cc: Add mask and replica layer ids to the effect tree

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 27 matching lines @@
 #include "ui/gfx/geometry/box_f.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace cc {
 LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id)
     : parent_(nullptr),
-      mask_layer_id_(-1),
-      mask_layer_(nullptr),
-      replica_layer_id_(-1),
-      replica_layer_(nullptr),
       layer_id_(id),
       layer_tree_impl_(tree_impl),
       test_properties_(nullptr),
       scroll_clip_layer_id_(Layer::INVALID_ID),
       main_thread_scrolling_reasons_(
           MainThreadScrollingReason::kNotScrollingOnMain),
       user_scrollable_horizontal_(true),
       user_scrollable_vertical_(true),
       should_flatten_transform_from_property_tree_(false),
       layer_property_changed_(false),
@@ skipping 34 matching lines @@
   DCHECK_EQ(DRAW_MODE_NONE, current_draw_mode_);
 
   layer_tree_impl_->UnregisterScrollLayer(this);
   layer_tree_impl_->UnregisterLayer(this);
   layer_tree_impl_->RemoveLayerShouldPushProperties(this);
 
   layer_tree_impl_->RemoveFromElementMap(this);
 
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerImpl", this);
-
-  // The mask and replica layers should have been removed already.
-  if (mask_layer_)
-    DCHECK(!layer_tree_impl_->RemoveLayer(mask_layer_id_));
-  if (replica_layer_)
-    DCHECK(!layer_tree_impl_->RemoveLayer(replica_layer_id_));
 }
 
 void LayerImpl::AddChild(std::unique_ptr<LayerImpl> child) {
   child->SetParent(this);
   DCHECK_EQ(layer_tree_impl(), child->layer_tree_impl());
   test_properties()->children.push_back(child.get());
   layer_tree_impl_->AddLayer(std::move(child));
 }
 
 std::unique_ptr<LayerImpl> LayerImpl::RemoveChildForTesting(LayerImpl* child) {
   auto it = std::find(test_properties()->children.begin(),
                       test_properties()->children.end(), child);
   if (it != test_properties()->children.end())
     test_properties()->children.erase(it);
   layer_tree_impl()->property_trees()->RemoveIdFromIdToIndexMaps(child->id());
   return layer_tree_impl_->RemoveLayer(child->id());
 }
 
 void LayerImpl::SetParent(LayerImpl* parent) {
   parent_ = parent;
 }
 
-void LayerImpl::ClearLinksToOtherLayers() {
-  mask_layer_ = nullptr;
-  replica_layer_ = nullptr;
-}
-
 void LayerImpl::SetHasWillChangeTransformHint(bool has_will_change) {
   if (has_will_change_transform_hint_ == has_will_change)
     return;
   has_will_change_transform_hint_ = has_will_change;
   SetNeedsPushProperties();
 }
 
 void LayerImpl::SetDebugInfo(
     std::unique_ptr<base::trace_event::ConvertableToTraceFormat> debug_info) {
   owned_debug_info_ = std::move(debug_info);
@@ skipping 369 matching lines @@
 }
 
 void LayerImpl::ResetChangeTracking() {
   layer_property_changed_ = false;
 
   update_rect_.SetRect(0, 0, 0, 0);
   damage_rect_.SetRect(0, 0, 0, 0);
 
   if (render_surface_)
     render_surface_->ResetPropertyChangedFlag();
-
-  if (mask_layer_)
-    mask_layer_->ResetChangeTracking();
-
-  if (replica_layer_) {
-    // This also resets the replica mask, if it exists.
-    replica_layer_->ResetChangeTracking();
-  }
 }
 
 int LayerImpl::num_copy_requests_in_target_subtree() {
   return layer_tree_impl()
       ->property_trees()
       ->effect_tree.Node(effect_tree_index())
       ->data.num_copy_requests_in_subtree;
 }
 
 void LayerImpl::UpdatePropertyTreeTransform() {
@@ skipping 240 matching lines @@
           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();
   }
 }
 
