Use private helpers in LayerImpl to shorten property tree references.

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 117 matching lines @@
 }
 
 void LayerImpl::SetDebugInfo(
     std::unique_ptr<base::trace_event::ConvertableToTraceFormat> debug_info) {
   owned_debug_info_ = std::move(debug_info);
   debug_info_ = owned_debug_info_.get();
   SetNeedsPushProperties();
 }
 
 void LayerImpl::DistributeScroll(ScrollState* scroll_state) {
-  ScrollTree& scroll_tree = layer_tree_impl()->property_trees()->scroll_tree;
+  ScrollTree& scroll_tree = GetScrollTree();
   ScrollNode* scroll_node = scroll_tree.Node(scroll_tree_index());
   scroll_tree.DistributeScroll(scroll_node, scroll_state);
 }
 
 void LayerImpl::SetTransformTreeIndex(int index) {
   transform_tree_index_ = index;
 }
 
 void LayerImpl::SetClipTreeIndex(int index) {
   clip_tree_index_ = index;
 }
 
 void LayerImpl::SetEffectTreeIndex(int index) {
   effect_tree_index_ = index;
 }
 
 int LayerImpl::render_target_effect_tree_index() const {
-  EffectNode* effect_node =
-      layer_tree_impl_->property_trees()->effect_tree.Node(effect_tree_index_);
-  if (effect_node->render_surface)
-    return effect_node->id;
-  else
-    return effect_node->target_id;
+  EffectNode* effect_node = GetEffectTree().Node(effect_tree_index_);
+  return effect_node->render_surface ? effect_node->id : effect_node->target_id;
 }
 
 void LayerImpl::SetScrollTreeIndex(int index) {
   scroll_tree_index_ = index;
 }
 
 void LayerImpl::ClearRenderSurfaceLayerList() {
   if (render_surface_)
     render_surface_->ClearLayerLists();
 }
@@ skipping 107 matching lines @@
   }
 }
 
 void LayerImpl::GetContentsResourceId(ResourceId* resource_id,
                                       gfx::Size* resource_size) const {
   NOTREACHED();
   *resource_id = 0;
 }
 
 gfx::Vector2dF LayerImpl::ScrollBy(const gfx::Vector2dF& scroll) {
-  ScrollTree& scroll_tree = layer_tree_impl()->property_trees()->scroll_tree;
+  ScrollTree& scroll_tree = GetScrollTree();
   ScrollNode* scroll_node = scroll_tree.Node(scroll_tree_index());
   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;
@@ skipping 88 matching lines @@
     layer->SetDebugInfo(std::move(owned_debug_info_));
 
   // Reset any state that should be cleared for the next update.
   layer_property_changed_ = false;
   needs_push_properties_ = false;
   update_rect_ = gfx::Rect();
   layer_tree_impl()->RemoveLayerShouldPushProperties(this);
 }
 
 bool LayerImpl::IsAffectedByPageScale() const {
-  TransformTree& transform_tree =
-      layer_tree_impl()->property_trees()->transform_tree;
+  TransformTree& transform_tree = GetTransformTree();
   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();
 
@@ skipping 39 matching lines @@
   list = new base::ListValue;
   for (size_t i = 0; i < test_properties()->children.size(); ++i)
     list->Append(test_properties()->children[i]->LayerTreeAsJson());
   result->Set("Children", list);
 
   return result;
 }
 
 bool LayerImpl::LayerPropertyChanged() const {
   if (layer_property_changed_ ||
-      (layer_tree_impl()->property_trees() &&
-       layer_tree_impl()->property_trees()->full_tree_damaged))
+      (GetPropertyTrees() && GetPropertyTrees()->full_tree_damaged))
     return true;
   if (transform_tree_index() == TransformTree::kInvalidNodeId)
     return false;
   TransformNode* transform_node =
-      layer_tree_impl()->property_trees()->transform_tree.Node(
-          transform_tree_index());
+      GetTransformTree().Node(transform_tree_index());
   if (transform_node && transform_node->transform_changed)
     return true;
   if (effect_tree_index() == EffectTree::kInvalidNodeId)
     return false;
