Fork cc::OutputSurface into cc::CompositorFrameSink.

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 13 matching lines @@
 #include "cc/base/cc_export.h"
 #include "cc/debug/micro_benchmark.h"
 #include "cc/debug/micro_benchmark_controller.h"
 #include "cc/input/event_listener_properties.h"
 #include "cc/input/input_handler.h"
 #include "cc/input/layer_selection_bound.h"
 #include "cc/input/scrollbar.h"
 #include "cc/input/top_controls_state.h"
 #include "cc/layers/layer_collections.h"
 #include "cc/layers/layer_list_iterator.h"
-#include "cc/output/output_surface.h"
+#include "cc/output/compositor_frame_sink.h"
 #include "cc/output/swap_promise.h"
 #include "cc/resources/resource_format.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_host_interface.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "cc/trees/proxy.h"
 #include "cc/trees/surface_sequence_generator.h"
 #include "cc/trees/swap_promise_manager.h"
@@ skipping 101 matching lines @@
   UIResourceManager* GetUIResourceManager() const override;
   TaskRunnerProvider* GetTaskRunnerProvider() const override;
   const LayerTreeSettings& GetSettings() const override;
   void SetSurfaceClientId(uint32_t client_id) override;
   void SetLayerTreeMutator(std::unique_ptr<LayerTreeMutator> mutator) override;
   void QueueSwapPromise(std::unique_ptr<SwapPromise> swap_promise) override;
   SwapPromiseManager* GetSwapPromiseManager() override;
   void SetHasGpuRasterizationTrigger(bool has_trigger) override;
   void SetVisible(bool visible) override;
   bool IsVisible() const override;
-  void SetOutputSurface(std::unique_ptr<OutputSurface> output_surface) override;
-  std::unique_ptr<OutputSurface> ReleaseOutputSurface() override;
+  void SetCompositorFrameSink(
+      std::unique_ptr<CompositorFrameSink> compositor_frame_sink) override;
+  std::unique_ptr<CompositorFrameSink> ReleaseCompositorFrameSink() override;
   void SetNeedsAnimate() override;
   void SetNeedsUpdateLayers() override;
   void SetNeedsCommit() override;
   bool BeginMainFrameRequested() const override;
   bool CommitRequested() const override;
   void SetDeferCommits(bool defer_commits) override;
   void LayoutAndUpdateLayers() override;
   void Composite(base::TimeTicks frame_begin_time) override;
   void SetNeedsRedraw() override;
   void SetNeedsRedrawRect(const gfx::Rect& damage_rect) override;
@@ skipping 17 matching lines @@
   // LayerTreeHost interface to Proxy.
   void WillBeginMainFrame();
   void DidBeginMainFrame();
   void BeginMainFrame(const BeginFrameArgs& args);
   void BeginMainFrameNotExpectedSoon();
   void AnimateLayers(base::TimeTicks monotonic_frame_begin_time);
   void RequestMainFrameUpdate();
   void FinishCommitOnImplThread(LayerTreeHostImpl* host_impl);
   void WillCommit();
   void CommitComplete();
-  void RequestNewOutputSurface();
-  void DidInitializeOutputSurface();
-  void DidFailToInitializeOutputSurface();
+  void RequestNewCompositorFrameSink();
+  void DidInitializeCompositorFrameSink();
+  void DidFailToInitializeCompositorFrameSink();
   virtual std::unique_ptr<LayerTreeHostImpl> CreateLayerTreeHostImpl(
       LayerTreeHostImplClient* client);
-  void DidLoseOutputSurface();
+  void DidLoseCompositorFrameSink();
   void DidCommitAndDrawFrame() { client_->DidCommitAndDrawFrame(); }
   void DidCompleteSwapBuffers() { client_->DidCompleteSwapBuffers(); }
   bool UpdateLayers();
   // Called when the compositor completed page scale animation.
   void DidCompletePageScaleAnimation();
   void ApplyScrollAndScale(ScrollAndScaleSet* info);
 
   LayerTreeHostClient* client() { return client_; }
 
   bool gpu_rasterization_histogram_recorded() const {
@@ skipping 132 matching lines @@
   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_;
 
   SwapPromiseManager swap_promise_manager_;
 
-  // |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_;
+  // |current_compositor_frame_sink_| can't be updated until we've successfully
+  // initialized a new CompositorFrameSink. |new_compositor_frame_sink_|
+  // contains the new CompositorFrameSink that is currently being initialized.
+  // If initialization is successful then |new_compositor_frame_sink_| replaces
+  // |current_compositor_frame_sink_|.
+  std::unique_ptr<CompositorFrameSink> new_compositor_frame_sink_;
+  std::unique_ptr<CompositorFrameSink> current_compositor_frame_sink_;
 
   const LayerTreeSettings settings_;
   LayerTreeDebugState debug_state_;
 
   bool visible_;
 
   bool has_gpu_rasterization_trigger_;
   bool content_is_suitable_for_gpu_rasterization_;
   bool gpu_rasterization_histogram_recorded_;
 
@@ skipping 14 matching lines @@
 
   SurfaceSequenceGenerator surface_sequence_generator_;
   uint32_t num_consecutive_frames_suitable_for_gpu_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHost);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_H_