Refactor MutatorHostClient from LayerTreeHost to LayerTree.

cc/trees/layer_tree_host.h

 // Copyright 2011 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.
 
 #ifndef CC_TREES_LAYER_TREE_HOST_H_
 #define CC_TREES_LAYER_TREE_HOST_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 25 matching lines @@
 #include "cc/output/output_surface.h"
 #include "cc/output/renderer_capabilities.h"
 #include "cc/output/swap_promise.h"
 #include "cc/resources/resource_format.h"
 #include "cc/resources/scoped_ui_resource.h"
 #include "cc/surfaces/surface_sequence.h"
 #include "cc/trees/compositor_mode.h"
 #include "cc/trees/layer_tree.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_settings.h"
-#include "cc/trees/mutator_host_client.h"
 #include "cc/trees/proxy.h"
 #include "cc/trees/swap_promise_monitor.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace gpu {
 class GpuMemoryBufferManager;
 }
 
 namespace cc {
@@ skipping 19 matching lines @@
 class TopControlsManager;
 class UIResourceRequest;
 struct PendingPageScaleAnimation;
 struct RenderingStats;
 struct ScrollAndScaleSet;
 
 namespace proto {
 class LayerTreeHost;
 }
 
-class CC_EXPORT LayerTreeHost : public MutatorHostClient {
+class CC_EXPORT LayerTreeHost {
  public:
   // TODO(sad): InitParams should be a movable type so that it can be
   // std::move()d to the Create* functions.
   struct CC_EXPORT InitParams {
     LayerTreeHostClient* client = nullptr;
     SharedBitmapManager* shared_bitmap_manager = nullptr;
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager = nullptr;
     TaskGraphRunner* task_graph_runner = nullptr;
     LayerTreeSettings const* settings = nullptr;
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner;
@@ skipping 48 matching lines @@
   void DidInitializeOutputSurface();
   void DidFailToInitializeOutputSurface();
   virtual std::unique_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
       LayerTreeHostImplClient* client);
   void DidLoseOutputSurface();
   bool output_surface_lost() const { return output_surface_lost_; }
   void DidCommitAndDrawFrame() { client_->DidCommitAndDrawFrame(); }
   void DidCompleteSwapBuffers() { client_->DidCompleteSwapBuffers(); }
   bool UpdateLayers();
 
-  LayerListIterator<Layer> begin() const;
-  LayerListIterator<Layer> end() const;
-  LayerListReverseIterator<Layer> rbegin();
-  LayerListReverseIterator<Layer> rend();
-
   // Called when the compositor completed page scale animation.
   void DidCompletePageScaleAnimation();
 
   LayerTreeHostClient* client() { return client_; }
   const base::WeakPtr<InputHandler>& GetInputHandler() {
     return input_handler_weak_ptr_;
   }
 
   void NotifyInputThrottledUntilCommit();
 
   void LayoutAndUpdateLayers();
   void Composite(base::TimeTicks frame_begin_time);
 
   void SetDeferCommits(bool defer_commits);
 
   int source_frame_number() const { return source_frame_number_; }
 
   bool gpu_rasterization_histogram_recorded() const {
     return gpu_rasterization_histogram_recorded_;
   }
 
-  void SetNeedsDisplayOnAllLayers();
-
   void CollectRenderingStats(RenderingStats* stats) const;
 
   RenderingStatsInstrumentation* rendering_stats_instrumentation() const {
     return rendering_stats_instrumentation_.get();
   }
 
   virtual const RendererCapabilities& GetRendererCapabilities() const;
 
   void SetNeedsAnimate();
   virtual void SetNeedsUpdateLayers();
@@ skipping 94 matching lines @@
   void UpdateTopControlsState(TopControlsState constraints,
                               TopControlsState current,
                               bool animate);
 
   HeadsUpDisplayLayer* hud_layer() const { return hud_layer_.get(); }
 
   Proxy* proxy() const { return proxy_.get(); }
   TaskRunnerProvider* task_runner_provider() const {
     return task_runner_provider_.get();
   }
-  AnimationHost* animation_host() const;
 
   bool has_output_surface() const { return !!current_output_surface_; }
 
   // CreateUIResource creates a resource given a bitmap.  The bitmap is
   // generated via an interface function, which is called when initializing the
   // resource and when the resource has been lost (due to lost context).  The
   // parameter of the interface is a single boolean, which indicates whether the
   // resource has been lost or not.  CreateUIResource returns an Id of the
   // resource, which is always positive.
   virtual UIResourceId CreateUIResource(UIResourceClient* client);
@@ skipping 33 matching lines @@
   void set_surface_client_id(uint32_t client_id);
   SurfaceSequence CreateSurfaceSequence();
 
   PropertyTrees* property_trees() { return &property_trees_; }
   bool needs_meta_info_recomputation() {
     return needs_meta_info_recomputation_;
   }
 
   void SetLayerTreeMutator(std::unique_ptr<LayerTreeMutator> mutator);
 
-  Layer* LayerById(int id) const;
-
-  Layer* LayerByElementId(ElementId element_id) const;
-  void AddToElementMap(Layer* layer);
-  void RemoveFromElementMap(Layer* layer);
-
-  // MutatorHostClient implementation.
-  bool IsElementInList(ElementId element_id,
-                       ElementListType list_type) const override;
-  void SetMutatorsNeedCommit() override;
-  void SetMutatorsNeedRebuildPropertyTrees() override;
-  void SetElementFilterMutated(ElementId element_id,
-                               ElementListType list_type,
-                               const FilterOperations& filters) override;
-  void SetElementOpacityMutated(ElementId element_id,
-                                ElementListType list_type,
-                                float opacity) override;
-  void SetElementTransformMutated(ElementId element_id,
-                                  ElementListType list_type,
-                                  const gfx::Transform& transform) override;
-  void SetElementScrollOffsetMutated(
-      ElementId element_id,
-      ElementListType list_type,
-      const gfx::ScrollOffset& scroll_offset) override;
-  void ElementTransformIsAnimatingChanged(ElementId element_id,
-                                          ElementListType list_type,
-                                          AnimationChangeType change_type,
-                                          bool is_animating) override;
-  void ElementOpacityIsAnimatingChanged(ElementId element_id,
-                                        ElementListType list_type,
-                                        AnimationChangeType change_type,
-                                        bool is_animating) override;
-  void ElementFilterIsAnimatingChanged(ElementId element_id,
-                                       ElementListType list_type,
-                                       AnimationChangeType change_type,
-                                       bool is_animating) override;
-  void ScrollOffsetAnimationFinished() override {}
-  gfx::ScrollOffset GetScrollOffsetForAnimation(
-      ElementId element_id) const override;
-
   // Serializes the parts of this LayerTreeHost that is needed for a commit to a
   // protobuf message. Not all members are serialized as they are not helpful
   // for remote usage.
   // The |swap_promise_list_| is transferred to the serializer in
   // |swap_promises|.
   void ToProtobufForCommit(
       proto::LayerTreeHost* proto,
       std::vector<std::unique_ptr<SwapPromise>>* swap_promises);
 
   // Deserializes the protobuf into this LayerTreeHost before a commit. The
   // expected input is a serialized remote LayerTreeHost. After deserializing
   // the protobuf, the normal commit-flow should continue.
   void FromProtobufForCommit(const proto::LayerTreeHost& proto);
 
   bool IsSingleThreaded() const;
   bool IsThreaded() const;
   bool IsRemoteServer() const;
   bool IsRemoteClient() const;
   void BuildPropertyTreesForTesting();
 
-  void SetElementIdsForTesting();
-
   ImageSerializationProcessor* image_serialization_processor() const {
     return image_serialization_processor_;
   }
 
   EnginePictureCache* engine_picture_cache() const {
     return engine_picture_cache_ ? engine_picture_cache_.get() : nullptr;
   }
 
   ClientPictureCache* client_picture_cache() const {
     return client_picture_cache_ ? client_picture_cache_.get() : nullptr;
   }
 
-  LayerTree* GetLayerTree() { return &layer_tree_; }
-  const LayerTree* GetLayerTree() const { return &layer_tree_; }
+  LayerTree* GetLayerTree() { return layer_tree_.get(); }
+  const LayerTree* GetLayerTree() const { return layer_tree_.get(); }
 
  protected:
   LayerTreeHost(InitParams* params, CompositorMode mode);
   void InitializeThreaded(
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
       std::unique_ptr<BeginFrameSource> external_begin_frame_source);
   void InitializeSingleThreaded(
       LayerTreeHostSingleThreadClient* single_thread_client,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
@@ skipping 26 matching lines @@
     return gpu_memory_buffer_manager_;
   }
   TaskGraphRunner* task_graph_runner() const { return task_graph_runner_; }
 
   MicroBenchmarkController micro_benchmark_controller_;
 
   void OnCommitForSwapPromises();
 
   void RecordGpuRasterizationHistogram();
 
+  // Layer tree that hold layers.
+  std::unique_ptr<LayerTree> layer_tree_;
+
  private:
   friend class LayerTreeHostSerializationTest;
 
   // This is the number of consecutive frames in which we want the content to be
   // suitable for GPU rasterization before re-enabling it.
   enum { kNumFramesToConsiderBeforeGpuRasterization = 60 };
 
   void ApplyViewportDeltas(ScrollAndScaleSet* info);
   void InitializeProxy(
       std::unique_ptr<Proxy> proxy,
@@ skipping 99 matching lines @@
 
   ImageSerializationProcessor* image_serialization_processor_;
   std::unique_ptr<EnginePictureCache> engine_picture_cache_;
   std::unique_ptr<ClientPictureCache> client_picture_cache_;
 
   std::vector<std::unique_ptr<SwapPromise>> swap_promise_list_;
   std::set<SwapPromiseMonitor*> swap_promise_monitor_;
 
   PropertyTrees property_trees_;
 
-  using ElementLayersMap = std::unordered_map<ElementId, Layer*, ElementIdHash>;
-  ElementLayersMap element_layers_map_;
-
   uint32_t surface_client_id_;
   uint32_t next_surface_sequence_;
   uint32_t num_consecutive_frames_suitable_for_gpu_ = 0;
 
-  // Layer tree that hold layers.
-  LayerTree layer_tree_;
-
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHost);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_H_