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 55 matching lines @@
 }
 
 void Layer::SetNextCommitWaitsForActivation() {
   if (!layer_tree_host_)
     return;
 
   layer_tree_host_->SetNextCommitWaitsForActivation();
 }
 
 void Layer::SetNeedsPushProperties() {
   if (layer_tree_host_)

[vmpstr, 2016/07/27 18:05:30]

if (GetLayerTree()) here and throughout

-    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;

[vmpstr, 2016/07/25 20:45:46]

If we're mimicking impl side of things, then layer_tree_impl is passed into the
ctor of layer_impl. Can we do a similar thing for the main side?

LayerTreeHost owns LayerTree which owns Layers, so it's a bit awkward for

Layer to talk to LayerTreeHost in order to get its LayerTree.

Most, if not all, interactions on the impl side happen from LayerImpl to
LayerTreeImpl, which may or may not forward the call to LayerTreeHostImpl. Is
this the plan in the future?

[xingliu, 2016/07/25 23:40:25]

@Khushal

Khushal probably can answer this question much better than me.

[Khushal, 2016/07/26 18:10:41]

Not sure. Blink uses the WebCompositorSupportImpl to build the WebLayers
wrapping the cc::Layers and that's shared across the RWCs which have the LTH. In
Clank UI as well, they just create Layers and don't have access to the LTH,
since its owned by the CompositorImpl in content/, so you just set the root
layer on the compositor which gives it to the host and it attaches itself to the
underlying tree. I figured the reason we have the SetLayerTreeHost method on
Layers is because you can construct one and then attach or detach it from the
LTH or change hosts? LayerImpls on the other hand remain bound to the
LayerTreeImpl right?
Yup, LayerTreeHost wouldn't exist, so SetLayerTreeHost would change to
SetLayerTree.

+}
+
 }  // namespace cc