cc: Move data to LayerTree from LayerTreeHost.

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 110 matching lines @@
   // a CompositorMessageToImpl::CloseImpl message from the server. This ensures
   // that the client will not send any compositor messages once the
   // LayerTreeHost on the server is destroyed.
   static std::unique_ptr<LayerTreeHost> CreateRemoteClient(
       RemoteProtoChannel* remote_proto_channel,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
       InitParams* params);
 
   virtual ~LayerTreeHost();
 
-  // LayerTreeHost interface to Proxy.
+  // LayerTreeHost interface to Proxy
   void WillBeginMainFrame();
   void DidBeginMainFrame();
   void BeginMainFrame(const BeginFrameArgs& args);
   void BeginMainFrameNotExpectedSoon();
   void AnimateLayers(base::TimeTicks monotonic_frame_begin_time);
   void DidStopFlinging();
   void RequestMainFrameUpdate();
   void FinishCommitOnImplThread(LayerTreeHostImpl* host_impl);
   void WillCommit();
   void CommitComplete();
   void SetOutputSurface(std::unique_ptr<OutputSurface> output_surface);
   std::unique_ptr<OutputSurface> ReleaseOutputSurface();
   void RequestNewOutputSurface();
   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();
+  // Called when the compositor completed page scale animation.
+  void DidCompletePageScaleAnimation();
 
   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);
 
@@ skipping 13 matching lines @@
 
   RenderingStatsInstrumentation* rendering_stats_instrumentation() const {
     return rendering_stats_instrumentation_.get();
   }
 
   virtual const RendererCapabilities& GetRendererCapabilities() const;
 
   void SetNeedsAnimate();
   virtual void SetNeedsUpdateLayers();
   virtual void SetNeedsCommit();
-  virtual void SetNeedsFullTreeSync();
-  virtual void SetNeedsMetaInfoRecomputation(
-      bool needs_meta_info_recomputation);
   void SetNeedsRedraw();
   void SetNeedsRedrawRect(const gfx::Rect& damage_rect);
   bool CommitRequested() const;
   bool BeginMainFrameRequested() const;
 
   void SetNextCommitWaitsForActivation();
 
   void SetNextCommitForcesRedraw();
 
   void SetAnimationEvents(std::unique_ptr<AnimationEvents> events);
 
-  void SetRootLayer(scoped_refptr<Layer> root_layer);
-  Layer* root_layer() { return root_layer_.get(); }
-  const Layer* root_layer() const { return root_layer_.get(); }
-  const Layer* overscroll_elasticity_layer() const {
-    return overscroll_elasticity_layer_.get();
-  }
-  const Layer* page_scale_layer() const { return page_scale_layer_.get(); }
-  void RegisterViewportLayers(scoped_refptr<Layer> overscroll_elasticity_layer,
-                              scoped_refptr<Layer> page_scale_layer,
-                              scoped_refptr<Layer> inner_viewport_scroll_layer,
-                              scoped_refptr<Layer> outer_viewport_scroll_layer);
-  Layer* inner_viewport_scroll_layer() const {
-    return inner_viewport_scroll_layer_.get();
-  }
-  Layer* outer_viewport_scroll_layer() const {
-    return outer_viewport_scroll_layer_.get();
-  }
-
-  void RegisterSelection(const LayerSelection& selection);
-
-  bool have_scroll_event_handlers() const {
-    return have_scroll_event_handlers_;
-  }
-  void SetHaveScrollEventHandlers(bool have_event_handlers);
-
-  void SetEventListenerProperties(EventListenerClass event_class,
-                                  EventListenerProperties event_properties);
-  EventListenerProperties event_listener_properties(
-      EventListenerClass event_class) const {
-    return event_listener_properties_[static_cast<size_t>(event_class)];
-  }
-
   const LayerTreeSettings& settings() const { return settings_; }
 
   void SetDebugState(const LayerTreeDebugState& debug_state);
   const LayerTreeDebugState& debug_state() const { return debug_state_; }
 
   bool has_gpu_rasterization_trigger() const {
     return has_gpu_rasterization_trigger_;
   }
   void SetHasGpuRasterizationTrigger(bool has_trigger);
 
-  void SetViewportSize(const gfx::Size& device_viewport_size);
-  void SetTopControlsHeight(float height, bool shrink);
-  void SetTopControlsShownRatio(float ratio);
-
-  gfx::Size device_viewport_size() const { return device_viewport_size_; }
-
   void ApplyPageScaleDeltaFromImplSide(float page_scale_delta);
-  void SetPageScaleFactorAndLimits(float page_scale_factor,
-                                   float min_page_scale_factor,
-                                   float max_page_scale_factor);
-  float page_scale_factor() const { return page_scale_factor_; }
-  gfx::Vector2dF elastic_overscroll() const { return elastic_overscroll_; }
-
-  SkColor background_color() const { return background_color_; }
-  void set_background_color(SkColor color) { background_color_ = color; }
-
-  void set_has_transparent_background(bool transparent) {
-    has_transparent_background_ = transparent;
-  }
 
   void SetVisible(bool visible);
   bool visible() const { return visible_; }
 
