Refactor MutatorHostClient from LayerTreeHost to LayerTree.

cc/layers/layer.cc

 // Copyright 2010 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.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 115 matching lines @@
 
 void Layer::SetLayerTreeHost(LayerTreeHost* host) {
   if (layer_tree_host_ == host)
     return;
 
   if (layer_tree_host_) {
     layer_tree_->property_trees()->RemoveIdFromIdToIndexMaps(id());
     layer_tree_->property_trees()->needs_rebuild = true;
     layer_tree_->UnregisterLayer(this);
     if (inputs_.element_id) {
-      layer_tree_->animation_host()->UnregisterElement(inputs_.element_id,
-                                                       ElementListType::ACTIVE);
-      layer_tree_host_->RemoveFromElementMap(this);
+      layer_tree_->UnregisterElement(inputs_.element_id,
+                                     ElementListType::ACTIVE, this);
     }
   }
   if (host) {
     host->GetLayerTree()->property_trees()->needs_rebuild = true;
     host->GetLayerTree()->RegisterLayer(this);
     if (inputs_.element_id) {
-      host->AddToElementMap(this);
-      host->animation_host()->RegisterElement(inputs_.element_id,
-                                              ElementListType::ACTIVE);
+      host->GetLayerTree()->RegisterElement(inputs_.element_id,
+                                            ElementListType::ACTIVE, this);
     }
   }
 
   layer_tree_host_ = host;
   layer_tree_ = host ? host->GetLayerTree() : nullptr;
   InvalidatePropertyTreesIndices();
 
   // When changing hosts, the layer needs to commit its properties to the impl
   // side for the new host.
   SetNeedsPushProperties();
@@ skipping 687 matching lines @@
 
 void Layer::SetScrollClipLayerId(int clip_layer_id) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.scroll_clip_layer_id == clip_layer_id)
     return;
   inputs_.scroll_clip_layer_id = clip_layer_id;
   SetNeedsCommit();
 }
 
 Layer* Layer::scroll_clip_layer() const {
-  return layer_tree_host()->LayerById(inputs_.scroll_clip_layer_id);
+  DCHECK(layer_tree_);
+  return layer_tree_->LayerById(inputs_.scroll_clip_layer_id);
 }
 
 void Layer::SetUserScrollable(bool horizontal, bool vertical) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.user_scrollable_horizontal == horizontal &&
       inputs_.user_scrollable_vertical == vertical)
     return;
   inputs_.user_scrollable_horizontal = horizontal;
   inputs_.user_scrollable_vertical = vertical;
   SetNeedsCommit();
@@ skipping 607 matching lines @@
   inputs_.use_parent_backface_visibility =
       base.use_parent_backface_visibility();
   inputs_.transform = ProtoToTransform(base.transform());
   inputs_.sorting_context_id = base.sorting_context_id();
   num_descendants_that_draw_content_ = base.num_descendants_that_draw_content();
 
   inputs_.scroll_clip_layer_id = base.scroll_clip_layer_id();
   inputs_.user_scrollable_horizontal = base.user_scrollable_horizontal();
   inputs_.user_scrollable_vertical = base.user_scrollable_vertical();
 
-  inputs_.scroll_parent =
-      base.scroll_parent_id() == INVALID_ID
-          ? nullptr
-          : layer_tree_host_->LayerById(base.scroll_parent_id());
+  inputs_.scroll_parent = base.scroll_parent_id() == INVALID_ID
+                              ? nullptr
+                              : layer_tree_->LayerById(base.scroll_parent_id());
 
   // If there have been scroll children entries in previous deserializations,
   // clear out the set. If there have been none, initialize the set of children.
   // After this, the set is in the correct state to only add the new children.
   // If the set of children has not changed, for now this code still rebuilds
   // the set.
   if (scroll_children_)
     scroll_children_->clear();
   else if (base.scroll_children_ids_size() > 0)
     scroll_children_.reset(new std::set<Layer*>);
   for (int i = 0; i < base.scroll_children_ids_size(); ++i) {
     int child_id = base.scroll_children_ids(i);
-    scoped_refptr<Layer> child = layer_tree_host_->LayerById(child_id);
+    scoped_refptr<Layer> child = layer_tree_->LayerById(child_id);
     scroll_children_->insert(child.get());
   }
 
-  inputs_.clip_parent =
-      base.clip_parent_id() == INVALID_ID
-          ? nullptr
-          : layer_tree_host_->LayerById(base.clip_parent_id());
+  inputs_.clip_parent = base.clip_parent_id() == INVALID_ID
+                            ? nullptr
+                            : layer_tree_->LayerById(base.clip_parent_id());
 
   // If there have been clip children entries in previous deserializations,
   // clear out the set. If there have been none, initialize the set of children.
   // After this, the set is in the correct state to only add the new children.
   // If the set of children has not changed, for now this code still rebuilds
   // the set.
   if (clip_children_)
     clip_children_->clear();
   else if (base.clip_children_ids_size() > 0)
     clip_children_.reset(new std::set<Layer*>);
   for (int i = 0; i < base.clip_children_ids_size(); ++i) {
     int child_id = base.clip_children_ids(i);
-    scoped_refptr<Layer> child = layer_tree_host_->LayerById(child_id);
+    scoped_refptr<Layer> child = layer_tree_->LayerById(child_id);
     clip_children_->insert(child.get());
   }
 
   inputs_.scroll_offset = ProtoToScrollOffset(base.scroll_offset());
 
   inputs_.update_rect.Union(ProtoToRect(base.update_rect()));
 
   inputs_.has_will_change_transform_hint =
       base.has_will_change_transform_hint();
 }
@@ skipping 299 matching lines @@
   benchmark->RunOnLayer(this);
 }
 
 void Layer::SetElementId(ElementId id) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.element_id == id)
     return;
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
                "Layer::SetElementId", "element", id.AsValue().release());
   if (inputs_.element_id && layer_tree_host()) {
-    layer_tree_host()->animation_host()->UnregisterElement(
-        inputs_.element_id, ElementListType::ACTIVE);
-    layer_tree_host()->RemoveFromElementMap(this);
+    layer_tree_->UnregisterElement(inputs_.element_id, ElementListType::ACTIVE,
+                                   this);
   }
 
   inputs_.element_id = id;
 
   if (inputs_.element_id && layer_tree_host()) {
-    layer_tree_host()->animation_host()->RegisterElement(
-        inputs_.element_id, ElementListType::ACTIVE);
-    layer_tree_host()->AddToElementMap(this);
+    layer_tree_->RegisterElement(inputs_.element_id, ElementListType::ACTIVE,
+                                 this);
   }
 
   SetNeedsCommit();
 }
 
 void Layer::SetMutableProperties(uint32_t properties) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.mutable_properties == properties)
     return;
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
@@ skipping 20 matching lines @@
   DCHECK_NE(transform_tree_index_, TransformTree::kInvalidNodeId);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_->property_trees()->transform_tree);
 }
 
 LayerTree* Layer::GetLayerTree() const {
   return layer_tree_;
 }
 
 }  // namespace cc