cc: Force an update on tile size after viewport resize

cc/trees/layer_tree_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_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 519 matching lines @@
                                            root_layer_scroll_offset_delegate_,
                                            this));
 }
 
 void LayerTreeImpl::ClearViewportLayers() {
   page_scale_layer_ = NULL;
   inner_viewport_scroll_layer_ = NULL;
   outer_viewport_scroll_layer_ = NULL;
 }
 
-bool LayerTreeImpl::UpdateDrawProperties(bool update_lcd_text) {
+bool LayerTreeImpl::UpdateDrawProperties(bool first_update_after_commit) {
   if (!needs_update_draw_properties_)
     return true;
 
   // Calling UpdateDrawProperties must clear this flag, so there can be no
   // early outs before this.
   needs_update_draw_properties_ = false;
 
   // For max_texture_size.  When the renderer is re-created in
   // CreateAndSetRenderer, the needs update draw properties flag is set
   // again.
@@ skipping 104 matching lines @@
 
     unoccluded_screen_space_region_ =
         occlusion_tracker.ComputeVisibleRegionInScreen();
   }
 
   // It'd be ideal if this could be done earlier, but when the raster source
   // is updated from the main thread during push properties, update draw
   // properties has not occurred yet and so it's not clear whether or not the
   // layer can or cannot use lcd text.  So, this is the cleanup pass to
   // determine if the raster source needs to be replaced with a non-lcd
-  // raster source due to draw properties.
-  if (update_lcd_text) {
+  // raster source due to draw properties. We also check for changes in the
+  // viewport size here and if using GPU rasterization, notify the layers
+  // that they need to recalculate the tiling texture size.
+  if (first_update_after_commit) {
     // TODO(enne): Make LTHI::sync_tree return this value.
     LayerTreeImpl* sync_tree =
         layer_tree_host_impl_->proxy()->CommitToActiveTree()
             ? layer_tree_host_impl_->active_tree()
             : layer_tree_host_impl_->pending_tree();
     // If this is not the sync tree, then it is not safe to update lcd text
     // as it causes invalidations and the tiles may be in use.
     DCHECK_EQ(this, sync_tree);
-    for (const auto& layer : picture_layers_)
+
+    bool layersNeedNotificationOfViewportChange =

[enne (OOO), 2015/03/19 17:55:24]

layers_need_notification_etc

+        layer_tree_host_impl_->active_tree()->ViewportSizeInvalid() &&

[enne (OOO), 2015/03/19 17:55:24]

This will not work.  If you commit to the active tree, then there will not be a
pending tree, and ViewportSizeInvalid will not be true.  Then you will not
update the tile size until the next time a layer has a push properties.

+        layer_tree_host_impl_->use_gpu_rasterization();

[enne (OOO), 2015/03/19 17:55:24]

This is leaking implementation details of PictureLayerImpl, somewhat.  I'd just
always call it and let the PictureLayerImpl function early out.

+
+    for (const auto& layer : picture_layers_) {
       layer->UpdateCanUseLCDTextAfterCommit();
+      if (layersNeedNotificationOfViewportChange)
+        layer->UpdateViewportAfterCommit();
+    }
   }
 
   {
     TRACE_EVENT_BEGIN2("cc", "LayerTreeImpl::UpdateDrawProperties::UpdateTiles",
                        "IsActive", IsActiveTree(), "SourceFrameNumber",
                        source_frame_number_);
     const bool resourceless_software_draw =
         (layer_tree_host_impl_->GetDrawMode() ==
          DRAW_MODE_RESOURCELESS_SOFTWARE);
     size_t layers_updated_count = 0;
@@ skipping 780 matching lines @@
            ScrollsAnyDrawnRenderSurfaceLayerListMember(layer) ||
            !layer->touch_event_handler_region().IsEmpty() ||
            layer->have_wheel_event_handlers();
   }
 };
 
 LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPoint(
     const gfx::PointF& screen_space_point) {
   if (!root_layer())
     return NULL;
-  bool update_lcd_text = false;
-  if (!UpdateDrawProperties(update_lcd_text))
+  bool first_update_after_commit = false;
+  if (!UpdateDrawProperties(first_update_after_commit))
     return NULL;
   FindClosestMatchingLayerDataForRecursion data_for_recursion;
   FindClosestMatchingLayer(screen_space_point,
                            root_layer(),
                            HitTestVisibleScrollableOrTouchableFunctor(),
                            &data_for_recursion);
   return data_for_recursion.closest_match;
 }
 
 static bool LayerHasTouchEventHandlersAt(const gfx::PointF& screen_space_point,
@@ skipping 21 matching lines @@
 struct FindWheelEventLayerFunctor {
   bool operator()(LayerImpl* layer) const {
     return layer->have_wheel_event_handlers();
   }
 };
 
 LayerImpl* LayerTreeImpl::FindLayerWithWheelHandlerThatIsHitByPoint(
     const gfx::PointF& screen_space_point) {
   if (!root_layer())
     return NULL;
-  bool update_lcd_text = false;
-  if (!UpdateDrawProperties(update_lcd_text))
+  bool first_update_after_commit = false;
+  if (!UpdateDrawProperties(first_update_after_commit))
     return NULL;
   FindWheelEventLayerFunctor func;
   FindClosestMatchingLayerDataForRecursion data_for_recursion;
   FindClosestMatchingLayer(screen_space_point, root_layer(), func,
                            &data_for_recursion);
   return data_for_recursion.closest_match;
 }
 
 struct FindTouchEventLayerFunctor {
   bool operator()(LayerImpl* layer) const {
     return LayerHasTouchEventHandlersAt(screen_space_point, layer);
   }
   const gfx::PointF screen_space_point;
 };
 
 LayerImpl* LayerTreeImpl::FindLayerThatIsHitByPointInTouchHandlerRegion(
     const gfx::PointF& screen_space_point) {
   if (!root_layer())
     return NULL;
-  bool update_lcd_text = false;
-  if (!UpdateDrawProperties(update_lcd_text))
+  bool first_update_after_commit = false;
+  if (!UpdateDrawProperties(first_update_after_commit))
     return NULL;
   FindTouchEventLayerFunctor func = {screen_space_point};
   FindClosestMatchingLayerDataForRecursion data_for_recursion;
   FindClosestMatchingLayer(
       screen_space_point, root_layer(), func, &data_for_recursion);
   return data_for_recursion.closest_match;
 }
 
 void LayerTreeImpl::RegisterSelection(const LayerSelectionBound& start,
                                       const LayerSelectionBound& end) {
@@ skipping 84 matching lines @@
     scoped_ptr<PendingPageScaleAnimation> pending_animation) {
   pending_page_scale_animation_ = pending_animation.Pass();
 }
 
 scoped_ptr<PendingPageScaleAnimation>
     LayerTreeImpl::TakePendingPageScaleAnimation() {
   return pending_page_scale_animation_.Pass();
 }
 
 }  // namespace cc