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),
+      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 &&
+         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);
+  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();
+  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 {

[jaydasika, 2016/02/11 23:38:56]

Question : Is Scroll Node creation reasons a subset of Transform node creation
reasons ?
I looked at the code and  we don't create a transform node for having a non fast
scrollable region but we create a scroll node. In that case, the screen space
transform computed here should also include the layer's offset to transform
parent). 

[sunxd, 2016/02/12 15:33:30]

So we are only interested with ScreenSpaceTransform in non-fast scrollable
region case in TryScroll (only caller of this function, TryScroll also checks if
this transform is non-invertible, but if it is, it will have a transform node,
otherwise we are not interested.). It seems that non-fast scrollable region can
only be set on scrollable layers
(https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...),
but I'm not very sure about this.

If we do have scroll tree nodes that doesn't have a corresponding transform node
and we are interested in its ScreenSpaceTransform, we can put
offset_to_transform_parent in scroll tree, and update it when changing the value
in the layers.

[ajuma, 2016/02/12 17:03:01]

For TryScroll we might be ok, but I'm not sure if that's true for other
scrolling code. If we're exposing a ScreenSpaceTransform method on ScrollTree,
it seems safer to make sure it works for all scroll nodes.

+  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 = transform_node->data.to_screen;
+  if (transform_node->data.flattens_inherited_transform)
+    screen_space_transform.FlattenTo2d();

[ajuma, 2016/02/12 17:03:01]

I believe this already happens when to_screen is computed in the transform tree.

However, for layers that don't have transform nodes, you need to flatten if
LayerImpl::should_flatten_transform_from_property_trees is true.

+  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