Fork cc::OutputSurface into cc::CompositorFrameSink.

cc/trees/proxy_main.cc

 // Copyright 2015 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/trees/proxy_main.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "base/trace_event/trace_event_synthetic_delay.h"
 #include "cc/animation/animation_events.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/debug/devtools_instrumentation.h"
-#include "cc/output/output_surface.h"
+#include "cc/output/compositor_frame_sink.h"
 #include "cc/output/swap_promise.h"
 #include "cc/resources/ui_resource_manager.h"
 #include "cc/trees/blocking_task_runner.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/remote_channel_main.h"
 #include "cc/trees/scoped_abort_remaining_swap_promises.h"
 #include "cc/trees/threaded_channel.h"
 
 namespace cc {
 
@@ skipping 60 matching lines @@
   DCHECK(IsMainThread());
   layer_tree_host_->DidCommitAndDrawFrame();
 }
 
 void ProxyMain::SetAnimationEvents(std::unique_ptr<AnimationEvents> events) {
   TRACE_EVENT0("cc", "ProxyMain::SetAnimationEvents");
   DCHECK(IsMainThread());
   layer_tree_host_->SetAnimationEvents(std::move(events));
 }
 
-void ProxyMain::DidLoseOutputSurface() {
-  TRACE_EVENT0("cc", "ProxyMain::DidLoseOutputSurface");
+void ProxyMain::DidLoseCompositorFrameSink() {
+  TRACE_EVENT0("cc", "ProxyMain::DidLoseCompositorFrameSink");
   DCHECK(IsMainThread());
-  layer_tree_host_->DidLoseOutputSurface();
+  layer_tree_host_->DidLoseCompositorFrameSink();
 }
 
-void ProxyMain::RequestNewOutputSurface() {
-  TRACE_EVENT0("cc", "ProxyMain::RequestNewOutputSurface");
+void ProxyMain::RequestNewCompositorFrameSink() {
+  TRACE_EVENT0("cc", "ProxyMain::RequestNewCompositorFrameSink");
   DCHECK(IsMainThread());
-  layer_tree_host_->RequestNewOutputSurface();
+  layer_tree_host_->RequestNewCompositorFrameSink();
 }
 
-void ProxyMain::DidInitializeOutputSurface(bool success) {
-  TRACE_EVENT0("cc", "ProxyMain::DidInitializeOutputSurface");
+void ProxyMain::DidInitializeCompositorFrameSink(bool success) {
+  TRACE_EVENT0("cc", "ProxyMain::DidInitializeCompositorFrameSink");
   DCHECK(IsMainThread());
 
   if (!success)
-    layer_tree_host_->DidFailToInitializeOutputSurface();
+    layer_tree_host_->DidFailToInitializeCompositorFrameSink();
   else
-    layer_tree_host_->DidInitializeOutputSurface();
+    layer_tree_host_->DidInitializeCompositorFrameSink();
 }
 
 void ProxyMain::DidCompletePageScaleAnimation() {
   DCHECK(IsMainThread());
   layer_tree_host_->DidCompletePageScaleAnimation();
 }
 
 void ProxyMain::BeginMainFrame(
     std::unique_ptr<BeginMainFrameAndCommitState> begin_main_frame_state) {
   benchmark_instrumentation::ScopedBeginFrameTask begin_frame_task(
@@ skipping 118 matching lines @@
   DCHECK(IsMainThread());
   return started_;
 }
 
 bool ProxyMain::CommitToActiveTree() const {
   // With ProxyMain, we use a pending tree and activate it once it's ready to
   // draw to allow input to modify the active tree and draw during raster.
   return false;
 }
 
-void ProxyMain::SetOutputSurface(OutputSurface* output_surface) {
-  channel_main_->InitializeOutputSurfaceOnImpl(output_surface);
+void ProxyMain::SetCompositorFrameSink(
+    CompositorFrameSink* compositor_frame_sink) {
+  channel_main_->InitializeCompositorFrameSinkOnImpl(compositor_frame_sink);
 }
 
 void ProxyMain::SetVisible(bool visible) {
   TRACE_EVENT1("cc", "ProxyMain::SetVisible", "visible", visible);
   channel_main_->SetVisibleOnImpl(visible);
 }
 
 void ProxyMain::SetNeedsAnimate() {
   DCHECK(IsMainThread());
   if (SendCommitRequestToImplThreadIfNeeded(ANIMATE_PIPELINE_STAGE)) {
@@ skipping 121 matching lines @@
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_);
     CompletionEvent completion;
     channel_main_->MainFrameWillHappenOnImplForTesting(&completion,
                                                        &main_frame_will_happen);
     completion.Wait();
   }
   return main_frame_will_happen;
 }
 
-void ProxyMain::ReleaseOutputSurface() {
+void ProxyMain::ReleaseCompositorFrameSink() {
   DCHECK(IsMainThread());
   DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_);
   CompletionEvent completion;
-  channel_main_->ReleaseOutputSurfaceOnImpl(&completion);
+  channel_main_->ReleaseCompositorFrameSinkOnImpl(&completion);
   completion.Wait();
 }
 
 void ProxyMain::UpdateTopControlsState(TopControlsState constraints,
                                        TopControlsState current,
                                        bool animate) {
   DCHECK(IsMainThread());
   channel_main_->UpdateTopControlsStateOnImpl(constraints, current, animate);
 }
 
 bool ProxyMain::SendCommitRequestToImplThreadIfNeeded(
     CommitPipelineStage required_stage) {
   DCHECK(IsMainThread());
   DCHECK_NE(NO_PIPELINE_STAGE, required_stage);
   bool already_posted = max_requested_pipeline_stage_ != NO_PIPELINE_STAGE;
   max_requested_pipeline_stage_ =
       std::max(max_requested_pipeline_stage_, required_stage);
   if (already_posted)
     return false;
   channel_main_->SetNeedsCommitOnImpl();
   return true;
 }
 
 bool ProxyMain::IsMainThread() const {
   return task_runner_provider_->IsMainThread();
 }
 
 }  // namespace cc