Home | History | Annotate | Download | only in browser 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "android_webview/browser/browser_view_renderer.h"
      6 
      7 #include "android_webview/browser/browser_view_renderer_client.h"
      8 #include "android_webview/browser/shared_renderer_state.h"
      9 #include "android_webview/common/aw_switches.h"
     10 #include "android_webview/public/browser/draw_gl.h"
     11 #include "base/android/jni_android.h"
     12 #include "base/auto_reset.h"
     13 #include "base/command_line.h"
     14 #include "base/debug/trace_event.h"
     15 #include "base/json/json_writer.h"
     16 #include "base/logging.h"
     17 #include "base/strings/string_number_conversions.h"
     18 #include "base/strings/stringprintf.h"
     19 #include "cc/output/compositor_frame.h"
     20 #include "content/public/browser/browser_thread.h"
     21 #include "content/public/browser/web_contents.h"
     22 #include "content/public/common/content_switches.h"
     23 #include "gpu/command_buffer/service/gpu_switches.h"
     24 #include "third_party/skia/include/core/SkBitmap.h"
     25 #include "third_party/skia/include/core/SkCanvas.h"
     26 #include "third_party/skia/include/core/SkPicture.h"
     27 #include "third_party/skia/include/core/SkPictureRecorder.h"
     28 #include "ui/gfx/vector2d_conversions.h"
     29 
     30 using base::android::AttachCurrentThread;
     31 using base::android::JavaRef;
     32 using base::android::ScopedJavaLocalRef;
     33 using content::BrowserThread;
     34 using content::SynchronousCompositorMemoryPolicy;
     35 
     36 namespace android_webview {
     37 
     38 namespace {
     39 
     40 const int64 kFallbackTickTimeoutInMilliseconds = 100;
     41 
     42 // Used to calculate memory allocation. Determined experimentally.
     43 const size_t kMemoryMultiplier = 20;
     44 const size_t kBytesPerPixel = 4;
     45 const size_t kMemoryAllocationStep = 5 * 1024 * 1024;
     46 uint64 g_memory_override_in_bytes = 0u;
     47 
     48 // Used to calculate tile allocation. Determined experimentally.
     49 const size_t kTileMultiplier = 12;
     50 const size_t kTileAllocationStep = 20;
     51 // This will be set by static function CalculateTileMemoryPolicy() during init.
     52 // See AwMainDelegate::BasicStartupComplete.
     53 size_t g_tile_area;
     54 
     55 class TracedValue : public base::debug::ConvertableToTraceFormat {
     56  public:
     57   explicit TracedValue(base::Value* value) : value_(value) {}
     58   static scoped_refptr<base::debug::ConvertableToTraceFormat> FromValue(
     59       base::Value* value) {
     60     return scoped_refptr<base::debug::ConvertableToTraceFormat>(
     61         new TracedValue(value));
     62   }
     63   virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE {
     64     std::string tmp;
     65     base::JSONWriter::Write(value_.get(), &tmp);
     66     *out += tmp;
     67   }
     68 
     69  private:
     70   virtual ~TracedValue() {}
     71   scoped_ptr<base::Value> value_;
     72 
     73   DISALLOW_COPY_AND_ASSIGN(TracedValue);
     74 };
     75 
     76 }  // namespace
     77 
     78 // static
     79 void BrowserViewRenderer::CalculateTileMemoryPolicy(bool use_zero_copy) {
     80   CommandLine* cl = CommandLine::ForCurrentProcess();
     81 
     82   // If the value was overridden on the command line, use the specified value.
     83   bool client_hard_limit_bytes_overridden =
     84       cl->HasSwitch(switches::kForceGpuMemAvailableMb);
     85   if (client_hard_limit_bytes_overridden) {
     86     base::StringToUint64(
     87         base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
     88             switches::kForceGpuMemAvailableMb),
     89         &g_memory_override_in_bytes);
     90     g_memory_override_in_bytes *= 1024 * 1024;
     91   }
     92 
     93   if (!use_zero_copy) {
     94     // Use chrome's default tile size, which varies from 256 to 512.
     95     // Be conservative here and use the smallest tile size possible.
     96     g_tile_area = 256 * 256;
     97 
     98     // Also use a high tile limit since there are no file descriptor issues.
     99     // There is no need to limit number of tiles, so use an effectively
    100     // unlimited value as the limit.
    101     GlobalTileManager::GetInstance()->SetTileLimit(10 * 1000 * 1000);
    102     return;
    103   }
    104 
    105   const char kDefaultTileSize[] = "384";
    106 
    107   if (!cl->HasSwitch(switches::kDefaultTileWidth))
    108     cl->AppendSwitchASCII(switches::kDefaultTileWidth, kDefaultTileSize);
    109 
    110   if (!cl->HasSwitch(switches::kDefaultTileHeight))
    111     cl->AppendSwitchASCII(switches::kDefaultTileHeight, kDefaultTileSize);
    112 
    113   size_t tile_size;
    114   base::StringToSizeT(kDefaultTileSize, &tile_size);
    115   g_tile_area = tile_size * tile_size;
    116 }
    117 
    118 BrowserViewRenderer::BrowserViewRenderer(
    119     BrowserViewRendererClient* client,
    120     SharedRendererState* shared_renderer_state,
    121     content::WebContents* web_contents,
    122     const scoped_refptr<base::SingleThreadTaskRunner>& ui_task_runner)
    123     : client_(client),
    124       shared_renderer_state_(shared_renderer_state),
    125       web_contents_(web_contents),
    126       ui_task_runner_(ui_task_runner),
    127       compositor_(NULL),
    128       is_paused_(false),
    129       view_visible_(false),
    130       window_visible_(false),
    131       attached_to_window_(false),
    132       hardware_enabled_(false),
    133       dip_scale_(0.0),
    134       page_scale_factor_(1.0),
    135       on_new_picture_enable_(false),
    136       clear_view_(false),
    137       compositor_needs_continuous_invalidate_(false),
    138       invalidate_after_composite_(false),
    139       block_invalidates_(false),
    140       fallback_tick_pending_(false),
    141       width_(0),
    142       height_(0) {
    143   CHECK(web_contents_);
    144   content::SynchronousCompositor::SetClientForWebContents(web_contents_, this);
    145 
    146   // Currently the logic in this class relies on |compositor_| remaining
    147   // NULL until the DidInitializeCompositor() call, hence it is not set here.
    148 }
    149 
    150 BrowserViewRenderer::~BrowserViewRenderer() {
    151   content::SynchronousCompositor::SetClientForWebContents(web_contents_, NULL);
    152   // OnDetachedFromWindow should be called before the destructor, so the memory
    153   // policy should have already been updated.
    154 }
    155 
    156 // This function updates the resource allocation in GlobalTileManager.
    157 void BrowserViewRenderer::TrimMemory(const int level, const bool visible) {
    158   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    159   // Constants from Android ComponentCallbacks2.
    160   enum {
    161     TRIM_MEMORY_RUNNING_LOW = 10,
    162     TRIM_MEMORY_UI_HIDDEN = 20,
    163     TRIM_MEMORY_BACKGROUND = 40,
    164   };
    165 
    166   // Not urgent enough. TRIM_MEMORY_UI_HIDDEN is treated specially because
    167   // it does not indicate memory pressure, but merely that the app is
    168   // backgrounded.
    169   if (level < TRIM_MEMORY_RUNNING_LOW || level == TRIM_MEMORY_UI_HIDDEN)
    170     return;
    171 
    172   // Do not release resources on view we expect to get DrawGL soon.
    173   if (level < TRIM_MEMORY_BACKGROUND && visible)
    174     return;
    175 
    176   // Just set the memory limit to 0 and drop all tiles. This will be reset to
    177   // normal levels in the next DrawGL call.
    178   SynchronousCompositorMemoryPolicy zero_policy;
    179   if (memory_policy_ == zero_policy)
    180     return;
    181 
    182   TRACE_EVENT0("android_webview", "BrowserViewRenderer::TrimMemory");
    183   DCHECK(hardware_enabled_);
    184   DCHECK(compositor_);
    185 
    186   RequestMemoryPolicy(zero_policy);
    187   EnforceMemoryPolicyImmediately(zero_policy);
    188 }
    189 
    190 SynchronousCompositorMemoryPolicy
    191 BrowserViewRenderer::CalculateDesiredMemoryPolicy() {
    192   SynchronousCompositorMemoryPolicy policy;
    193   size_t width = last_on_draw_global_visible_rect_.width();
    194   size_t height = last_on_draw_global_visible_rect_.height();
    195   policy.bytes_limit = kMemoryMultiplier * kBytesPerPixel * width * height;
    196   // Round up to a multiple of kMemoryAllocationStep.
    197   policy.bytes_limit =
    198       (policy.bytes_limit / kMemoryAllocationStep + 1) * kMemoryAllocationStep;
    199 
    200   if (g_memory_override_in_bytes)
    201     policy.bytes_limit = static_cast<size_t>(g_memory_override_in_bytes);
    202 
    203   size_t tiles = width * height * kTileMultiplier / g_tile_area;
    204   // Round up to a multiple of kTileAllocationStep. The minimum number of tiles
    205   // is also kTileAllocationStep.
    206   tiles = (tiles / kTileAllocationStep + 1) * kTileAllocationStep;
    207   policy.num_resources_limit = tiles;
    208   return policy;
    209 }
    210 
    211 // This function updates the cached memory policy in shared renderer state, as
    212 // well as the tile resource allocation in GlobalTileManager.
    213 void BrowserViewRenderer::RequestMemoryPolicy(
    214     SynchronousCompositorMemoryPolicy& new_policy) {
    215   DCHECK(compositor_);
    216   GlobalTileManager* manager = GlobalTileManager::GetInstance();
    217 
    218   // The following line will call BrowserViewRenderer::SetMemoryPolicy().
    219   manager->RequestTiles(new_policy, tile_manager_key_);
    220 }
    221 
    222 void BrowserViewRenderer::SetMemoryPolicy(
    223     SynchronousCompositorMemoryPolicy new_policy,
    224     bool effective_immediately) {
    225   memory_policy_ = new_policy;
    226   if (effective_immediately)
    227     EnforceMemoryPolicyImmediately(memory_policy_);
    228 }
    229 
    230 void BrowserViewRenderer::EnforceMemoryPolicyImmediately(
    231     SynchronousCompositorMemoryPolicy new_policy) {
    232   compositor_->SetMemoryPolicy(new_policy);
    233   ForceFakeCompositeSW();
    234 }
    235 
    236 SynchronousCompositorMemoryPolicy BrowserViewRenderer::GetMemoryPolicy() const {
    237   return memory_policy_;
    238 }
    239 
    240 bool BrowserViewRenderer::OnDraw(jobject java_canvas,
    241                                  bool is_hardware_canvas,
    242                                  const gfx::Vector2d& scroll,
    243                                  const gfx::Rect& global_visible_rect) {
    244   last_on_draw_scroll_offset_ = scroll;
    245   last_on_draw_global_visible_rect_ = global_visible_rect;
    246 
    247   if (clear_view_)
    248     return false;
    249 
    250   if (is_hardware_canvas && attached_to_window_ &&
    251       !switches::ForceAuxiliaryBitmap()) {
    252     return OnDrawHardware(java_canvas);
    253   }
    254 
    255   // Perform a software draw
    256   return OnDrawSoftware(java_canvas);
    257 }
    258 
    259 bool BrowserViewRenderer::OnDrawHardware(jobject java_canvas) {
    260   TRACE_EVENT0("android_webview", "BrowserViewRenderer::OnDrawHardware");
    261   if (!compositor_)
    262     return false;
    263 
    264   shared_renderer_state_->SetScrollOffset(last_on_draw_scroll_offset_);
    265 
    266   if (!hardware_enabled_) {
    267     hardware_enabled_ = compositor_->InitializeHwDraw();
    268     if (hardware_enabled_) {
    269       tile_manager_key_ = GlobalTileManager::GetInstance()->PushBack(this);
    270     }
    271   }
    272   if (!hardware_enabled_)
    273     return false;
    274 
    275   if (last_on_draw_global_visible_rect_.IsEmpty() &&
    276       parent_draw_constraints_.surface_rect.IsEmpty()) {
    277     TRACE_EVENT_INSTANT0("android_webview",
    278                          "EarlyOut_EmptyVisibleRect",
    279                          TRACE_EVENT_SCOPE_THREAD);
    280     shared_renderer_state_->SetForceInvalidateOnNextDrawGL(true);
    281     return client_->RequestDrawGL(java_canvas, false);
    282   }
    283 
    284   ReturnResourceFromParent();
    285   if (shared_renderer_state_->HasCompositorFrame()) {
    286     TRACE_EVENT_INSTANT0("android_webview",
    287                          "EarlyOut_PreviousFrameUnconsumed",
    288                          TRACE_EVENT_SCOPE_THREAD);
    289     DidSkipCompositeInDraw();
    290     return client_->RequestDrawGL(java_canvas, false);
    291   }
    292 
    293   scoped_ptr<cc::CompositorFrame> frame = CompositeHw();
    294   if (!frame.get())
    295     return false;
    296 
    297   shared_renderer_state_->SetCompositorFrame(frame.Pass(), false);
    298   GlobalTileManager::GetInstance()->DidUse(tile_manager_key_);
    299   return client_->RequestDrawGL(java_canvas, false);
    300 }
    301 
    302 scoped_ptr<cc::CompositorFrame> BrowserViewRenderer::CompositeHw() {
    303   SynchronousCompositorMemoryPolicy new_policy = CalculateDesiredMemoryPolicy();
    304   RequestMemoryPolicy(new_policy);
    305   compositor_->SetMemoryPolicy(memory_policy_);
    306 
    307   parent_draw_constraints_ = shared_renderer_state_->ParentDrawConstraints();
    308   gfx::Size surface_size(width_, height_);
    309   gfx::Rect viewport(surface_size);
    310   gfx::Rect clip = viewport;
    311   gfx::Transform transform_for_tile_priority =
    312       parent_draw_constraints_.transform;
    313 
    314   // If the WebView is on a layer, WebView does not know what transform is
    315   // applied onto the layer so global visible rect does not make sense here.
    316   // In this case, just use the surface rect for tiling.
    317   gfx::Rect viewport_rect_for_tile_priority;
    318   if (parent_draw_constraints_.is_layer ||
    319       last_on_draw_global_visible_rect_.IsEmpty()) {
    320     viewport_rect_for_tile_priority = parent_draw_constraints_.surface_rect;
    321   } else {
    322     viewport_rect_for_tile_priority = last_on_draw_global_visible_rect_;
    323   }
    324 
    325   scoped_ptr<cc::CompositorFrame> frame =
    326       compositor_->DemandDrawHw(surface_size,
    327                                 gfx::Transform(),
    328                                 viewport,
    329                                 clip,
    330                                 viewport_rect_for_tile_priority,
    331                                 transform_for_tile_priority);
    332   if (frame.get())
    333     DidComposite();
    334   return frame.Pass();
    335 }
    336 
    337 void BrowserViewRenderer::UpdateParentDrawConstraints() {
    338   // Post an invalidate if the parent draw constraints are stale and there is
    339   // no pending invalidate.
    340   bool needs_force_invalidate =
    341       shared_renderer_state_->NeedsForceInvalidateOnNextDrawGL();
    342   if (needs_force_invalidate ||
    343       !parent_draw_constraints_.Equals(
    344           shared_renderer_state_->ParentDrawConstraints())) {
    345     shared_renderer_state_->SetForceInvalidateOnNextDrawGL(false);
    346     EnsureContinuousInvalidation(true, needs_force_invalidate);
    347   }
    348 }
    349 
    350 void BrowserViewRenderer::ReturnUnusedResource(
    351     scoped_ptr<cc::CompositorFrame> frame) {
    352   if (!frame.get())
    353     return;
    354 
    355   cc::CompositorFrameAck frame_ack;
    356   cc::TransferableResource::ReturnResources(
    357       frame->delegated_frame_data->resource_list, &frame_ack.resources);
    358   if (compositor_ && !frame_ack.resources.empty())
    359     compositor_->ReturnResources(frame_ack);
    360 }
    361 
    362 void BrowserViewRenderer::ReturnResourceFromParent() {
    363   cc::CompositorFrameAck frame_ack;
    364   shared_renderer_state_->SwapReturnedResources(&frame_ack.resources);
    365   if (compositor_ && !frame_ack.resources.empty()) {
    366     compositor_->ReturnResources(frame_ack);
    367   }
    368 }
    369 
    370 void BrowserViewRenderer::DidSkipCommitFrame() {
    371   // Treat it the same way as skipping onDraw.
    372   DidSkipCompositeInDraw();
    373 }
    374 
    375 bool BrowserViewRenderer::OnDrawSoftware(jobject java_canvas) {
    376   if (!compositor_) {
    377     TRACE_EVENT_INSTANT0(
    378         "android_webview", "EarlyOut_NoCompositor", TRACE_EVENT_SCOPE_THREAD);
    379     return false;
    380   }
    381 
    382   // TODO(hush): right now webview size is passed in as the auxiliary bitmap
    383   // size, which might hurt performace (only for software draws with auxiliary
    384   // bitmap). For better performance, get global visible rect, transform it
    385   // from screen space to view space, then intersect with the webview in
    386   // viewspace.  Use the resulting rect as the auxiliary
    387   // bitmap.
    388   return BrowserViewRendererJavaHelper::GetInstance()
    389       ->RenderViaAuxilaryBitmapIfNeeded(
    390           java_canvas,
    391           last_on_draw_scroll_offset_,
    392           gfx::Size(width_, height_),
    393           base::Bind(&BrowserViewRenderer::CompositeSW,
    394                      base::Unretained(this)));
    395 }
    396 
    397 skia::RefPtr<SkPicture> BrowserViewRenderer::CapturePicture(int width,
    398                                                             int height) {
    399   TRACE_EVENT0("android_webview", "BrowserViewRenderer::CapturePicture");
    400 
    401   // Return empty Picture objects for empty SkPictures.
    402   if (width <= 0 || height <= 0) {
    403     SkPictureRecorder emptyRecorder;
    404     emptyRecorder.beginRecording(0, 0);
    405     return skia::AdoptRef(emptyRecorder.endRecording());
    406   }
    407 
    408   // Reset scroll back to the origin, will go back to the old
    409   // value when scroll_reset is out of scope.
    410   base::AutoReset<gfx::Vector2dF> scroll_reset(&scroll_offset_dip_,
    411                                                gfx::Vector2dF());
    412 
    413   SkPictureRecorder recorder;
    414   SkCanvas* rec_canvas = recorder.beginRecording(width, height, NULL, 0);
    415   if (compositor_)
    416     CompositeSW(rec_canvas);
    417   return skia::AdoptRef(recorder.endRecording());
    418 }
    419 
    420 void BrowserViewRenderer::EnableOnNewPicture(bool enabled) {
    421   on_new_picture_enable_ = enabled;
    422 }
    423 
    424 void BrowserViewRenderer::ClearView() {
    425   TRACE_EVENT_INSTANT0("android_webview",
    426                        "BrowserViewRenderer::ClearView",
    427                        TRACE_EVENT_SCOPE_THREAD);
    428   if (clear_view_)
    429     return;
    430 
    431   clear_view_ = true;
    432   // Always invalidate ignoring the compositor to actually clear the webview.
    433   EnsureContinuousInvalidation(true, false);
    434 }
    435 
    436 void BrowserViewRenderer::SetIsPaused(bool paused) {
    437   TRACE_EVENT_INSTANT1("android_webview",
    438                        "BrowserViewRenderer::SetIsPaused",
    439                        TRACE_EVENT_SCOPE_THREAD,
    440                        "paused",
    441                        paused);
    442   is_paused_ = paused;
    443   EnsureContinuousInvalidation(false, false);
    444 }
    445 
    446 void BrowserViewRenderer::SetViewVisibility(bool view_visible) {
    447   TRACE_EVENT_INSTANT1("android_webview",
    448                        "BrowserViewRenderer::SetViewVisibility",
    449                        TRACE_EVENT_SCOPE_THREAD,
    450                        "view_visible",
    451                        view_visible);
    452   view_visible_ = view_visible;
    453 }
    454 
    455 void BrowserViewRenderer::SetWindowVisibility(bool window_visible) {
    456   TRACE_EVENT_INSTANT1("android_webview",
    457                        "BrowserViewRenderer::SetWindowVisibility",
    458                        TRACE_EVENT_SCOPE_THREAD,
    459                        "window_visible",
    460                        window_visible);
    461   window_visible_ = window_visible;
    462   EnsureContinuousInvalidation(false, false);
    463 }
    464 
    465 void BrowserViewRenderer::OnSizeChanged(int width, int height) {
    466   TRACE_EVENT_INSTANT2("android_webview",
    467                        "BrowserViewRenderer::OnSizeChanged",
    468                        TRACE_EVENT_SCOPE_THREAD,
    469                        "width",
    470                        width,
    471                        "height",
    472                        height);
    473   width_ = width;
    474   height_ = height;
    475 }
    476 
    477 void BrowserViewRenderer::OnAttachedToWindow(int width, int height) {
    478   TRACE_EVENT2("android_webview",
    479                "BrowserViewRenderer::OnAttachedToWindow",
    480                "width",
    481                width,
    482                "height",
    483                height);
    484   attached_to_window_ = true;
    485   width_ = width;
    486   height_ = height;
    487 }
    488 
    489 void BrowserViewRenderer::OnDetachedFromWindow() {
    490   TRACE_EVENT0("android_webview", "BrowserViewRenderer::OnDetachedFromWindow");
    491   attached_to_window_ = false;
    492   DCHECK(!hardware_enabled_);
    493 }
    494 
    495 void BrowserViewRenderer::ReleaseHardware() {
    496   DCHECK(hardware_enabled_);
    497   ReturnUnusedResource(shared_renderer_state_->PassCompositorFrame());
    498   ReturnResourceFromParent();
    499   DCHECK(shared_renderer_state_->ReturnedResourcesEmpty());
    500 
    501   if (compositor_) {
    502     compositor_->ReleaseHwDraw();
    503     SynchronousCompositorMemoryPolicy zero_policy;
    504     RequestMemoryPolicy(zero_policy);
    505   }
    506 
    507   hardware_enabled_ = false;
    508   GlobalTileManager::GetInstance()->Remove(tile_manager_key_);
    509 }
    510 
    511 bool BrowserViewRenderer::IsVisible() const {
    512   // Ignore |window_visible_| if |attached_to_window_| is false.
    513   return view_visible_ && (!attached_to_window_ || window_visible_);
    514 }
    515 
    516 gfx::Rect BrowserViewRenderer::GetScreenRect() const {
    517   return gfx::Rect(client_->GetLocationOnScreen(), gfx::Size(width_, height_));
    518 }
    519 
    520 void BrowserViewRenderer::DidInitializeCompositor(
    521     content::SynchronousCompositor* compositor) {
    522   TRACE_EVENT0("android_webview",
    523                "BrowserViewRenderer::DidInitializeCompositor");
    524   DCHECK(compositor);
    525   DCHECK(!compositor_);
    526   compositor_ = compositor;
    527 }
    528 
    529 void BrowserViewRenderer::DidDestroyCompositor(
    530     content::SynchronousCompositor* compositor) {
    531   TRACE_EVENT0("android_webview", "BrowserViewRenderer::DidDestroyCompositor");
    532   DCHECK(compositor_);
    533   SynchronousCompositorMemoryPolicy zero_policy;
    534   if (hardware_enabled_) {
    535     RequestMemoryPolicy(zero_policy);
    536   }
    537   DCHECK(memory_policy_ == zero_policy);
    538   compositor_ = NULL;
    539 }
    540 
    541 void BrowserViewRenderer::SetContinuousInvalidate(bool invalidate) {
    542   if (compositor_needs_continuous_invalidate_ == invalidate)
    543     return;
    544 
    545   TRACE_EVENT_INSTANT1("android_webview",
    546                        "BrowserViewRenderer::SetContinuousInvalidate",
    547                        TRACE_EVENT_SCOPE_THREAD,
    548                        "invalidate",
    549                        invalidate);
    550   compositor_needs_continuous_invalidate_ = invalidate;
    551 
    552   EnsureContinuousInvalidation(false, false);
    553 }
    554 
    555 void BrowserViewRenderer::SetDipScale(float dip_scale) {
    556   dip_scale_ = dip_scale;
    557   CHECK_GT(dip_scale_, 0);
    558 }
    559 
    560 gfx::Vector2d BrowserViewRenderer::max_scroll_offset() const {
    561   DCHECK_GT(dip_scale_, 0);
    562   return gfx::ToCeiledVector2d(gfx::ScaleVector2d(
    563       max_scroll_offset_dip_, dip_scale_ * page_scale_factor_));
    564 }
    565 
    566 void BrowserViewRenderer::ScrollTo(gfx::Vector2d scroll_offset) {
    567   gfx::Vector2d max_offset = max_scroll_offset();
    568   gfx::Vector2dF scroll_offset_dip;
    569   // To preserve the invariant that scrolling to the maximum physical pixel
    570   // value also scrolls to the maximum dip pixel value we transform the physical
    571   // offset into the dip offset by using a proportion (instead of dividing by
    572   // dip_scale * page_scale_factor).
    573   if (max_offset.x()) {
    574     scroll_offset_dip.set_x((scroll_offset.x() * max_scroll_offset_dip_.x()) /
    575                             max_offset.x());
    576   }
    577   if (max_offset.y()) {
    578     scroll_offset_dip.set_y((scroll_offset.y() * max_scroll_offset_dip_.y()) /
    579                             max_offset.y());
    580   }
    581 
    582   DCHECK_LE(0, scroll_offset_dip.x());
    583   DCHECK_LE(0, scroll_offset_dip.y());
    584   DCHECK_LE(scroll_offset_dip.x(), max_scroll_offset_dip_.x());
    585   DCHECK_LE(scroll_offset_dip.y(), max_scroll_offset_dip_.y());
    586 
    587   if (scroll_offset_dip_ == scroll_offset_dip)
    588     return;
    589 
    590   scroll_offset_dip_ = scroll_offset_dip;
    591 
    592   TRACE_EVENT_INSTANT2("android_webview",
    593                "BrowserViewRenderer::ScrollTo",
    594                TRACE_EVENT_SCOPE_THREAD,
    595                "x",
    596                scroll_offset_dip.x(),
    597                "y",
    598                scroll_offset_dip.y());
    599 
    600   if (compositor_)
    601     compositor_->DidChangeRootLayerScrollOffset();
    602 }
    603 
    604 void BrowserViewRenderer::DidUpdateContent() {
    605   TRACE_EVENT_INSTANT0("android_webview",
    606                        "BrowserViewRenderer::DidUpdateContent",
    607                        TRACE_EVENT_SCOPE_THREAD);
    608   clear_view_ = false;
    609   if (on_new_picture_enable_)
    610     client_->OnNewPicture();
    611 }
    612 
    613 void BrowserViewRenderer::SetTotalRootLayerScrollOffset(
    614     gfx::Vector2dF scroll_offset_dip) {
    615   // TOOD(mkosiba): Add a DCHECK to say that this does _not_ get called during
    616   // DrawGl when http://crbug.com/249972 is fixed.
    617   if (scroll_offset_dip_ == scroll_offset_dip)
    618     return;
    619 
    620   scroll_offset_dip_ = scroll_offset_dip;
    621 
    622   gfx::Vector2d max_offset = max_scroll_offset();
    623   gfx::Vector2d scroll_offset;
    624   // For an explanation as to why this is done this way see the comment in
    625   // BrowserViewRenderer::ScrollTo.
    626   if (max_scroll_offset_dip_.x()) {
    627     scroll_offset.set_x((scroll_offset_dip.x() * max_offset.x()) /
    628                         max_scroll_offset_dip_.x());
    629   }
    630 
    631   if (max_scroll_offset_dip_.y()) {
    632     scroll_offset.set_y((scroll_offset_dip.y() * max_offset.y()) /
    633                         max_scroll_offset_dip_.y());
    634   }
    635 
    636   DCHECK_LE(0, scroll_offset.x());
    637   DCHECK_LE(0, scroll_offset.y());
    638   DCHECK_LE(scroll_offset.x(), max_offset.x());
    639   DCHECK_LE(scroll_offset.y(), max_offset.y());
    640 
    641   client_->ScrollContainerViewTo(scroll_offset);
    642 }
    643 
    644 gfx::Vector2dF BrowserViewRenderer::GetTotalRootLayerScrollOffset() {
    645   return scroll_offset_dip_;
    646 }
    647 
    648 bool BrowserViewRenderer::IsExternalFlingActive() const {
    649   return client_->IsFlingActive();
    650 }
    651 
    652 void BrowserViewRenderer::UpdateRootLayerState(
    653     const gfx::Vector2dF& total_scroll_offset_dip,
    654     const gfx::Vector2dF& max_scroll_offset_dip,
    655     const gfx::SizeF& scrollable_size_dip,
    656     float page_scale_factor,
    657     float min_page_scale_factor,
    658     float max_page_scale_factor) {
    659   TRACE_EVENT_INSTANT1(
    660       "android_webview",
    661       "BrowserViewRenderer::UpdateRootLayerState",
    662       TRACE_EVENT_SCOPE_THREAD,
    663       "state",
    664       TracedValue::FromValue(
    665           RootLayerStateAsValue(total_scroll_offset_dip, scrollable_size_dip)
    666               .release()));
    667 
    668   DCHECK_GT(dip_scale_, 0);
    669 
    670   max_scroll_offset_dip_ = max_scroll_offset_dip;
    671   DCHECK_LE(0, max_scroll_offset_dip_.x());
    672   DCHECK_LE(0, max_scroll_offset_dip_.y());
    673 
    674   page_scale_factor_ = page_scale_factor;
    675   DCHECK_GT(page_scale_factor_, 0);
    676 
    677   client_->UpdateScrollState(max_scroll_offset(),
    678                              scrollable_size_dip,
    679                              page_scale_factor,
    680                              min_page_scale_factor,
    681                              max_page_scale_factor);
    682   SetTotalRootLayerScrollOffset(total_scroll_offset_dip);
    683 }
    684 
    685 scoped_ptr<base::Value> BrowserViewRenderer::RootLayerStateAsValue(
    686     const gfx::Vector2dF& total_scroll_offset_dip,
    687     const gfx::SizeF& scrollable_size_dip) {
    688   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue);
    689 
    690   state->SetDouble("total_scroll_offset_dip.x", total_scroll_offset_dip.x());
    691   state->SetDouble("total_scroll_offset_dip.y", total_scroll_offset_dip.y());
    692 
    693   state->SetDouble("max_scroll_offset_dip.x", max_scroll_offset_dip_.x());
    694   state->SetDouble("max_scroll_offset_dip.y", max_scroll_offset_dip_.y());
    695 
    696   state->SetDouble("scrollable_size_dip.width", scrollable_size_dip.width());
    697   state->SetDouble("scrollable_size_dip.height", scrollable_size_dip.height());
    698 
    699   state->SetDouble("page_scale_factor", page_scale_factor_);
    700   return state.PassAs<base::Value>();
    701 }
    702 
    703 void BrowserViewRenderer::DidOverscroll(gfx::Vector2dF accumulated_overscroll,
    704                                         gfx::Vector2dF latest_overscroll_delta,
    705                                         gfx::Vector2dF current_fling_velocity) {
    706   const float physical_pixel_scale = dip_scale_ * page_scale_factor_;
    707   if (accumulated_overscroll == latest_overscroll_delta)
    708     overscroll_rounding_error_ = gfx::Vector2dF();
    709   gfx::Vector2dF scaled_overscroll_delta =
    710       gfx::ScaleVector2d(latest_overscroll_delta, physical_pixel_scale);
    711   gfx::Vector2d rounded_overscroll_delta = gfx::ToRoundedVector2d(
    712       scaled_overscroll_delta + overscroll_rounding_error_);
    713   overscroll_rounding_error_ =
    714       scaled_overscroll_delta - rounded_overscroll_delta;
    715   client_->DidOverscroll(rounded_overscroll_delta);
    716 }
    717 
    718 void BrowserViewRenderer::EnsureContinuousInvalidation(
    719     bool force_invalidate,
    720     bool skip_reschedule_tick) {
    721   if (force_invalidate)
    722     invalidate_after_composite_ = true;
    723 
    724   // This method should be called again when any of these conditions change.
    725   bool need_invalidate =
    726       compositor_needs_continuous_invalidate_ || invalidate_after_composite_;
    727   if (!need_invalidate || block_invalidates_)
    728     return;
    729 
    730   if (!compositor_needs_continuous_invalidate_ && invalidate_after_composite_)
    731     invalidate_after_composite_ = false;
    732 
    733   // Always call view invalidate. We rely the Android framework to ignore the
    734   // invalidate when it's not needed such as when view is not visible.
    735   client_->PostInvalidate();
    736 
    737   // Stop fallback ticks when one of these is true.
    738   // 1) Webview is paused. Also need to check we are not in clear view since
    739   // paused, offscreen still expect clear view to recover.
    740   // 2) If we are attached to window and the window is not visible (eg when
    741   // app is in the background). We are sure in this case the webview is used
    742   // "on-screen" but that updates are not needed when in the background.
    743   bool throttle_fallback_tick =
    744       (is_paused_ && !clear_view_) || (attached_to_window_ && !window_visible_);
    745   if (throttle_fallback_tick)
    746     return;
    747 
    748   block_invalidates_ = compositor_needs_continuous_invalidate_;
    749   if (skip_reschedule_tick && fallback_tick_pending_)
    750     return;
    751 
    752   // Unretained here is safe because the callbacks are cancelled when
    753   // they are destroyed.
    754   post_fallback_tick_.Reset(base::Bind(&BrowserViewRenderer::PostFallbackTick,
    755                                        base::Unretained(this)));
    756   fallback_tick_fired_.Cancel();
    757   fallback_tick_pending_ = false;
    758 
    759   // No need to reschedule fallback tick if compositor does not need to be
    760   // ticked. This can happen if this is reached because force_invalidate is
    761   // true.
    762   if (compositor_needs_continuous_invalidate_) {
    763     fallback_tick_pending_ = true;
    764     ui_task_runner_->PostTask(FROM_HERE, post_fallback_tick_.callback());
    765   }
    766 }
    767 
    768 void BrowserViewRenderer::PostFallbackTick() {
    769   DCHECK(fallback_tick_fired_.IsCancelled());
    770   fallback_tick_fired_.Reset(base::Bind(&BrowserViewRenderer::FallbackTickFired,
    771                                         base::Unretained(this)));
    772   if (compositor_needs_continuous_invalidate_) {
    773     ui_task_runner_->PostDelayedTask(
    774         FROM_HERE,
    775         fallback_tick_fired_.callback(),
    776         base::TimeDelta::FromMilliseconds(kFallbackTickTimeoutInMilliseconds));
    777   } else {
    778     // Pretend we just composited to unblock further invalidates.
    779     DidComposite();
    780   }
    781 }
    782 
    783 void BrowserViewRenderer::FallbackTickFired() {
    784   TRACE_EVENT1("android_webview",
    785                "BrowserViewRenderer::FallbackTickFired",
    786                "compositor_needs_continuous_invalidate_",
    787                compositor_needs_continuous_invalidate_);
    788 
    789   // This should only be called if OnDraw or DrawGL did not come in time, which
    790   // means block_invalidates_ must still be true.
    791   DCHECK(block_invalidates_);
    792   fallback_tick_pending_ = false;
    793   if (compositor_needs_continuous_invalidate_ && compositor_) {
    794     if (hardware_enabled_) {
    795       ReturnResourceFromParent();
    796       ReturnUnusedResource(shared_renderer_state_->PassCompositorFrame());
    797       scoped_ptr<cc::CompositorFrame> frame = CompositeHw();
    798       if (frame.get()) {
    799         shared_renderer_state_->SetCompositorFrame(frame.Pass(), true);
    800       }
    801     } else {
    802       ForceFakeCompositeSW();
    803     }
    804   } else {
    805     // Pretend we just composited to unblock further invalidates.
    806     DidComposite();
    807   }
    808 }
    809 
    810 void BrowserViewRenderer::ForceFakeCompositeSW() {
    811   DCHECK(compositor_);
    812   SkBitmap bitmap;
    813   bitmap.allocN32Pixels(1, 1);
    814   bitmap.eraseColor(0);
    815   SkCanvas canvas(bitmap);
    816   CompositeSW(&canvas);
    817 }
    818 
    819 bool BrowserViewRenderer::CompositeSW(SkCanvas* canvas) {
    820   DCHECK(compositor_);
    821   ReturnResourceFromParent();
    822   bool result = compositor_->DemandDrawSw(canvas);
    823   DidComposite();
    824   return result;
    825 }
    826 
    827 void BrowserViewRenderer::DidComposite() {
    828   block_invalidates_ = false;
    829   post_fallback_tick_.Cancel();
    830   fallback_tick_fired_.Cancel();
    831   fallback_tick_pending_ = false;
    832   EnsureContinuousInvalidation(false, false);
    833 }
    834 
    835 void BrowserViewRenderer::DidSkipCompositeInDraw() {
    836   block_invalidates_ = false;
    837   EnsureContinuousInvalidation(true, true);
    838 }
    839 
    840 std::string BrowserViewRenderer::ToString(AwDrawGLInfo* draw_info) const {
    841   std::string str;
    842   base::StringAppendF(&str, "is_paused: %d ", is_paused_);
    843   base::StringAppendF(&str, "view_visible: %d ", view_visible_);
    844   base::StringAppendF(&str, "window_visible: %d ", window_visible_);
    845   base::StringAppendF(&str, "dip_scale: %f ", dip_scale_);
    846   base::StringAppendF(&str, "page_scale_factor: %f ", page_scale_factor_);
    847   base::StringAppendF(&str,
    848                       "compositor_needs_continuous_invalidate: %d ",
    849                       compositor_needs_continuous_invalidate_);
    850   base::StringAppendF(&str, "block_invalidates: %d ", block_invalidates_);
    851   base::StringAppendF(&str, "view width height: [%d %d] ", width_, height_);
    852   base::StringAppendF(&str, "attached_to_window: %d ", attached_to_window_);
    853   base::StringAppendF(&str,
    854                       "global visible rect: %s ",
    855                       last_on_draw_global_visible_rect_.ToString().c_str());
    856   base::StringAppendF(
    857       &str, "scroll_offset_dip: %s ", scroll_offset_dip_.ToString().c_str());
    858   base::StringAppendF(&str,
    859                       "overscroll_rounding_error_: %s ",
    860                       overscroll_rounding_error_.ToString().c_str());
    861   base::StringAppendF(
    862       &str, "on_new_picture_enable: %d ", on_new_picture_enable_);
    863   base::StringAppendF(&str, "clear_view: %d ", clear_view_);
    864   if (draw_info) {
    865     base::StringAppendF(&str,
    866                         "clip left top right bottom: [%d %d %d %d] ",
    867                         draw_info->clip_left,
    868                         draw_info->clip_top,
    869                         draw_info->clip_right,
    870                         draw_info->clip_bottom);
    871     base::StringAppendF(&str,
    872                         "surface width height: [%d %d] ",
    873                         draw_info->width,
    874                         draw_info->height);
    875     base::StringAppendF(&str, "is_layer: %d ", draw_info->is_layer);
    876   }
    877   return str;
    878 }
    879 
    880 }  // namespace android_webview
    881