Fork cc::OutputSurface into cc::CompositorFrameSink.

cc/output/compositor_frame_sink.cc

Index: cc/output/compositor_frame_sink.cc
diff --git a/cc/output/output_surface.cc b/cc/output/compositor_frame_sink.cc
similarity index 80%
copy from cc/output/output_surface.cc
copy to cc/output/compositor_frame_sink.cc
index 8746131927d47ed0dea2513f39f925e60a13536f..b441aca45de7f71608ca061cd9a62da37fd7763d 100644
--- a/cc/output/output_surface.cc
+++ b/cc/output/compositor_frame_sink.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "cc/output/output_surface.h"
+#include "cc/output/compositor_frame_sink.h"
 
 #include <stdint.h>
 
@@ -13,8 +13,8 @@
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event.h"
+#include "cc/output/compositor_frame_sink_client.h"
 #include "cc/output/managed_memory_policy.h"
-#include "cc/output/output_surface_client.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
@@ -119,7 +119,7 @@ class SkiaGpuTraceMemoryDump : public SkTraceMemoryDump {
 
 }  // namespace
 
-OutputSurface::OutputSurface(
+CompositorFrameSink::CompositorFrameSink(
     scoped_refptr<ContextProvider> context_provider,
     scoped_refptr<ContextProvider> worker_context_provider,
     std::unique_ptr<SoftwareOutputDevice> software_device)
@@ -130,25 +130,25 @@ OutputSurface::OutputSurface(
   client_thread_checker_.DetachFromThread();
 }
 
-OutputSurface::OutputSurface(
+CompositorFrameSink::CompositorFrameSink(
     scoped_refptr<VulkanContextProvider> vulkan_context_provider)
     : vulkan_context_provider_(vulkan_context_provider),
       weak_ptr_factory_(this) {
   client_thread_checker_.DetachFromThread();
 }
 
-OutputSurface::~OutputSurface() {
+CompositorFrameSink::~CompositorFrameSink() {
   if (client_)
     DetachFromClientInternal();
 }
 
-bool OutputSurface::HasExternalStencilTest() const {
+bool CompositorFrameSink::HasExternalStencilTest() const {
   return false;
 }
 
-void OutputSurface::ApplyExternalStencil() {}
+void CompositorFrameSink::ApplyExternalStencil() {}
 
-bool OutputSurface::BindToClient(OutputSurfaceClient* client) {
+bool CompositorFrameSink::BindToClient(CompositorFrameSinkClient* client) {
   DCHECK(client_thread_checker_.CalledOnValidThread());
   DCHECK(client);
   DCHECK(!client_);
@@ -158,8 +158,9 @@ bool OutputSurface::BindToClient(OutputSurfaceClient* client) {
   if (context_provider_.get()) {
     success = context_provider_->BindToCurrentThread();
     if (success) {
-      context_provider_->SetLostContextCallback(base::Bind(
-          &OutputSurface::DidLoseOutputSurface, base::Unretained(this)));
+      context_provider_->SetLostContextCallback(
+          base::Bind(&CompositorFrameSink::DidLoseCompositorFrameSink,
+                     base::Unretained(this)));
     }
   }
 
@@ -171,7 +172,7 @@ bool OutputSurface::BindToClient(OutputSurfaceClient* client) {
     // thread's task runner. This will overwrite any previous dump provider
     // registered.
     base::trace_event::MemoryDumpManager::GetInstance()->RegisterDumpProvider(
-        this, "OutputSurface", base::ThreadTaskRunnerHandle::Get());
+        this, "CompositorFrameSink", base::ThreadTaskRunnerHandle::Get());
   }
 
   if (!success)
@@ -179,26 +180,26 @@ bool OutputSurface::BindToClient(OutputSurfaceClient* client) {
   return success;
 }
 
-void OutputSurface::DetachFromClient() {
+void CompositorFrameSink::DetachFromClient() {
   DetachFromClientInternal();
 }
 
-void OutputSurface::EnsureBackbuffer() {
+void CompositorFrameSink::EnsureBackbuffer() {
   if (software_device_)
     software_device_->EnsureBackbuffer();
 }
 
-void OutputSurface::DiscardBackbuffer() {
+void CompositorFrameSink::DiscardBackbuffer() {
   if (context_provider_.get())
     context_provider_->ContextGL()->DiscardBackbufferCHROMIUM();
   if (software_device_)
     software_device_->DiscardBackbuffer();
 }
 
-void OutputSurface::Reshape(const gfx::Size& size,
-                            float scale_factor,
-                            const gfx::ColorSpace& color_space,
-                            bool has_alpha) {
+void CompositorFrameSink::Reshape(const gfx::Size& size,
+                                  float scale_factor,
+                                  const gfx::ColorSpace& color_space,
+                                  bool has_alpha) {
   device_color_space_ = color_space;
   if (size == surface_size_ && scale_factor == device_scale_factor_ &&
       has_alpha == has_alpha_)
@@ -215,46 +216,48 @@ void OutputSurface::Reshape(const gfx::Size& size,
     software_device_->Resize(size, scale_factor);
 }
 
-void OutputSurface::BindFramebuffer() {
+void CompositorFrameSink::BindFramebuffer() {
   DCHECK(context_provider_.get());
   context_provider_->ContextGL()->BindFramebuffer(GL_FRAMEBUFFER, 0);
 }
 
-void OutputSurface::PostSwapBuffersComplete() {
+void CompositorFrameSink::PostSwapBuffersComplete() {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&OutputSurface::OnSwapBuffersComplete,
+      FROM_HERE, base::Bind(&CompositorFrameSink::OnSwapBuffersComplete,
                             weak_ptr_factory_.GetWeakPtr()));
 }
 
 // We don't post tasks bound to the client directly since they might run
-// after the OutputSurface has been destroyed.
-void OutputSurface::OnSwapBuffersComplete() {
+// after the CompositorFrameSink has been destroyed.
+void CompositorFrameSink::OnSwapBuffersComplete() {
   client_->DidSwapBuffersComplete();
 }
 
-void OutputSurface::DidReceiveTextureInUseResponses(
+void CompositorFrameSink::DidReceiveTextureInUseResponses(
     const gpu::TextureInUseResponses& responses) {
   client_->DidReceiveTextureInUseResponses(responses);
 }
 
-OverlayCandidateValidator* OutputSurface::GetOverlayCandidateValidator() const {
+OverlayCandidateValidator* CompositorFrameSink::GetOverlayCandidateValidator()
+    const {
   return nullptr;
 }
 
-bool OutputSurface::IsDisplayedAsOverlayPlane() const {
+bool CompositorFrameSink::IsDisplayedAsOverlayPlane() const {
   return false;
 }
 
-unsigned OutputSurface::GetOverlayTextureId() const {
+unsigned CompositorFrameSink::GetOverlayTextureId() const {
   return 0;
 }
 
-bool OutputSurface::SurfaceIsSuspendForRecycle() const {
+bool CompositorFrameSink::SurfaceIsSuspendForRecycle() const {
   return false;
 }
 
-bool OutputSurface::OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
-                                 base::trace_event::ProcessMemoryDump* pmd) {
+bool CompositorFrameSink::OnMemoryDump(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
   if (auto* context_provider = this->context_provider()) {
     // No need to lock, main context provider is not shared.
     if (auto* gr_context = context_provider->GrContext()) {
@@ -276,7 +279,7 @@ bool OutputSurface::OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
   return true;
 }
 
-void OutputSurface::DetachFromClientInternal() {
+void CompositorFrameSink::DetachFromClientInternal() {
   DCHECK(client_thread_checker_.CalledOnValidThread());
   DCHECK(client_);
 
@@ -294,9 +297,9 @@ void OutputSurface::DetachFromClientInternal() {
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
-void OutputSurface::DidLoseOutputSurface() {
-  TRACE_EVENT0("cc", "OutputSurface::DidLoseOutputSurface");
-  client_->DidLoseOutputSurface();
+void CompositorFrameSink::DidLoseCompositorFrameSink() {
+  TRACE_EVENT0("cc", "CompositorFrameSink::DidLoseCompositorFrameSink");
+  client_->DidLoseCompositorFrameSink();
 }
 
 }  // namespace cc