Setup LayerTree class, refactor 2 functions from LayerTreeHost to it.

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 111 matching lines @@
   }
 }
 
 void Layer::SetLayerTreeHost(LayerTreeHost* host) {
   if (layer_tree_host_ == host)
     return;
 
   if (layer_tree_host_) {
     layer_tree_host_->property_trees()->RemoveIdFromIdToIndexMaps(id());
     layer_tree_host_->property_trees()->needs_rebuild = true;
-    layer_tree_host_->UnregisterLayer(this);
+    GetLayerTree()->UnregisterLayer(this);
     if (inputs_.element_id) {
       layer_tree_host_->animation_host()->UnregisterElement(
           inputs_.element_id, ElementListType::ACTIVE);
       layer_tree_host_->RemoveFromElementMap(this);
     }
   }
   if (host) {
     host->property_trees()->needs_rebuild = true;
-    host->RegisterLayer(this);
+    host->GetLayerTree()->RegisterLayer(this);
     if (inputs_.element_id) {
       host->AddToElementMap(this);
       host->animation_host()->RegisterElement(inputs_.element_id,
                                               ElementListType::ACTIVE);
     }
   }
 
   layer_tree_host_ = host;
   InvalidatePropertyTreesIndices();
 
@@ skipping 56 matching lines @@
 
 void Layer::SetNextCommitWaitsForActivation() {
   if (!layer_tree_host_)
     return;
 
   layer_tree_host_->SetNextCommitWaitsForActivation();
 }
 
 void Layer::SetNeedsPushProperties() {
   if (layer_tree_host_)
-    layer_tree_host_->AddLayerShouldPushProperties(this);
+    GetLayerTree()->AddLayerShouldPushProperties(this);
 }
 
 void Layer::ResetNeedsPushPropertiesForTesting() {
-  layer_tree_host_->RemoveLayerShouldPushProperties(this);
+  GetLayerTree()->RemoveLayerShouldPushProperties(this);
 }
 
 bool Layer::IsPropertyChangeAllowed() const {
   if (!layer_tree_host_)
     return true;
 
-  return !layer_tree_host_->in_paint_layer_contents();
+  return !GetLayerTree()->in_paint_layer_contents();
 }
 
 sk_sp<SkPicture> Layer::GetPicture() const {
   return nullptr;
 }
 
 void Layer::SetParent(Layer* layer) {
   DCHECK(!layer || !layer->HasAncestor(this));
 
   parent_ = layer;
@@ skipping 948 matching lines @@
   layer->SetUpdateRect(inputs_.update_rect);
 
   layer->SetHasWillChangeTransformHint(has_will_change_transform_hint());
   layer->SetNeedsPushProperties();
 
   // Reset any state that should be cleared for the next update.
   subtree_property_changed_ = false;
   layer_property_changed_ = false;
   inputs_.update_rect = gfx::Rect();
 
-  layer_tree_host()->RemoveLayerShouldPushProperties(this);
+  GetLayerTree()->RemoveLayerShouldPushProperties(this);
 }
 
 void Layer::TakeCopyRequests(
     std::vector<std::unique_ptr<CopyOutputRequest>>* requests) {
   for (auto& it : inputs_.copy_requests) {
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner =
         layer_tree_host()->task_runner_provider()->MainThreadTaskRunner();
     std::unique_ptr<CopyOutputRequest> original_request = std::move(it);
     const CopyOutputRequest& original_request_ref = *original_request;
     std::unique_ptr<CopyOutputRequest> main_thread_request =
@@ skipping 31 matching lines @@
     inputs_.mask_layer->ToLayerNodeProto(proto->mutable_mask_layer());
   if (inputs_.replica_layer)
     inputs_.replica_layer->ToLayerNodeProto(proto->mutable_replica_layer());
 }
 
 void Layer::ClearLayerTreePropertiesForDeserializationAndAddToMap(
     LayerIdMap* layer_map) {
   (*layer_map)[inputs_.layer_id] = this;
 
   if (layer_tree_host_)
-    layer_tree_host_->UnregisterLayer(this);
+    GetLayerTree()->UnregisterLayer(this);
 
   layer_tree_host_ = nullptr;
   parent_ = nullptr;
 
   // Clear these properties for all the children and add them to the map.
   for (auto& child : inputs_.children) {
     child->ClearLayerTreePropertiesForDeserializationAndAddToMap(layer_map);
   }
 
   inputs_.children.clear();
@@ skipping 17 matching lines @@
   DCHECK(!layer_tree_host_);
   DCHECK(inputs_.children.empty());
   DCHECK(!inputs_.mask_layer);
   DCHECK(!inputs_.replica_layer);
   DCHECK(layer_tree_host);
   DCHECK(proto.has_id());
 
   inputs_.layer_id = proto.id();
 
   layer_tree_host_ = layer_tree_host;
-  layer_tree_host_->RegisterLayer(this);
+  GetLayerTree()->RegisterLayer(this);
 
   for (int i = 0; i < proto.children_size(); ++i) {
     const proto::LayerNode& child_proto = proto.children(i);
     DCHECK(child_proto.has_type());
     scoped_refptr<Layer> child =
         LayerProtoConverter::FindOrAllocateAndConstruct(child_proto, layer_map);
     // The child must now refer to this layer as its parent, and must also have
     // the same LayerTreeHost. This must be done before deserializing children.
     DCHECK(!child->parent_);
     child->parent_ = this;
@@ skipping 441 matching lines @@
 }
 
 void Layer::SetHasWillChangeTransformHint(bool has_will_change) {
   if (inputs_.has_will_change_transform_hint == has_will_change)
     return;
   inputs_.has_will_change_transform_hint = has_will_change;
   SetNeedsCommit();
 }
 
 AnimationHost* Layer::GetAnimationHost() const {
-  return layer_tree_host_ ? layer_tree_host_->animation_host() : nullptr;
+  LayerTree* layer_tree = GetLayerTree();
+  return layer_tree ? layer_tree->animation_host() : nullptr;
 }
 
 ElementListType Layer::GetElementTypeForAnimation() const {
   return ElementListType::ACTIVE;
 }
 
 ScrollbarLayerInterface* Layer::ToScrollbarLayer() {
   return nullptr;
 }
 
@@ skipping 81 matching lines @@
       ->effect_tree.Node(effect_tree_index())
       ->num_copy_requests_in_subtree;
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, -1);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
+LayerTree* Layer::GetLayerTree() const {
+  return layer_tree_host_ ? layer_tree_host_->GetLayerTree() : nullptr;
+}
+
 }  // namespace cc