cc: Move TryScroll from LayerImpl to LayerTreeHostImpl

cc/trees/property_tree.cc

 // Copyright 2014 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 <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 461 matching lines @@
   clip_id = data.clip_id();
 }
 
 ScrollNodeData::ScrollNodeData()
     : scrollable(false),
       main_thread_scrolling_reasons(
           MainThreadScrollingReason::kNotScrollingOnMain),
       contains_non_fast_scrollable_region(false),
       max_scroll_offset_affected_by_page_scale(false),
       is_inner_viewport_scroll_layer(false),
-      is_outer_viewport_scroll_layer(false) {}
+      is_outer_viewport_scroll_layer(false),
+      should_flatten(false),
+      transform_id(0) {}
 
 bool ScrollNodeData::operator==(const ScrollNodeData& other) const {
   return scrollable == other.scrollable &&
          main_thread_scrolling_reasons == other.main_thread_scrolling_reasons &&
          contains_non_fast_scrollable_region ==
              other.contains_non_fast_scrollable_region &&
          scroll_clip_layer_bounds == other.scroll_clip_layer_bounds &&
          bounds == other.bounds &&
          max_scroll_offset_affected_by_page_scale ==
              other.max_scroll_offset_affected_by_page_scale &&
          is_inner_viewport_scroll_layer ==
              other.is_inner_viewport_scroll_layer &&
-         is_outer_viewport_scroll_layer == other.is_outer_viewport_scroll_layer;
+         is_outer_viewport_scroll_layer ==
+             other.is_outer_viewport_scroll_layer &&
+         offset_to_transform_parent == other.offset_to_transform_parent &&
+         should_flatten == other.should_flatten &&
+         transform_id == other.transform_id;
 }
 
 void ScrollNodeData::ToProtobuf(proto::TreeNode* proto) const {
   DCHECK(!proto->has_scroll_node_data());
   proto::ScrollNodeData* data = proto->mutable_scroll_node_data();
   data->set_scrollable(scrollable);
   data->set_main_thread_scrolling_reasons(main_thread_scrolling_reasons);
   data->set_contains_non_fast_scrollable_region(
       contains_non_fast_scrollable_region);
   SizeToProto(scroll_clip_layer_bounds,
               data->mutable_scroll_clip_layer_bounds());
   SizeToProto(bounds, data->mutable_bounds());
   data->set_max_scroll_offset_affected_by_page_scale(
       max_scroll_offset_affected_by_page_scale);
   data->set_is_inner_viewport_scroll_layer(is_inner_viewport_scroll_layer);
   data->set_is_outer_viewport_scroll_layer(is_outer_viewport_scroll_layer);
+  Vector2dFToProto(offset_to_transform_parent,
+                   data->mutable_offset_to_transform_parent());
+  data->set_should_flatten(should_flatten);
+  data->set_transform_id(transform_id);
 }
 
 void ScrollNodeData::FromProtobuf(const proto::TreeNode& proto) {
   DCHECK(proto.has_scroll_node_data());
   const proto::ScrollNodeData& data = proto.scroll_node_data();
 
   scrollable = data.scrollable();
   main_thread_scrolling_reasons = data.main_thread_scrolling_reasons();
   contains_non_fast_scrollable_region =
       data.contains_non_fast_scrollable_region();
   scroll_clip_layer_bounds = ProtoToSize(data.scroll_clip_layer_bounds());
   bounds = ProtoToSize(data.bounds());
   max_scroll_offset_affected_by_page_scale =
       data.max_scroll_offset_affected_by_page_scale();
   is_inner_viewport_scroll_layer = data.is_inner_viewport_scroll_layer();
   is_outer_viewport_scroll_layer = data.is_outer_viewport_scroll_layer();
+  offset_to_transform_parent =
+      ProtoToVector2dF(data.offset_to_transform_parent());
+  should_flatten = data.should_flatten();
+  transform_id = data.transform_id();
 }
 
 void TransformTree::clear() {
   PropertyTree<TransformNode>::clear();
 
   nodes_affected_by_inner_viewport_bounds_delta_.clear();
   nodes_affected_by_outer_viewport_bounds_delta_.clear();
 }
 
 bool TransformTree::ComputeTransform(int source_id,
@@ skipping 733 matching lines @@
 
   gfx::ScrollOffset max_offset(
       scaled_scroll_bounds.width() - scroll_clip_layer_bounds.width(),
       scaled_scroll_bounds.height() - scroll_clip_layer_bounds.height());
 
   max_offset.Scale(1 / scale_factor);
   max_offset.SetToMax(gfx::ScrollOffset());
   return max_offset;
 }
 
+gfx::Transform ScrollTree::ScreenSpaceTransform(int scroll_node_id) const {
+  const ScrollNode* scroll_node = Node(scroll_node_id);
+  const TransformNode* transform_node =
+      property_trees()->transform_tree.Node(scroll_node->data.transform_id);
+  gfx::Transform screen_space_transform(
+      1, 0, 0, 1, scroll_node->data.offset_to_transform_parent.x(),
+      scroll_node->data.offset_to_transform_parent.y());
+  screen_space_transform.ConcatTransform(transform_node->data.to_screen);
+  if (scroll_node->data.should_flatten)
+    screen_space_transform.FlattenTo2d();
+  return screen_space_transform;
+}
+
 PropertyTrees::PropertyTrees()
     : needs_rebuild(true), non_root_surfaces_enabled(true), sequence_number(0) {
   transform_tree.SetPropertyTrees(this);
   effect_tree.SetPropertyTrees(this);
   clip_tree.SetPropertyTrees(this);
   scroll_tree.SetPropertyTrees(this);
 }
 
 PropertyTrees::~PropertyTrees() {}
 
@@ skipping 76 matching lines @@
   outer_viewport_container_bounds_delta_ = bounds_delta;
   transform_tree.UpdateOuterViewportContainerBoundsDelta();
 }
 
 void PropertyTrees::SetInnerViewportScrollBoundsDelta(
     gfx::Vector2dF bounds_delta) {
   inner_viewport_scroll_bounds_delta_ = bounds_delta;
 }
 
 }  // namespace cc