Move LayerImpl's bounds_delta to property trees

cc/layers/layer_impl.cc

 // Copyright 2012 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/layers/layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 364 matching lines @@
   return transform_tree.Node(transform_tree_index())
       ->in_subtree_of_page_scale_layer;
 }
 
 gfx::Vector2dF LayerImpl::FixedContainerSizeDelta() const {
   LayerImpl* scroll_clip_layer =
       layer_tree_impl()->LayerById(scroll_clip_layer_id_);
   if (!scroll_clip_layer)
     return gfx::Vector2dF();
 
-  return scroll_clip_layer->bounds_delta();
+  return scroll_clip_layer->ViewportBoundsDelta();
 }
 
 std::unique_ptr<base::DictionaryValue> LayerImpl::LayerTreeAsJson() {
   std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue);
   result->SetInteger("LayerId", id());
   result->SetString("LayerType", LayerTypeAsString());
 
   auto list = base::MakeUnique<base::ListValue>();
   list->AppendInteger(bounds().width());
   list->AppendInteger(bounds().height());
@@ skipping 101 matching lines @@
 
 gfx::ScrollOffset LayerImpl::ScrollOffsetForAnimation() const {
   return CurrentScrollOffset();
 }
 
 bool LayerImpl::IsActive() const {
   return layer_tree_impl_->IsActiveTree();
 }
 
 gfx::Size LayerImpl::bounds() const {
-  gfx::Vector2d delta = gfx::ToCeiledVector2d(bounds_delta_);
-  return gfx::Size(bounds_.width() + delta.x(),
-                   bounds_.height() + delta.y());
+  auto viewport_bounds_delta = gfx::ToCeiledVector2d(ViewportBoundsDelta());
+  return gfx::Size(bounds_.width() + viewport_bounds_delta.x(),
+                   bounds_.height() + viewport_bounds_delta.y());
 }
 
 gfx::SizeF LayerImpl::BoundsForScrolling() const {
-  return gfx::SizeF(bounds_.width() + bounds_delta_.x(),
-                    bounds_.height() + bounds_delta_.y());
+  auto viewport_bounds_delta = ViewportBoundsDelta();
+  return gfx::SizeF(bounds_.width() + viewport_bounds_delta.x(),
+                    bounds_.height() + viewport_bounds_delta.y());
 }
 
 void LayerImpl::SetBounds(const gfx::Size& bounds) {
   if (bounds_ == bounds)
     return;
 
   bounds_ = bounds;
 
   layer_tree_impl()->DidUpdateScrollState(id());
 
   NoteLayerPropertyChanged();
 }
 
-void LayerImpl::SetBoundsDelta(const gfx::Vector2dF& bounds_delta) {
+void LayerImpl::SetViewportBoundsDelta(const gfx::Vector2dF& bounds_delta) {
   DCHECK(IsActive());
-  if (bounds_delta_ == bounds_delta)
+
+  if (bounds_delta == ViewportBoundsDelta())
     return;
 
-  bounds_delta_ = bounds_delta;
-
   PropertyTrees* property_trees = GetPropertyTrees();
   if (this == layer_tree_impl()->InnerViewportContainerLayer())
     property_trees->SetInnerViewportContainerBoundsDelta(bounds_delta);
   else if (this == layer_tree_impl()->OuterViewportContainerLayer())
     property_trees->SetOuterViewportContainerBoundsDelta(bounds_delta);
   else if (this == layer_tree_impl()->InnerViewportScrollLayer())
     property_trees->SetInnerViewportScrollBoundsDelta(bounds_delta);
+  else
+    NOTREACHED();
 
   layer_tree_impl()->DidUpdateScrollState(id());
 
   if (masks_to_bounds()) {
     // If layer is clipping, then update the clip node using the new bounds.
     if (ClipNode* clip_node =
             property_trees->clip_tree.UpdateNodeFromOwningLayerId(id())) {
       DCHECK_EQ(clip_node->id, clip_tree_index());
       clip_node->clip = gfx::RectF(gfx::PointF() + offset_to_transform_parent(),
                                    gfx::SizeF(bounds()));
       property_trees->clip_tree.set_needs_update(true);
     }
     property_trees->full_tree_damaged = true;
     layer_tree_impl()->set_needs_update_draw_properties();
   } else {
     NoteLayerPropertyChanged();
   }
 }
 
+gfx::Vector2dF LayerImpl::ViewportBoundsDelta() const {
+  if (this == layer_tree_impl()->InnerViewportContainerLayer())
+    return GetPropertyTrees()->inner_viewport_container_bounds_delta();
+  else if (this == layer_tree_impl()->OuterViewportContainerLayer())
+    return GetPropertyTrees()->outer_viewport_container_bounds_delta();
+  else if (this == layer_tree_impl()->InnerViewportScrollLayer())
+    return GetPropertyTrees()->inner_viewport_scroll_bounds_delta();
+  return gfx::Vector2dF();
+}
+
 ScrollbarLayerImplBase* LayerImpl::ToScrollbarLayer() {
   return nullptr;
 }
 
 void LayerImpl::SetDrawsContent(bool draws_content) {
   if (draws_content_ == draws_content)
     return;
 
   draws_content_ = draws_content;
   NoteLayerPropertyChanged();
@@ skipping 405 matching lines @@
 
 ScrollTree& LayerImpl::GetScrollTree() const {
   return GetPropertyTrees()->scroll_tree;
 }
 
 TransformTree& LayerImpl::GetTransformTree() const {
   return GetPropertyTrees()->transform_tree;
 }
 
 }  // namespace cc