Fix UpdateTilePriorities viewport in Android WebView.

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
@@ skipping 179 matching lines @@
       memory_history_(MemoryHistory::Create()),
       debug_rect_history_(DebugRectHistory::Create()),
       max_memory_needed_bytes_(0),
       last_sent_memory_visible_bytes_(0),
       last_sent_memory_visible_and_nearby_bytes_(0),
       last_sent_memory_use_bytes_(0),
       zero_budget_(false),
       device_scale_factor_(1.f),
       overhang_ui_resource_id_(0),
       overdraw_bottom_height_(0.f),
+      device_viewport_valid_for_tile_management_(true),
       external_stencil_test_enabled_(false),
       animation_registrar_(AnimationRegistrar::Create()),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       need_to_update_visible_tiles_before_draw_(false) {
   DCHECK(proxy_->IsImplThread());
   DidVisibilityChange(this, visible_);
 
   SetDebugState(settings.initial_debug_state);
 
   if (settings.calculate_top_controls_position) {
@@ skipping 76 matching lines @@
   // draw_and_swap_full_viewport_every_frame check. Tracked in crbug.com/264967.
   if (!active_tree_->root_layer()) {
     TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no root layer",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   if (output_surface_->capabilities().draw_and_swap_full_viewport_every_frame)
     return true;
 
-  if (device_viewport_size_.IsEmpty()) {
+  if (DrawViewportSize().IsEmpty()) {
     TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw empty viewport",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
   if (active_tree_->ViewportSizeInvalid()) {
     TRACE_EVENT_INSTANT0(
         "cc", "LayerTreeHostImpl::CanDraw viewport size recently changed",
         TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
@@ skipping 14 matching lines @@
   AnimateLayers(monotonic_time, wall_clock_time);
   AnimateScrollbars(monotonic_time);
   AnimateTopControls(monotonic_time);
 }
 
 void LayerTreeHostImpl::ManageTiles() {
   if (!tile_manager_)
     return;
   if (!manage_tiles_needed_)
     return;
+  if (!device_viewport_valid_for_tile_management_)
+    return;
+
   manage_tiles_needed_ = false;
   tile_manager_->ManageTiles();
 
   size_t memory_required_bytes;
   size_t memory_nice_to_have_bytes;
   size_t memory_allocated_bytes;
   size_t memory_used_bytes;
   tile_manager_->GetMemoryStats(&memory_required_bytes,
                                 &memory_nice_to_have_bytes,
                                 &memory_allocated_bytes,
                                 &memory_used_bytes);
   SendManagedMemoryStats(memory_required_bytes,
                          memory_nice_to_have_bytes,
                          memory_used_bytes);
 }
 
 void LayerTreeHostImpl::StartPageScaleAnimation(gfx::Vector2d target_offset,
                                                 bool anchor_point,
                                                 float page_scale,
                                                 base::TimeTicks start_time,
                                                 base::TimeDelta duration) {
   if (!RootScrollLayer())
     return;
 
   gfx::Vector2dF scroll_total =
       RootScrollLayer()->scroll_offset() + RootScrollLayer()->ScrollDelta();
   gfx::SizeF scaled_scrollable_size = active_tree_->ScrollableSize();
-  gfx::SizeF viewport_size = VisibleViewportSize();
+  gfx::SizeF viewport_size = UnscaledScrollableViewportSize();
 
   double start_time_seconds = (start_time - base::TimeTicks()).InSecondsF();
 
   // Easing constants experimentally determined.
   scoped_ptr<TimingFunction> timing_function =
       CubicBezierTimingFunction::Create(.8, 0, .3, .9).PassAs<TimingFunction>();
 
   page_scale_animation_ =
       PageScaleAnimation::Create(scroll_total,
                                  active_tree_->total_page_scale_factor(),
@@ skipping 811 matching lines @@
           old_policy.priority_cutoff_when_visible) {
     needs_commit = false;
   }
 
   if (needs_commit)
     client_->SetNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::SetExternalDrawConstraints(
     const gfx::Transform& transform,
-    gfx::Rect viewport) {
+    gfx::Rect viewport,
+    gfx::Rect clip,
+    bool valid_for_tile_management) {
   external_transform_ = transform;
   external_viewport_ = viewport;
+  external_clip_ = clip;
+  device_viewport_valid_for_tile_management_ = valid_for_tile_management;
 }
 
 void LayerTreeHostImpl::SetExternalStencilTest(bool enabled) {
   external_stencil_test_enabled_ = enabled;
 }
 
 void LayerTreeHostImpl::SetNeedsRedrawRect(gfx::Rect damage_rect) {
   client_->SetNeedsRedrawRectOnImplThread(damage_rect);
 }
 
@@ skipping 180 matching lines @@
 
 void LayerTreeHostImpl::SetNeedsBeginFrame(bool enable) {
   if (output_surface_)
     output_surface_->SetNeedsBeginFrame(enable);
 }
 
 float LayerTreeHostImpl::DeviceScaleFactor() const {
   return device_scale_factor_;
 }
 
-gfx::SizeF LayerTreeHostImpl::VisibleViewportSize() const {
+gfx::SizeF LayerTreeHostImpl::UnscaledScrollableViewportSize() const {
   // The container layer bounds should be used if non-overlay scrollbars may
   // exist since it adjusts for them.
   LayerImpl* container_layer = active_tree_->RootContainerLayer();
   if (!Settings().solid_color_scrollbars && container_layer) {
     DCHECK(!top_controls_manager_);
     DCHECK_EQ(0, overdraw_bottom_height_);
     return container_layer->bounds();
   }
 
   gfx::SizeF dip_size =
-      gfx::ScaleSize(device_viewport_size(), 1.f / device_scale_factor());
+      gfx::ScaleSize(device_viewport_size_, 1.f / device_scale_factor());
 
   float top_offset =
       top_controls_manager_ ? top_controls_manager_->content_top_offset() : 0.f;
   return gfx::SizeF(dip_size.width(),
                     dip_size.height() - top_offset - overdraw_bottom_height_);
 }
 
 const LayerTreeSettings& LayerTreeHostImpl::Settings() const {
   return settings();
 }
@@ skipping 374 matching lines @@
 
   SetOffscreenContextProvider(NULL);
 
   client_->SetNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::SetViewportSize(gfx::Size device_viewport_size) {
   if (device_viewport_size == device_viewport_size_)
     return;
 
-  if (pending_tree_ && device_viewport_size_ != device_viewport_size)
+  if (pending_tree_)
     active_tree_->SetViewportSizeInvalid();
 
   device_viewport_size_ = device_viewport_size;
 
   UpdateMaxScrollOffset();
 
   if (renderer_)
     renderer_->ViewportChanged();
 
   client_->OnCanDrawStateChanged(CanDraw());
@@ skipping 21 matching lines @@
     return;
   device_scale_factor_ = device_scale_factor;
 
   if (renderer_)
     renderer_->ViewportChanged();
 
   UpdateMaxScrollOffset();
   SetFullRootLayerDamage();
 }
 
+gfx::Size LayerTreeHostImpl::DrawViewportSize() const {
+  return DeviceViewport().size();
+}
+
 gfx::Rect LayerTreeHostImpl::DeviceViewport() const {
   if (external_viewport_.IsEmpty())
     return gfx::Rect(device_viewport_size_);
 
   return external_viewport_;
 }
 
-const gfx::Transform& LayerTreeHostImpl::DeviceTransform() const {
+gfx::Rect LayerTreeHostImpl::DeviceClip() const {
+  if (external_clip_.IsEmpty())
+    return DeviceViewport();
+
+  return external_clip_;
+}
+
+const gfx::Transform& LayerTreeHostImpl::DrawTransform() const {
   return external_transform_;
 }
 
 void LayerTreeHostImpl::UpdateMaxScrollOffset() {
   active_tree_->UpdateMaxScrollOffset();
 }
 
 void LayerTreeHostImpl::DidChangeTopControlsPosition() {
   client_->SetNeedsRedrawOnImplThread();
   active_tree_->set_needs_update_draw_properties();
@@ skipping 432 matching lines @@
   scoped_ptr<ScrollAndScaleSet> scroll_info(new ScrollAndScaleSet());
 
   CollectScrollDeltas(scroll_info.get(), active_tree_->root_layer());
   scroll_info->page_scale_delta = active_tree_->page_scale_delta();
   active_tree_->set_sent_page_scale_delta(scroll_info->page_scale_delta);
 
   return scroll_info.Pass();
 }
 
 void LayerTreeHostImpl::SetFullRootLayerDamage() {
-  SetViewportDamage(gfx::Rect(device_viewport_size_));
+  SetViewportDamage(gfx::Rect(DrawViewportSize()));
 }
 
 void LayerTreeHostImpl::AnimatePageScale(base::TimeTicks time) {
   if (!page_scale_animation_ || !RootScrollLayer())
     return;
 
   double monotonic_time = (time - base::TimeTicks()).InSecondsF();
   gfx::Vector2dF scroll_total = RootScrollLayer()->scroll_offset() +
                                 RootScrollLayer()->ScrollDelta();
 
@@ skipping 299 matching lines @@
 
 ResourceProvider::ResourceId LayerTreeHostImpl::ResourceIdForUIResource(
     UIResourceId uid) const {
   UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
   if (iter != ui_resource_map_.end())
     return iter->second;
   return 0;
 }
 
 }  // namespace cc