Move MaxScrollOffset to property_trees

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"
 #include "cc/base/math_util.h"
 #include "cc/input/main_thread_scrolling_reason.h"
 #include "cc/proto/gfx_conversions.h"
 #include "cc/proto/property_tree.pb.h"
 #include "cc/proto/scroll_offset.pb.h"
 #include "cc/proto/transform.pb.h"
 #include "cc/proto/vector2df.pb.h"
 #include "cc/trees/property_tree.h"
+#include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
 
 template <typename T>
 bool TreeNode<T>::operator==(const TreeNode<T>& other) const {
   return id == other.id && parent_id == other.parent_id &&
          owner_id == other.owner_id && data == other.data;
 }
 
 template <typename T>
@@ skipping 440 matching lines @@
   num_copy_requests_in_subtree = data.num_copy_requests_in_subtree();
   transform_id = data.transform_id();
   clip_id = data.clip_id();
 }
 
 ScrollNodeData::ScrollNodeData()
     : scrollable(false),
       main_thread_scrolling_reasons(
           MainThreadScrollingReason::kNotScrollingOnMain),
       contains_non_fast_scrollable_region(false),
-      transform_id(0) {}
+      envelope_page_scale_layer_with_clip_layer(false),
+      is_inner_viewport_scroll_layer(false),
+      is_outer_viewport_scroll_layer(false),
+      is_inner_viewport_container_layer(false),
+      is_outer_viewport_container_layer(false) {}
 
 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 &&
-         transform_id == other.transform_id;
+         scroll_clip_layer_bounds == other.scroll_clip_layer_bounds &&
+         bounds == other.bounds &&
+         envelope_page_scale_layer_with_clip_layer ==
+             other.envelope_page_scale_layer_with_clip_layer &&
+         is_inner_viewport_scroll_layer ==
+             other.is_inner_viewport_scroll_layer &&
+         is_outer_viewport_scroll_layer ==
+             other.is_outer_viewport_scroll_layer &&
+         is_inner_viewport_container_layer ==
+             other.is_inner_viewport_container_layer &&
+         is_outer_viewport_container_layer ==
+             other.is_outer_viewport_container_layer;
 }
 
 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);
-  data->set_transform_id(transform_id);
+  SizeToProto(scroll_clip_layer_bounds,
+              data->mutable_scroll_clip_layer_bounds());
+  SizeToProto(bounds, data->mutable_bounds());
+  data->set_envelope_page_scale_layer_with_clip_layer(
+      envelope_page_scale_layer_with_clip_layer);
+  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_is_inner_viewport_container_layer(
+      is_inner_viewport_container_layer);
+  data->set_is_outer_viewport_container_layer(
+      is_outer_viewport_container_layer);
 }
 
 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();
-  transform_id = data.transform_id();
+  scroll_clip_layer_bounds = ProtoToSize(data.scroll_clip_layer_bounds());
+  bounds = ProtoToSize(data.bounds());
+  envelope_page_scale_layer_with_clip_layer =
+      data.envelope_page_scale_layer_with_clip_layer();
+  is_inner_viewport_scroll_layer = data.is_inner_viewport_scroll_layer();
+  is_outer_viewport_scroll_layer = data.is_outer_viewport_scroll_layer();
+  is_inner_viewport_container_layer = data.is_inner_viewport_container_layer();
+  is_outer_viewport_container_layer = data.is_outer_viewport_container_layer();
 }
 
 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 208 matching lines @@
 
 void TransformTree::UpdateLocalTransform(TransformNode* node) {
   gfx::Transform transform = node->data.post_local;
   if (NeedsSourceToParentUpdate(node)) {
     gfx::Transform to_parent;
     ComputeTransform(node->data.source_node_id, node->parent_id, &to_parent);
     node->data.source_to_parent = to_parent.To2dTranslation();
   }
 
   gfx::Vector2dF fixed_position_adjustment;
+  gfx::Vector2dF inner_viewport_bounds_delta =
+      property_trees()->inner_viewport_container_bounds_delta();
+  gfx::Vector2dF outer_viewport_bounds_delta =
+      property_trees()->outer_viewport_container_bounds_delta();
   if (node->data.affected_by_inner_viewport_bounds_delta_x)
-    fixed_position_adjustment.set_x(inner_viewport_bounds_delta_.x());
+    fixed_position_adjustment.set_x(inner_viewport_bounds_delta.x());
   else if (node->data.affected_by_outer_viewport_bounds_delta_x)
-    fixed_position_adjustment.set_x(outer_viewport_bounds_delta_.x());
+    fixed_position_adjustment.set_x(outer_viewport_bounds_delta.x());
 
   if (node->data.affected_by_inner_viewport_bounds_delta_y)
-    fixed_position_adjustment.set_y(inner_viewport_bounds_delta_.y());
+    fixed_position_adjustment.set_y(inner_viewport_bounds_delta.y());
   else if (node->data.affected_by_outer_viewport_bounds_delta_y)
-    fixed_position_adjustment.set_y(outer_viewport_bounds_delta_.y());
+    fixed_position_adjustment.set_y(outer_viewport_bounds_delta.y());
 
   transform.Translate(
       node->data.source_to_parent.x() - node->data.scroll_offset.x() +
           fixed_position_adjustment.x(),
       node->data.source_to_parent.y() - node->data.scroll_offset.y() +
           fixed_position_adjustment.y());
   transform.PreconcatTransform(node->data.local);
   transform.PreconcatTransform(node->data.pre_local);
   node->data.set_to_parent(transform);
   node->data.needs_local_transform_update = false;
@@ skipping 208 matching lines @@
     const gfx::Transform& transform) {
   gfx::Vector2dF device_transform_scale_components =
       MathUtil::ComputeTransform2dScaleComponents(transform, 1.f);
 
   // Not handling the rare case of different x and y device scale.
   device_transform_scale_factor_ =
       std::max(device_transform_scale_components.x(),
                device_transform_scale_components.y());
 }
 
-void TransformTree::SetInnerViewportBoundsDelta(gfx::Vector2dF bounds_delta) {
-  if (inner_viewport_bounds_delta_ == bounds_delta)
-    return;
-
-  inner_viewport_bounds_delta_ = bounds_delta;
-
+void TransformTree::UpdateInnerViewportContainerBoundsDelta() {
   if (nodes_affected_by_inner_viewport_bounds_delta_.empty())
     return;
 
   set_needs_update(true);
   for (int i : nodes_affected_by_inner_viewport_bounds_delta_)
     Node(i)->data.needs_local_transform_update = true;
 }
 
-void TransformTree::SetOuterViewportBoundsDelta(gfx::Vector2dF bounds_delta) {
-  if (outer_viewport_bounds_delta_ == bounds_delta)
-    return;
-
-  outer_viewport_bounds_delta_ = bounds_delta;
-
+void TransformTree::UpdateOuterViewportContainerBoundsDelta() {
   if (nodes_affected_by_outer_viewport_bounds_delta_.empty())
     return;
 
   set_needs_update(true);
   for (int i : nodes_affected_by_outer_viewport_bounds_delta_)
     Node(i)->data.needs_local_transform_update = true;
 }
 
 void TransformTree::AddNodeAffectedByInnerViewportBoundsDelta(int node_id) {
   nodes_affected_by_inner_viewport_bounds_delta_.push_back(node_id);
@@ skipping 12 matching lines @@
 }
 
 bool TransformTree::operator==(const TransformTree& other) const {
   return PropertyTree::operator==(other) &&
          source_to_parent_updates_allowed_ ==
              other.source_to_parent_updates_allowed() &&
          page_scale_factor_ == other.page_scale_factor() &&
          device_scale_factor_ == other.device_scale_factor() &&
          device_transform_scale_factor_ ==
              other.device_transform_scale_factor() &&
-         inner_viewport_bounds_delta_ == other.inner_viewport_bounds_delta() &&
-         outer_viewport_bounds_delta_ == other.outer_viewport_bounds_delta() &&
          nodes_affected_by_inner_viewport_bounds_delta_ ==
              other.nodes_affected_by_inner_viewport_bounds_delta() &&
          nodes_affected_by_outer_viewport_bounds_delta_ ==
              other.nodes_affected_by_outer_viewport_bounds_delta();
 }
 
 void TransformTree::ToProtobuf(proto::PropertyTree* proto) const {
   DCHECK(!proto->has_property_type());
   proto->set_property_type(proto::PropertyTree::Transform);
 
   PropertyTree::ToProtobuf(proto);
   proto::TransformTreeData* data = proto->mutable_transform_tree_data();
 
   data->set_source_to_parent_updates_allowed(source_to_parent_updates_allowed_);
   data->set_page_scale_factor(page_scale_factor_);
   data->set_device_scale_factor(device_scale_factor_);
   data->set_device_transform_scale_factor(device_transform_scale_factor_);
 
-  Vector2dFToProto(inner_viewport_bounds_delta_,
-                   data->mutable_inner_viewport_bounds_delta());
-  Vector2dFToProto(outer_viewport_bounds_delta_,
-                   data->mutable_outer_viewport_bounds_delta());
-
   for (auto i : nodes_affected_by_inner_viewport_bounds_delta_)
     data->add_nodes_affected_by_inner_viewport_bounds_delta(i);
 
   for (auto i : nodes_affected_by_outer_viewport_bounds_delta_)
     data->add_nodes_affected_by_outer_viewport_bounds_delta(i);
 }
 
 void TransformTree::FromProtobuf(const proto::PropertyTree& proto) {
   DCHECK(proto.has_property_type());
   DCHECK_EQ(proto.property_type(), proto::PropertyTree::Transform);
 
   PropertyTree::FromProtobuf(proto);
   const proto::TransformTreeData& data = proto.transform_tree_data();
 
   source_to_parent_updates_allowed_ = data.source_to_parent_updates_allowed();
   page_scale_factor_ = data.page_scale_factor();
   device_scale_factor_ = data.device_scale_factor();
   device_transform_scale_factor_ = data.device_transform_scale_factor();
 
-  inner_viewport_bounds_delta_ =
-      ProtoToVector2dF(data.inner_viewport_bounds_delta());
-  outer_viewport_bounds_delta_ =
-      ProtoToVector2dF(data.outer_viewport_bounds_delta());
-
   DCHECK(nodes_affected_by_inner_viewport_bounds_delta_.empty());
   for (int i = 0; i < data.nodes_affected_by_inner_viewport_bounds_delta_size();
        ++i) {
     nodes_affected_by_inner_viewport_bounds_delta_.push_back(
         data.nodes_affected_by_inner_viewport_bounds_delta(i));
   }
 
   DCHECK(nodes_affected_by_outer_viewport_bounds_delta_.empty());
   for (int i = 0; i < data.nodes_affected_by_outer_viewport_bounds_delta_size();
        ++i) {
@@ skipping 114 matching lines @@
   PropertyTree::ToProtobuf(proto);
 }
 
 void EffectTree::FromProtobuf(const proto::PropertyTree& proto) {
   DCHECK(proto.has_property_type());
   DCHECK_EQ(proto.property_type(), proto::PropertyTree::Effect);
 
   PropertyTree::FromProtobuf(proto);
 }
 
+ScrollTree::ScrollTree() {}
+
+ScrollTree::~ScrollTree() {}
+
 bool ScrollTree::operator==(const ScrollTree& other) const {
   return PropertyTree::operator==(other);
 }
 
 void ScrollTree::ToProtobuf(proto::PropertyTree* proto) const {
   DCHECK(!proto->has_property_type());
   proto->set_property_type(proto::PropertyTree::Scroll);
 
   PropertyTree::ToProtobuf(proto);
 }
 
 void ScrollTree::FromProtobuf(const proto::PropertyTree& proto) {
   DCHECK(proto.has_property_type());
   DCHECK_EQ(proto.property_type(), proto::PropertyTree::Scroll);
 
   PropertyTree::FromProtobuf(proto);
 }
 
+gfx::ScrollOffset ScrollTree::MaxScrollOffset(int scroll_node_id) const {
+  const ScrollNode* scroll_node = Node(scroll_node_id);
+  if (!scroll_node->data.scrollable || scroll_node->data.bounds.IsEmpty())
+    return gfx::ScrollOffset();
+
+  TransformTree& transform_tree = property_trees()->transform_tree;
+  float scale_factor = 1.f;
+  if (scroll_node->data.envelope_page_scale_layer_with_clip_layer)
+    scale_factor = transform_tree.page_scale_factor();
+
+  gfx::SizeF scroll_bounds = gfx::SizeF(scroll_node->data.bounds.width(),
+                                        scroll_node->data.bounds.height());
+
+  if (scroll_node->data.is_inner_viewport_scroll_layer) {
+    scroll_bounds.Enlarge(
+        property_trees()->inner_viewport_scroll_bounds_delta().x(),
+        property_trees()->inner_viewport_scroll_bounds_delta().y());
+  } else if (scroll_node->data.is_inner_viewport_container_layer) {
+    scroll_bounds.Enlarge(
+        property_trees()->inner_viewport_container_bounds_delta().x(),
+        property_trees()->inner_viewport_container_bounds_delta().y());
+  } else if (scroll_node->data.is_outer_viewport_container_layer) {
+    scroll_bounds.Enlarge(
+        property_trees()->outer_viewport_container_bounds_delta().x(),
+        property_trees()->outer_viewport_container_bounds_delta().y());

[ajuma, 2016/02/09 16:27:13]

Are the inner/outer viewport container layers ever actually scrollable
themselves? I'd expect them to show up as scroll clip layers but not as
scrollable layers (in which case we don't need this
is_inner_viewport_container_layer and is_outer_viewport_container_layer bools).

+  }
+
+  gfx::SizeF scaled_scroll_bounds = gfx::ScaleSize(scroll_bounds, scale_factor);
+  scaled_scroll_bounds.SetSize(std::floor(scaled_scroll_bounds.width()),
+                               std::floor(scaled_scroll_bounds.height()));
+
+  gfx::Size scroll_clip_layer_bounds =
+      scroll_node->data.scroll_clip_layer_bounds;
+
+  gfx::Vector2dF scroll_clip_layer_bounds_delta;
+  if (scroll_node->data.is_inner_viewport_scroll_layer) {
+    scroll_clip_layer_bounds_delta.Add(
+        property_trees()->inner_viewport_container_bounds_delta());
+  } else if (scroll_node->data.is_outer_viewport_scroll_layer) {
+    scroll_clip_layer_bounds_delta.Add(
+        property_trees()->outer_viewport_container_bounds_delta());
+  }
+
+  gfx::Vector2d delta = gfx::ToCeiledVector2d(scroll_clip_layer_bounds_delta);
+  scroll_clip_layer_bounds.SetSize(
+      scroll_clip_layer_bounds.width() + delta.x(),
+      scroll_clip_layer_bounds.height() + delta.y());
+
+  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;
+}
+
 PropertyTrees::PropertyTrees()
-    : needs_rebuild(true),
-      non_root_surfaces_enabled(true),
-      sequence_number(0) {}
+    : 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() {}
 
 bool PropertyTrees::operator==(const PropertyTrees& other) const {
   return transform_tree == other.transform_tree &&
          effect_tree == other.effect_tree && clip_tree == other.clip_tree &&
          scroll_tree == other.scroll_tree &&
          needs_rebuild == other.needs_rebuild &&
          non_root_surfaces_enabled == other.non_root_surfaces_enabled &&
          sequence_number == other.sequence_number;
@@ skipping 17 matching lines @@
 // static
 void PropertyTrees::FromProtobuf(const proto::PropertyTrees& proto) {
   transform_tree.FromProtobuf(proto.transform_tree());
   effect_tree.FromProtobuf(proto.effect_tree());
   clip_tree.FromProtobuf(proto.clip_tree());
   scroll_tree.FromProtobuf(proto.scroll_tree());
 
   needs_rebuild = proto.needs_rebuild();
   non_root_surfaces_enabled = proto.non_root_surfaces_enabled();
   sequence_number = proto.sequence_number();
+
+  transform_tree.SetPropertyTrees(this);
+  effect_tree.SetPropertyTrees(this);
+  clip_tree.SetPropertyTrees(this);
+  scroll_tree.SetPropertyTrees(this);
+}
+
+void PropertyTrees::SetInnerViewportContainerBoundsDelta(
+    gfx::Vector2dF bounds_delta) {
+  if (inner_viewport_container_bounds_delta_ == bounds_delta)
+    return;
+
+  inner_viewport_container_bounds_delta_ = bounds_delta;
+  transform_tree.UpdateInnerViewportContainerBoundsDelta();
+}
+
+void PropertyTrees::SetOuterViewportContainerBoundsDelta(
+    gfx::Vector2dF bounds_delta) {
+  if (outer_viewport_container_bounds_delta_ == bounds_delta)
+    return;
+
+  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