-void LayerImpl::SetMaskLayer(std::unique_ptr<LayerImpl> mask_layer) {
-  int new_layer_id = mask_layer ? mask_layer->id() : -1;
-
-  if (mask_layer) {
-    DCHECK_EQ(layer_tree_impl(), mask_layer->layer_tree_impl());
-    DCHECK_NE(new_layer_id, mask_layer_id_);
-  } else if (new_layer_id == mask_layer_id_) {
-    return;
-  }
-
-  if (mask_layer_)
-    layer_tree_impl_->RemoveLayer(mask_layer_->id());
-  mask_layer_ = mask_layer.get();
-  if (mask_layer_)
-    layer_tree_impl_->AddLayer(std::move(mask_layer));
-
-  mask_layer_id_ = new_layer_id;
-}
-
-std::unique_ptr<LayerImpl> LayerImpl::TakeMaskLayer() {
-  mask_layer_id_ = -1;
-  std::unique_ptr<LayerImpl> ret;
-  if (mask_layer_)
-    ret = layer_tree_impl_->RemoveLayer(mask_layer_->id());
-  mask_layer_ = nullptr;
-  return ret;
-}
-
-void LayerImpl::SetReplicaLayer(std::unique_ptr<LayerImpl> replica_layer) {
-  int new_layer_id = replica_layer ? replica_layer->id() : -1;
-
-  if (replica_layer) {
-    DCHECK_EQ(layer_tree_impl(), replica_layer->layer_tree_impl());
-    DCHECK_NE(new_layer_id, replica_layer_id_);
-  } else if (new_layer_id == replica_layer_id_) {
-    return;
-  }
-
-  if (replica_layer_)
-    layer_tree_impl_->RemoveLayer(replica_layer_->id());
-  replica_layer_ = replica_layer.get();
-  if (replica_layer_)
-    layer_tree_impl_->AddLayer(std::move(replica_layer));
-
-  replica_layer_id_ = new_layer_id;
-}
-
-std::unique_ptr<LayerImpl> LayerImpl::TakeReplicaLayerForTesting() {
-  replica_layer_id_ = -1;
-  std::unique_ptr<LayerImpl> ret;
-  if (replica_layer_) {
-    if (replica_layer_->mask_layer())
-      replica_layer_->SetMaskLayer(nullptr);
-    ret = layer_tree_impl_->RemoveLayer(replica_layer_->id());
-  }
-  replica_layer_ = nullptr;
-  return ret;
-}
-
 ScrollbarLayerImplBase* LayerImpl::ToScrollbarLayer() {
   return nullptr;
 }
 
 void LayerImpl::SetDrawsContent(bool draws_content) {
   if (draws_content_ == draws_content)
     return;
 
   draws_content_ = draws_content;
   NoteLayerPropertyChanged();
@@ skipping 297 matching lines @@
   if (!touch_event_handler_region_.IsEmpty()) {
     state->BeginArray("touch_event_handler_region");
     touch_event_handler_region_.AsValueInto(state);
     state->EndArray();
   }
   if (!non_fast_scrollable_region_.IsEmpty()) {
     state->BeginArray("non_fast_scrollable_region");
     non_fast_scrollable_region_.AsValueInto(state);
     state->EndArray();
   }
-  if (mask_layer_) {
-    state->BeginDictionary("mask_layer");
-    mask_layer_->AsValueInto(state);
-    state->EndDictionary();
-  }
-  if (replica_layer_) {
-    state->BeginDictionary("replica_layer");
-    replica_layer_->AsValueInto(state);
-    state->EndDictionary();
-  }
 
   state->SetBoolean("can_use_lcd_text", CanUseLCDText());
   state->SetBoolean("contents_opaque", contents_opaque());
 
   state->SetBoolean("has_animation_bounds",
                     layer_tree_impl_->HasAnimationThatInflatesBounds(this));
 
   state->SetBoolean("has_will_change_transform_hint",
                     has_will_change_transform_hint());
 
@@ skipping 135 matching lines @@
   return node->data.screen_space_opacity == 0.f;
 }
 
 bool LayerImpl::InsideReplica() const {
   // There are very few render targets so this should be cheap to do for each
   // layer instead of something more complicated.
   EffectTree& effect_tree = layer_tree_impl_->property_trees()->effect_tree;
   EffectNode* node = effect_tree.Node(effect_tree_index_);
 
   while (node->id > 0) {
-    LayerImpl* target_layer = layer_tree_impl()->LayerById(node->owner_id);
-    DCHECK(target_layer);
-    if (target_layer->has_replica())
+    if (node->data.replica_layer_id != -1)
       return true;
     node = effect_tree.Node(node->data.target_id);
   }
 
   return false;
 }
 
 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());
 }
 
 }  // namespace cc