-  void StartPageScaleAnimation(const gfx::Vector2d& target_offset,
-                               bool use_anchor,
-                               float scale,
-                               base::TimeDelta duration);
-  bool HasPendingPageScaleAnimation() const;
-
   void ApplyScrollAndScale(ScrollAndScaleSet* info);
-  void SetImplTransform(const gfx::Transform& transform);
-
-  void SetDeviceScaleFactor(float device_scale_factor);
-  void SetPaintedDeviceScaleFactor(float painted_device_scale_factor);
-
-  float device_scale_factor() const { return device_scale_factor_; }
 
   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
@@ skipping 31 matching lines @@
   // See swap_promise.h for how to use SwapPromise.
   void QueueSwapPromise(std::unique_ptr<SwapPromise> swap_promise);
   void BreakSwapPromises(SwapPromise::DidNotSwapReason reason);
   std::vector<std::unique_ptr<SwapPromise>> TakeSwapPromises();
 
   size_t num_queued_swap_promises() const { return swap_promise_list_.size(); }
 
   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,
@@ skipping 56 matching lines @@
   }
 
   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(); }
+
+  void ResetGpuRasterizationTracking();
 
  protected:
+  // Allow tests to inject the LayerTree.
+  LayerTreeHost(InitParams* params,
+                CompositorMode mode,
+                std::unique_ptr<LayerTree> layer_tree);
   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,
       std::unique_ptr<BeginFrameSource> external_begin_frame_source);
   void InitializeRemoteServer(
       RemoteProtoChannel* remote_proto_channel,
@@ skipping 17 matching lines @@
   // task_graph_runner() return valid values only until the LayerTreeHostImpl is
   // created in CreateLayerTreeHostImpl().
   SharedBitmapManager* shared_bitmap_manager() const {
     return shared_bitmap_manager_;
   }
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager() const {
     return gpu_memory_buffer_manager_;
   }
   TaskGraphRunner* task_graph_runner() const { return task_graph_runner_; }
 
-  MicroBenchmarkController micro_benchmark_controller_;
-
   void OnCommitForSwapPromises();
 
   void RecordGpuRasterizationHistogram();
 
+  MicroBenchmarkController micro_benchmark_controller_;
+
+  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 18 matching lines @@
   UIResourceRequestQueue ui_resource_request_queue_;
 
   void CalculateLCDTextMetricsCallback(Layer* layer);
 
   void NotifySwapPromiseMonitorsOfSetNeedsCommit();
 
   void SetPropertyTreesNeedRebuild();
 
   const CompositorMode compositor_mode_;
 
-  bool needs_full_tree_sync_;
-  bool needs_meta_info_recomputation_;
-
   LayerTreeHostClient* client_;
   std::unique_ptr<Proxy> proxy_;
   std::unique_ptr<TaskRunnerProvider> task_runner_provider_;
 
   int source_frame_number_;
   std::unique_ptr<RenderingStatsInstrumentation>
       rendering_stats_instrumentation_;
 
   // |current_output_surface_| can't be updated until we've successfully
   // initialized a new output surface. |new_output_surface_| contains the
   // new output surface that is currently being initialized. If initialization
   // is successful then |new_output_surface_| replaces
   // |current_output_surface_|.
   std::unique_ptr<OutputSurface> new_output_surface_;
   std::unique_ptr<OutputSurface> current_output_surface_;
   bool output_surface_lost_;
 
-  scoped_refptr<Layer> root_layer_;
-  scoped_refptr<HeadsUpDisplayLayer> hud_layer_;
-
   base::WeakPtr<InputHandler> input_handler_weak_ptr_;
 
   const LayerTreeSettings settings_;
   LayerTreeDebugState debug_state_;
 
-  gfx::Size device_viewport_size_;
-  bool top_controls_shrink_blink_size_;
-  float top_controls_height_;
-  float top_controls_shown_ratio_;
-  float device_scale_factor_;
-  float painted_device_scale_factor_;
-
   bool visible_;
 
-  float page_scale_factor_;
-  float min_page_scale_factor_;
-  float max_page_scale_factor_;
-  gfx::Vector2dF elastic_overscroll_;
   bool has_gpu_rasterization_trigger_;
   bool content_is_suitable_for_gpu_rasterization_;
   bool gpu_rasterization_histogram_recorded_;
 
-  SkColor background_color_;
-  bool has_transparent_background_;
-
-  bool have_scroll_event_handlers_;
-  EventListenerProperties event_listener_properties_[static_cast<size_t>(
-      EventListenerClass::kNumClasses)];
-
-  std::unique_ptr<PendingPageScaleAnimation> pending_page_scale_animation_;
+  gfx::Vector2dF elastic_overscroll_;
 
   // If set, then page scale animation has completed, but the client hasn't been
   // notified about it yet.
   bool did_complete_scale_animation_;
 
   int id_;
   bool next_commit_forces_redraw_;
 
-  scoped_refptr<Layer> overscroll_elasticity_layer_;
-  scoped_refptr<Layer> page_scale_layer_;
-  scoped_refptr<Layer> inner_viewport_scroll_layer_;
-  scoped_refptr<Layer> outer_viewport_scroll_layer_;
-
-  LayerSelection selection_;
-
   SharedBitmapManager* shared_bitmap_manager_;
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
   TaskGraphRunner* task_graph_runner_;
 
   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_