Fork cc::OutputSurface into cc::CompositorFrameSink.

cc/trees/threaded_channel.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/threaded_channel.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 29 matching lines @@
 void ThreadedChannel::UpdateTopControlsStateOnImpl(TopControlsState constraints,
                                                    TopControlsState current,
                                                    bool animate) {
   DCHECK(IsMainThread());
   ImplThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ProxyImpl::UpdateTopControlsStateOnImpl, proxy_impl_weak_ptr_,
                  constraints, current, animate));
 }
 
-void ThreadedChannel::InitializeOutputSurfaceOnImpl(
-    OutputSurface* output_surface) {
+void ThreadedChannel::InitializeCompositorFrameSinkOnImpl(
+    CompositorFrameSink* output_surface) {
   DCHECK(IsMainThread());
   ImplThreadTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&ProxyImpl::InitializeOutputSurfaceOnImpl,
+      FROM_HERE, base::Bind(&ProxyImpl::InitializeCompositorFrameSinkOnImpl,
                             proxy_impl_weak_ptr_, output_surface));
 }
 
 void ThreadedChannel::InitializeMutatorOnImpl(
     std::unique_ptr<LayerTreeMutator> mutator) {
   ImplThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ProxyImpl::InitializeMutatorOnImpl, proxy_impl_weak_ptr_,
                  base::Passed(std::move(mutator))));
 }
@@ skipping 44 matching lines @@
                             proxy_impl_weak_ptr_, damage_rect));
 }
 
 void ThreadedChannel::SetVisibleOnImpl(bool visible) {
   DCHECK(IsMainThread());
   ImplThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ProxyImpl::SetVisibleOnImpl, proxy_impl_weak_ptr_, visible));
 }
 
-void ThreadedChannel::ReleaseOutputSurfaceOnImpl(CompletionEvent* completion) {
+void ThreadedChannel::ReleaseCompositorFrameSinkOnImpl(
+    CompletionEvent* completion) {
   DCHECK(IsMainThread());
   ImplThreadTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&ProxyImpl::ReleaseOutputSurfaceOnImpl,
+      FROM_HERE, base::Bind(&ProxyImpl::ReleaseCompositorFrameSinkOnImpl,
                             proxy_impl_weak_ptr_, completion));
 }
 
 void ThreadedChannel::MainFrameWillHappenOnImplForTesting(
     CompletionEvent* completion,
     bool* main_frame_will_happen) {
   DCHECK(IsMainThread());
   ImplThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&ProxyImpl::MainFrameWillHappenOnImplForTesting,
@@ skipping 81 matching lines @@
 }
 
 void ThreadedChannel::SetAnimationEvents(
     std::unique_ptr<AnimationEvents> events) {
   DCHECK(IsImplThread());
   MainThreadTaskRunner()->PostTask(
       FROM_HERE, base::Bind(&ProxyMain::SetAnimationEvents,
                             impl().proxy_main_weak_ptr, base::Passed(&events)));
 }
 
-void ThreadedChannel::DidLoseOutputSurface() {
+void ThreadedChannel::DidLoseCompositorFrameSink() {
   DCHECK(IsImplThread());
   MainThreadTaskRunner()->PostTask(
-      FROM_HERE,
-      base::Bind(&ProxyMain::DidLoseOutputSurface, impl().proxy_main_weak_ptr));
-}
-
-void ThreadedChannel::RequestNewOutputSurface() {
-  DCHECK(IsImplThread());
-  MainThreadTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&ProxyMain::RequestNewOutputSurface,
+      FROM_HERE, base::Bind(&ProxyMain::DidLoseCompositorFrameSink,
                             impl().proxy_main_weak_ptr));
 }
 
-void ThreadedChannel::DidInitializeOutputSurface(bool success) {
+void ThreadedChannel::RequestNewCompositorFrameSink() {
   DCHECK(IsImplThread());
   MainThreadTaskRunner()->PostTask(
-      FROM_HERE, base::Bind(&ProxyMain::DidInitializeOutputSurface,
+      FROM_HERE, base::Bind(&ProxyMain::RequestNewCompositorFrameSink,
+                            impl().proxy_main_weak_ptr));
+}
+
+void ThreadedChannel::DidInitializeCompositorFrameSink(bool success) {
+  DCHECK(IsImplThread());
+  MainThreadTaskRunner()->PostTask(
+      FROM_HERE, base::Bind(&ProxyMain::DidInitializeCompositorFrameSink,
                             impl().proxy_main_weak_ptr, success));
 }
 
 void ThreadedChannel::DidCompletePageScaleAnimation() {
   DCHECK(IsImplThread());
   MainThreadTaskRunner()->PostTask(
       FROM_HERE, base::Bind(&ProxyMain::DidCompletePageScaleAnimation,
                             impl().proxy_main_weak_ptr));
 }
 
@@ skipping 88 matching lines @@
 
 ThreadedChannel::MainThreadOnly::~MainThreadOnly() {}
 
 ThreadedChannel::CompositorThreadOnly::CompositorThreadOnly(
     base::WeakPtr<ProxyMain> proxy_main_weak_ptr)
     : proxy_main_weak_ptr(proxy_main_weak_ptr) {}
 
 ThreadedChannel::CompositorThreadOnly::~CompositorThreadOnly() {}
 
 }  // namespace cc