Add a cache of LayerImpl's viewport layer type

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 50 matching lines @@
       layer_property_changed_(false),
       may_contain_video_(false),
       masks_to_bounds_(false),
       contents_opaque_(false),
       use_parent_backface_visibility_(false),
       use_local_transform_for_backface_visibility_(false),
       should_check_backface_visibility_(false),
       draws_content_(false),
       contributes_to_drawn_render_surface_(false),
       was_ever_ready_since_last_transform_animation_(true),
+      viewport_layer_type_(NOT_VIEWPORT_LAYER),
       background_color_(0),
       safe_opaque_background_color_(0),
       transform_tree_index_(TransformTree::kInvalidNodeId),
       effect_tree_index_(EffectTree::kInvalidNodeId),
       clip_tree_index_(ClipTree::kInvalidNodeId),
       scroll_tree_index_(ScrollTree::kInvalidNodeId),
       current_draw_mode_(DRAW_MODE_NONE),
       mutable_properties_(MutableProperty::kNone),
       debug_info_(nullptr),
       has_will_change_transform_hint_(false),
@@ skipping 191 matching lines @@
   return scroll_tree.ScrollBy(scroll_node, scroll, layer_tree_impl());
 }
 
 void LayerImpl::SetScrollClipLayer(int scroll_clip_layer_id) {
   if (scroll_clip_layer_id_ == scroll_clip_layer_id)
     return;
 
   layer_tree_impl()->UnregisterScrollLayer(this);
   scroll_clip_layer_id_ = scroll_clip_layer_id;
   layer_tree_impl()->RegisterScrollLayer(this);
+
+  // Ensure our viewport layer type is updated.
+  layer_tree_impl()->UpdateViewportLayerTypes();
 }
 
 LayerImpl* LayerImpl::scroll_clip_layer() const {
   return layer_tree_impl()->LayerById(scroll_clip_layer_id_);
 }
 
 bool LayerImpl::scrollable() const {
   return scroll_clip_layer_id_ != Layer::INVALID_ID;
 }
 
@@ skipping 227 matching lines @@
   NoteLayerPropertyChanged();
 }
 
 void LayerImpl::SetViewportBoundsDelta(const gfx::Vector2dF& bounds_delta) {
   DCHECK(IsActive());
 
   if (bounds_delta == ViewportBoundsDelta())
     return;
 
   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();
+  switch (viewport_layer_type_) {
+    case (INNER_VIEWPORT_CONTAINER):
+      property_trees->SetInnerViewportContainerBoundsDelta(bounds_delta);
+      break;
+    case (OUTER_VIEWPORT_CONTAINER):
+      property_trees->SetOuterViewportContainerBoundsDelta(bounds_delta);
+      break;
+    case (INNER_VIEWPORT_SCROLL):
+      property_trees->SetInnerViewportScrollBoundsDelta(bounds_delta);
+      break;
+    case (OUTER_VIEWPORT_SCROLL):
+      // OUTER_VIEWPORT_SCROLL should not have viewport bounds deltas.
+      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();
+  switch (viewport_layer_type_) {
+    case (INNER_VIEWPORT_CONTAINER):
+      return GetPropertyTrees()->inner_viewport_container_bounds_delta();
+    case (OUTER_VIEWPORT_CONTAINER):
+      return GetPropertyTrees()->outer_viewport_container_bounds_delta();
+    case (INNER_VIEWPORT_SCROLL):
+      return GetPropertyTrees()->inner_viewport_scroll_bounds_delta();
+    default:
+      return gfx::Vector2dF();
+  }
 }
 
 ScrollbarLayerImplBase* LayerImpl::ToScrollbarLayer() {
   return nullptr;
 }
 
 void LayerImpl::SetDrawsContent(bool draws_content) {
   if (draws_content_ == draws_content)
     return;
 
@@ skipping 399 matching lines @@
 
 ScrollTree& LayerImpl::GetScrollTree() const {
   return GetPropertyTrees()->scroll_tree;
 }
 
 TransformTree& LayerImpl::GetTransformTree() const {
   return GetPropertyTrees()->transform_tree;
 }
 
 }  // namespace cc