cc:: Don't use cached screen space transform for layers not in RSLL.

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 <limits>
 #include <map>
 #include <set>
@@ skipping 50 matching lines @@
 #include "cc/raster/tile_task_worker_pool.h"
 #include "cc/raster/zero_copy_tile_task_worker_pool.h"
 #include "cc/resources/memory_history.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/ui_resource_bitmap.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "cc/tiles/eviction_tile_priority_queue.h"
 #include "cc/tiles/picture_layer_tiling.h"
 #include "cc/tiles/raster_tile_priority_queue.h"
 #include "cc/trees/damage_tracker.h"
+#include "cc/trees/draw_property_utils.h"
 #include "cc/trees/latency_info_swap_promise_monitor.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/scroll_offset.h"
@@ skipping 2487 matching lines @@
       ScrollAnimationCreate(layer_impl, target_offset, current_offset);
 
       SetNeedsAnimate();
       return SCROLL_STARTED;
     }
   }
   ScrollEnd();
   return scroll_status;
 }
 
+const gfx::Transform LayerTreeHostImpl::LayerScreenSpaceTransform(
+    const LayerImpl* layer) {
+  const bool use_property_trees =
+      settings_.use_property_trees || settings_.verify_property_trees;
+  if (!use_property_trees)
+    return layer->screen_space_transform();
+  const bool is_active_tree = layer->layer_tree_impl() == active_tree();
+  LayerTreeImpl* layer_tree_impl =
+      is_active_tree ? active_tree() : pending_tree();
+  DCHECK(layer_tree_impl);
+  return layer->IsDrawnRenderSurfaceLayerListMember()
+             ? layer->screen_space_transform()
+             : ScreenSpaceTransformFromPropertyTrees(
+                   layer, layer_tree_impl->property_trees()->transform_tree);
+}
+
 gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
     LayerImpl* layer_impl,
     const gfx::PointF& viewport_point,
     const gfx::Vector2dF& viewport_delta) {
   // Layers with non-invertible screen space transforms should not have passed
   // the scroll hit test in the first place.
-  DCHECK(layer_impl->screen_space_transform().IsInvertible());
+  const gfx::Transform screen_space_transform =
+      LayerScreenSpaceTransform(layer_impl);
+  DCHECK(screen_space_transform.IsInvertible());
   gfx::Transform inverse_screen_space_transform(
       gfx::Transform::kSkipInitialization);
-  bool did_invert = layer_impl->screen_space_transform().GetInverse(
-      &inverse_screen_space_transform);
+  bool did_invert =
+      screen_space_transform.GetInverse(&inverse_screen_space_transform);
   // TODO(shawnsingh): With the advent of impl-side scrolling for non-root
   // layers, we may need to explicitly handle uninvertible transforms here.
   DCHECK(did_invert);
 
   float scale_from_viewport_to_screen_space =
       active_tree_->device_scale_factor();
   gfx::PointF screen_space_point =
       gfx::ScalePoint(viewport_point, scale_from_viewport_to_screen_space);
 
   gfx::Vector2dF screen_space_delta = viewport_delta;
@@ skipping 23 matching lines @@
   layer_impl->ScrollBy(local_end_point - local_start_point);
   gfx::ScrollOffset scrolled =
       layer_impl->CurrentScrollOffset() - previous_offset;
 
   // Get the end point in the layer's content space so we can apply its
   // ScreenSpaceTransform.
   gfx::PointF actual_local_end_point =
       local_start_point + gfx::Vector2dF(scrolled.x(), scrolled.y());
 
   // Calculate the applied scroll delta in viewport space coordinates.
-  gfx::PointF actual_screen_space_end_point =
-      MathUtil::MapPoint(layer_impl->screen_space_transform(),
-                         actual_local_end_point, &end_clipped);
+  gfx::PointF actual_screen_space_end_point = MathUtil::MapPoint(
+      screen_space_transform, actual_local_end_point, &end_clipped);
   DCHECK(!end_clipped);
   if (end_clipped)
     return gfx::Vector2dF();
   gfx::PointF actual_viewport_end_point =
       gfx::ScalePoint(actual_screen_space_end_point,
                       1.f / scale_from_viewport_to_screen_space);
   return actual_viewport_end_point - viewport_point;
 }
 
 static gfx::Vector2dF ScrollLayerWithLocalDelta(
@@ skipping 245 matching lines @@
 
 float LayerTreeHostImpl::DeviceSpaceDistanceToLayer(
     const gfx::PointF& device_viewport_point,
     LayerImpl* layer_impl) {
   if (!layer_impl)
     return std::numeric_limits<float>::max();
 
   gfx::Rect layer_impl_bounds(layer_impl->bounds());
 
   gfx::RectF device_viewport_layer_impl_bounds = MathUtil::MapClippedRect(
-      layer_impl->screen_space_transform(), gfx::RectF(layer_impl_bounds));
+      LayerScreenSpaceTransform(layer_impl), gfx::RectF(layer_impl_bounds));
 
   return device_viewport_layer_impl_bounds.ManhattanDistanceToPoint(
       device_viewport_point);
 }
 
 void LayerTreeHostImpl::MouseMoveAt(const gfx::Point& viewport_point) {
   gfx::PointF device_viewport_point = gfx::ScalePoint(
       gfx::PointF(viewport_point), active_tree_->device_scale_factor());
   LayerImpl* layer_impl =
       active_tree_->FindLayerThatIsHitByPoint(device_viewport_point);
@@ skipping 786 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc