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) {}
+      max_scroll_offset_affected_by_page_scale(false),
+      is_inner_viewport_scroll_layer(false),
+      is_outer_viewport_scroll_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 &&
+         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;
 }
 
 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_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);
 }
 
 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());
+  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();
 }
 
 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())

[ajuma, 2016/02/09 22:35:05]

Do we need to take bounds_delta into account before checking if bounds are
empty? This could use a test case too.

+    return gfx::ScrollOffset();
+
+  TransformTree& transform_tree = property_trees()->transform_tree;
+  float scale_factor = 1.f;
+  if (scroll_node->data.max_scroll_offset_affected_by_page_scale)
+    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());
+  }
+
+  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;
 }
 
+PropertyTrees& PropertyTrees::operator=(const PropertyTrees& from) {
+  transform_tree = from.transform_tree;
+  effect_tree = from.effect_tree;
+  clip_tree = from.clip_tree;
+  scroll_tree = from.scroll_tree;
+  needs_rebuild = from.needs_rebuild;
+  non_root_surfaces_enabled = from.non_root_surfaces_enabled;
+  sequence_number = from.sequence_number;
+  inner_viewport_container_bounds_delta_ =
+      from.inner_viewport_container_bounds_delta();
+  outer_viewport_container_bounds_delta_ =
+      from.outer_viewport_container_bounds_delta();
+  inner_viewport_scroll_bounds_delta_ =
+      from.inner_viewport_scroll_bounds_delta();
+  transform_tree.SetPropertyTrees(this);
+  effect_tree.SetPropertyTrees(this);
+  clip_tree.SetPropertyTrees(this);
+  scroll_tree.SetPropertyTrees(this);
+  return *this;
+}
+
 void PropertyTrees::ToProtobuf(proto::PropertyTrees* proto) const {
   // TODO(khushalsagar): Add support for sending diffs when serializaing
   // property trees. See crbug/555370.
   transform_tree.ToProtobuf(proto->mutable_transform_tree());
   effect_tree.ToProtobuf(proto->mutable_effect_tree());
   clip_tree.ToProtobuf(proto->mutable_clip_tree());
   scroll_tree.ToProtobuf(proto->mutable_scroll_tree());
   proto->set_needs_rebuild(needs_rebuild);
   proto->set_non_root_surfaces_enabled(non_root_surfaces_enabled);
 
   // TODO(khushalsagar): Consider using the sequence number to decide if
   // property trees need to be serialized again for a commit. See crbug/555370.
   proto->set_sequence_number(sequence_number);
 }
 
 // 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