-  EffectNode* effect_node =
-      layer_tree_impl()->property_trees()->effect_tree.Node(
-          effect_tree_index());
+  EffectNode* effect_node = GetEffectTree().Node(effect_tree_index());
   if (effect_node && effect_node->effect_changed)
     return true;
   return false;
 }
 
 void LayerImpl::NoteLayerPropertyChanged() {
   layer_property_changed_ = true;
   layer_tree_impl()->set_needs_update_draw_properties();
   SetNeedsPushProperties();
 }
@@ skipping 16 matching lines @@
   needs_push_properties_ = false;
 
   update_rect_.SetRect(0, 0, 0, 0);
   damage_rect_.SetRect(0, 0, 0, 0);
 
   if (render_surface_)
     render_surface_->ResetPropertyChangedFlags();
 }
 
 int LayerImpl::num_copy_requests_in_target_subtree() {
-  return layer_tree_impl()
-      ->property_trees()
-      ->effect_tree.Node(effect_tree_index())
+  return GetEffectTree()
+      .Node(effect_tree_index())
       ->num_copy_requests_in_subtree;
 }
 
 void LayerImpl::UpdatePropertyTreeTransformIsAnimated(bool is_animated) {
-  PropertyTrees* property_trees = layer_tree_impl()->property_trees();
+  PropertyTrees* property_trees = GetPropertyTrees();
   if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
                                        id())) {
-    TransformNode* node = property_trees->transform_tree.Node(
-        property_trees->transform_id_to_index_map[id()]);
+    TransformTree& transform_tree = GetTransformTree();
+    TransformNode* node =
+        transform_tree.Node(property_trees->transform_id_to_index_map[id()]);
     // A LayerImpl's own current state is insufficient for determining whether
     // it owns a TransformNode, since this depends on the state of the
     // corresponding Layer at the time of the last commit. For example, if
     // |is_animated| is false, this might mean a transform animation just ticked
     // past its finish point (so the LayerImpl still owns a TransformNode) or it
     // might mean that a transform animation was removed during commit or
     // activation (and, in that case, the LayerImpl will no longer own a
     // TransformNode, unless it has non-animation-related reasons for owning a
     // node).
     if (node->has_potential_animation != is_animated) {
       node->has_potential_animation = is_animated;
       if (is_animated) {
         node->has_only_translation_animations = HasOnlyTranslationTransforms();
       } else {
         node->has_only_translation_animations = true;
       }
 
-      property_trees->transform_tree.set_needs_update(true);
+      transform_tree.set_needs_update(true);
       layer_tree_impl()->set_needs_update_draw_properties();
     }
   }
 }
 
 void LayerImpl::UpdatePropertyTreeForScrollingAndAnimationIfNeeded() {
   if (scrollable())
     UpdatePropertyTreeScrollOffset();
 
   if (HasAnyAnimationTargetingProperty(TargetProperty::TRANSFORM)) {
     UpdatePropertyTreeTransformIsAnimated(
         HasPotentiallyRunningTransformAnimation());
   }
 }
 
 gfx::ScrollOffset LayerImpl::ScrollOffsetForAnimation() const {
   return CurrentScrollOffset();
 }
 
 void LayerImpl::OnIsAnimatingChanged(const PropertyAnimationState& mask,
                                      const PropertyAnimationState& state) {
   DCHECK(layer_tree_impl_);
-  PropertyTrees* property_trees = layer_tree_impl()->property_trees();
+  PropertyTrees* property_trees = GetPropertyTrees();
 
   TransformNode* transform_node = nullptr;
   if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
                                        id())) {
-    transform_node = property_trees->transform_tree.Node(
+    transform_node = GetTransformTree().Node(
         property_trees->transform_id_to_index_map[id()]);
   }
 
   EffectNode* effect_node = nullptr;
   if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT, id())) {
-    effect_node = property_trees->effect_tree.Node(
-        property_trees->effect_id_to_index_map[id()]);
+    effect_node =
+        GetEffectTree().Node(property_trees->effect_id_to_index_map[id()]);
   }
 
   for (int property = TargetProperty::FIRST_TARGET_PROPERTY;
        property <= TargetProperty::LAST_TARGET_PROPERTY; ++property) {
     switch (property) {
       case TargetProperty::TRANSFORM:
         if (transform_node) {
           if (mask.currently_running[property])
             transform_node->is_currently_animating =
                 state.currently_running[property];
           if (mask.potentially_animating[property]) {
             UpdatePropertyTreeTransformIsAnimated(
                 state.potentially_animating[property]);
             was_ever_ready_since_last_transform_animation_ = false;
           }
         }
         break;
       case TargetProperty::OPACITY:
         if (effect_node) {
           if (mask.currently_running[property])
             effect_node->is_currently_animating_opacity =
                 state.currently_running[property];
           if (mask.potentially_animating[property]) {
             effect_node->has_potential_opacity_animation =
                 state.potentially_animating[property];
-            property_trees->effect_tree.set_needs_update(true);
+            GetEffectTree().set_needs_update(true);
           }
         }
         break;
       case TargetProperty::FILTER:
         if (effect_node) {
           if (mask.currently_running[property])
             effect_node->is_currently_animating_filter =
                 state.currently_running[property];
           if (mask.potentially_animating[property])
             effect_node->has_potential_filter_animation =
@@ skipping 32 matching lines @@
   NoteLayerPropertyChanged();
 }
 
 void LayerImpl::SetBoundsDelta(const gfx::Vector2dF& bounds_delta) {
   DCHECK(IsActive());
   if (bounds_delta_ == bounds_delta)
     return;
 
   bounds_delta_ = bounds_delta;
 
-  PropertyTrees* property_trees = layer_tree_impl()->property_trees();
+  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);
 
   layer_tree_impl()->DidUpdateScrollState(id());
 
   if (masks_to_bounds()) {
@@ skipping 58 matching lines @@
 
 void LayerImpl::SetMasksToBounds(bool masks_to_bounds) {
   masks_to_bounds_ = masks_to_bounds;
 }
 
 void LayerImpl::SetContentsOpaque(bool opaque) {
   contents_opaque_ = opaque;
 }
 
 float LayerImpl::Opacity() const {
-  PropertyTrees* property_trees = layer_tree_impl()->property_trees();
+  PropertyTrees* property_trees = GetPropertyTrees();
   if (!property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT, id()))
     return 1.f;
-  EffectNode* node = property_trees->effect_tree.Node(
-      property_trees->effect_id_to_index_map[id()]);
+  EffectNode* node =
+      GetEffectTree().Node(property_trees->effect_id_to_index_map[id()]);
   return node->opacity;
 }
 
 const gfx::Transform& LayerImpl::Transform() const {
-  PropertyTrees* property_trees = layer_tree_impl()->property_trees();
+  PropertyTrees* property_trees = GetPropertyTrees();
   DCHECK(property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
                                           id()));
-  TransformNode* node = property_trees->transform_tree.Node(
-      property_trees->transform_id_to_index_map[id()]);
+  TransformNode* node =
+      GetTransformTree().Node(property_trees->transform_id_to_index_map[id()]);
   return node->local;
 }
 
 void LayerImpl::SetElementId(ElementId element_id) {
   if (element_id == element_id_)
     return;
 
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
                "LayerImpl::SetElementId", "element",
                element_id.AsValue().release());
@@ skipping 75 matching lines @@
   update_rect_ = update_rect;
   SetNeedsPushProperties();
 }
 
 void LayerImpl::AddDamageRect(const gfx::Rect& damage_rect) {
   damage_rect_.Union(damage_rect);
 }
 
 void LayerImpl::SetCurrentScrollOffset(const gfx::ScrollOffset& scroll_offset) {
   DCHECK(IsActive());
-  if (layer_tree_impl()->property_trees()->scroll_tree.SetScrollOffset(
-          id(), scroll_offset))
+  if (GetScrollTree().SetScrollOffset(id(), scroll_offset))
     layer_tree_impl()->DidUpdateScrollOffset(id());
 }
 
 gfx::ScrollOffset LayerImpl::CurrentScrollOffset() const {
-  return layer_tree_impl()->property_trees()->scroll_tree.current_scroll_offset(
-      id());
+  return GetScrollTree().current_scroll_offset(id());
 }
 
 void LayerImpl::UpdatePropertyTreeScrollOffset() {
   // TODO(enne): in the future, scrolling should update the scroll tree
   // directly instead of going through layers.
-  TransformTree& transform_tree =
-      layer_tree_impl()->property_trees()->transform_tree;
+  TransformTree& transform_tree = GetTransformTree();
   TransformNode* node = transform_tree.Node(transform_tree_index_);
   gfx::ScrollOffset current_offset = CurrentScrollOffset();
   if (node->scroll_offset != current_offset) {
     node->scroll_offset = current_offset;
     node->needs_local_transform_update = true;
     transform_tree.set_needs_update(true);
   }
 }
 
 SimpleEnclosedRegion LayerImpl::VisibleOpaqueRegion() const {
   if (contents_opaque())
     return SimpleEnclosedRegion(visible_layer_rect());
   return SimpleEnclosedRegion();
 }
 
 void LayerImpl::DidBeginTracing() {}
 
 void LayerImpl::ReleaseResources() {}
 
 void LayerImpl::ReleaseTileResources() {}
 
 void LayerImpl::RecreateTileResources() {}
 
 gfx::ScrollOffset LayerImpl::MaxScrollOffset() const {
-  return layer_tree_impl()->property_trees()->scroll_tree.MaxScrollOffset(
-      scroll_tree_index());
+  return GetScrollTree().MaxScrollOffset(scroll_tree_index());
 }
 
 gfx::ScrollOffset LayerImpl::ClampScrollOffsetToLimits(
     gfx::ScrollOffset offset) const {
   offset.SetToMin(MaxScrollOffset());
   offset.SetToMax(gfx::ScrollOffset());
   return offset;
 }
 
 gfx::Vector2dF LayerImpl::ClampScrollToMaxScrollOffset() {
@@ skipping 108 matching lines @@
   if (should_have_render_surface) {
     render_surface_ = base::MakeUnique<RenderSurfaceImpl>(this);
     return;
   }
   render_surface_.reset();
 }
 
 gfx::Transform LayerImpl::DrawTransform() const {
   // Only drawn layers have up-to-date draw properties.
   if (!is_drawn_render_surface_layer_list_member()) {
-    if (layer_tree_impl()->property_trees()->non_root_surfaces_enabled) {
-      return draw_property_utils::DrawTransform(
-          this, layer_tree_impl()->property_trees()->transform_tree,
-          layer_tree_impl()->property_trees()->effect_tree);
+    if (GetPropertyTrees()->non_root_surfaces_enabled) {
+      return draw_property_utils::DrawTransform(this, GetTransformTree(),
+                                                GetEffectTree());
     } else {
-      return draw_property_utils::ScreenSpaceTransform(
-          this, layer_tree_impl()->property_trees()->transform_tree);
+      return draw_property_utils::ScreenSpaceTransform(this,
+                                                       GetTransformTree());
     }
   }
 
   return draw_properties().target_space_transform;
 }
 
 gfx::Transform LayerImpl::ScreenSpaceTransform() const {
   // Only drawn layers have up-to-date draw properties.
   if (!is_drawn_render_surface_layer_list_member()) {
-    return draw_property_utils::ScreenSpaceTransform(
-        this, layer_tree_impl()->property_trees()->transform_tree);
+    return draw_property_utils::ScreenSpaceTransform(this, GetTransformTree());
   }
 
   return draw_properties().screen_space_transform;
 }
 
 bool LayerImpl::CanUseLCDText() const {
   if (layer_tree_impl()->settings().layers_always_allowed_lcd_text)
     return true;
   if (!layer_tree_impl()->settings().can_use_lcd_text)
     return false;
   if (!contents_opaque())
     return false;
 
-  if (layer_tree_impl()
-          ->property_trees()
-          ->effect_tree.Node(effect_tree_index())
-          ->screen_space_opacity != 1.f)
+  if (GetEffectTree().Node(effect_tree_index())->screen_space_opacity != 1.f)
     return false;
-  if (!layer_tree_impl()
-           ->property_trees()
-           ->transform_tree.Node(transform_tree_index())
+  if (!GetTransformTree()
+           .Node(transform_tree_index())
            ->node_and_ancestors_have_only_integer_translation)
     return false;
   if (static_cast<int>(offset_to_transform_parent().x()) !=
       offset_to_transform_parent().x())
     return false;
   if (static_cast<int>(offset_to_transform_parent().y()) !=
       offset_to_transform_parent().y())
     return false;
   return true;
 }
 
 Region LayerImpl::GetInvalidationRegionForDebugging() {
   return Region(update_rect_);
 }
 
 gfx::Rect LayerImpl::GetEnclosingRectInTargetSpace() const {
   return MathUtil::MapEnclosingClippedRect(DrawTransform(),
                                            gfx::Rect(bounds()));
 }
 
 gfx::Rect LayerImpl::GetScaledEnclosingRectInTargetSpace(float scale) const {
   gfx::Transform scaled_draw_transform = DrawTransform();
   scaled_draw_transform.Scale(SK_MScalar1 / scale, SK_MScalar1 / scale);
   gfx::Size scaled_bounds = gfx::ScaleToCeiledSize(bounds(), scale);
   return MathUtil::MapEnclosingClippedRect(scaled_draw_transform,
                                            gfx::Rect(scaled_bounds));
 }
 
 RenderSurfaceImpl* LayerImpl::render_target() {
-  EffectTree& effect_tree = layer_tree_impl_->property_trees()->effect_tree;
-  return effect_tree.Node(render_target_effect_tree_index())->render_surface;
+  return GetEffectTree()
+      .Node(render_target_effect_tree_index())
+      ->render_surface;
 }
 
 const RenderSurfaceImpl* LayerImpl::render_target() const {
-  const EffectTree& effect_tree =
-      layer_tree_impl_->property_trees()->effect_tree;
-  return effect_tree.Node(render_target_effect_tree_index())->render_surface;
+  return GetEffectTree()
+      .Node(render_target_effect_tree_index())
+      ->render_surface;
 }
 
 bool LayerImpl::IsHidden() const {
-  EffectTree& effect_tree = layer_tree_impl_->property_trees()->effect_tree;
-  EffectNode* node = effect_tree.Node(effect_tree_index_);
+  EffectNode* node = GetEffectTree().Node(effect_tree_index_);
   return node->screen_space_opacity == 0.f;
 }
 
 float LayerImpl::GetIdealContentsScale() const {
   float page_scale = IsAffectedByPageScale()
                          ? layer_tree_impl()->current_page_scale_factor()
                          : 1.f;
   float device_scale = layer_tree_impl()->device_scale_factor();
 
   float default_scale = page_scale * device_scale;
   if (!layer_tree_impl()
            ->settings()
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       ScreenSpaceTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
+PropertyTrees* LayerImpl::GetPropertyTrees() const {
+  return layer_tree_impl_->property_trees();
+}
+
+EffectTree& LayerImpl::GetEffectTree() const {
+  return GetPropertyTrees()->effect_tree;
+}
+
+ScrollTree& LayerImpl::GetScrollTree() const {
+  return GetPropertyTrees()->scroll_tree;
+}
+
+TransformTree& LayerImpl::GetTransformTree() const {
+  return GetPropertyTrees()->transform_tree;
+}
+
 }  // namespace cc