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

cc/trees/layer_tree.cc

+// Copyright 2016 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 "base/auto_reset.h"
+#include "cc/animation/animation_host.h"
+#include "cc/layers/layer.h"
+#include "cc/proto/layer_tree.pb.h"
+#include "cc/trees/layer_tree.h"
+
+namespace cc {
+
+LayerTree::LayerTree(std::unique_ptr<AnimationHost> animation_host)
+    : in_paint_layer_contents_(false),
+      animation_host_(std::move(animation_host)) {
+  DCHECK(animation_host_);
+}
+
+LayerTree::~LayerTree() {}
+
+void LayerTree::RegisterLayer(Layer* layer) {
+  DCHECK(!LayerById(layer->id()));
+  DCHECK(!in_paint_layer_contents_);
+  layer_id_map_[layer->id()] = layer;
+  if (layer->element_id()) {
+    animation_host_->RegisterElement(layer->element_id(),
+                                     ElementListType::ACTIVE);
+  }
+}
+
+void LayerTree::UnregisterLayer(Layer* layer) {
+  DCHECK(LayerById(layer->id()));
+  DCHECK(!in_paint_layer_contents_);
+  if (layer->element_id()) {
+    animation_host_->UnregisterElement(layer->element_id(),
+                                       ElementListType::ACTIVE);
+  }
+  RemoveLayerShouldPushProperties(layer);
+  layer_id_map_.erase(layer->id());
+}
+
+Layer* LayerTree::LayerById(int id) const {
+  LayerIdMap::const_iterator iter = layer_id_map_.find(id);
+  return iter != layer_id_map_.end() ? iter->second : nullptr;
+}
+
+bool LayerTree::UpdateLayers(const LayerList& update_layer_list,
+                             bool* content_is_suitable_for_gpu) {
+  base::AutoReset<bool> painting(&in_paint_layer_contents_, true);
+  bool did_paint_content = false;
+  for (const auto& layer : update_layer_list) {
+    did_paint_content |= layer->Update();
+    *content_is_suitable_for_gpu &= layer->IsSuitableForGpuRasterization();
+  }
+  return did_paint_content;
+}
+
+void LayerTree::AddLayerShouldPushProperties(Layer* layer) {
+  layers_that_should_push_properties_.insert(layer);
+}
+
+void LayerTree::RemoveLayerShouldPushProperties(Layer* layer) {
+  layers_that_should_push_properties_.erase(layer);
+}
+
+std::unordered_set<Layer*>& LayerTree::LayersThatShouldPushProperties() {
+  return layers_that_should_push_properties_;
+}
+
+bool LayerTree::LayerNeedsPushPropertiesForTesting(Layer* layer) const {
+  return layers_that_should_push_properties_.find(layer) !=
+         layers_that_should_push_properties_.end();
+}
+
+void LayerTree::ToProtobuf(proto::LayerTree* proto) {
+  for (auto* layer : layers_that_should_push_properties_) {
+    proto->add_layers_that_should_push_properties(layer->id());
+  }
+  proto->set_in_paint_layer_contents(in_paint_layer_contents());
+}
+
+void LayerTree::FromProtobuf(const proto::LayerTree& proto) {
+  for (auto layer_id : proto.layers_that_should_push_properties()) {
+    AddLayerShouldPushProperties(layer_id_map_[layer_id]);
+  }
+  in_paint_layer_contents_ = proto.in_paint_layer_contents();
+}
+
+}  // namespace cc