Fork cc::OutputSurface into cc::CompositorFrameSink.

cc/output/compositor_frame_sink.cc

 // Copyright (c) 2013 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/output/output_surface.h"
+#include "cc/output/compositor_frame_sink.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #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"
 #include "third_party/skia/include/core/SkTraceMemoryDump.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/trace_util.h"
 
 class SkDiscardableMemory;
@@ skipping 84 matching lines @@
   }
 
   base::trace_event::ProcessMemoryDump* pmd_;
   uint64_t share_group_tracing_guid_;
 
   DISALLOW_COPY_AND_ASSIGN(SkiaGpuTraceMemoryDump);
 };
 
 }  // namespace
 
-OutputSurface::OutputSurface(
+CompositorFrameSink::CompositorFrameSink(
     scoped_refptr<ContextProvider> context_provider,
     scoped_refptr<ContextProvider> worker_context_provider,
     std::unique_ptr<SoftwareOutputDevice> software_device)
     : context_provider_(std::move(context_provider)),
       worker_context_provider_(std::move(worker_context_provider)),
       software_device_(std::move(software_device)),
       weak_ptr_factory_(this) {
   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_);
   client_ = client;
   bool success = true;
 
   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)));
     }
   }
 
   // In certain cases, ThreadTaskRunnerHandle isn't set (Android Webview).
   // Don't register a dump provider in these cases.
   // TODO(ericrk): Get this working in Android Webview. crbug.com/517156
   if (base::ThreadTaskRunnerHandle::IsSet()) {
     // Now that we are on the context thread, register a dump provider with this
     // 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)
     DetachFromClient();
   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_)
     return;
 
   surface_size_ = size;
   device_scale_factor_ = scale_factor;
   has_alpha_ = has_alpha;
   if (context_provider_.get()) {
     context_provider_->ContextGL()->ResizeCHROMIUM(size.width(), size.height(),
                                                    scale_factor, has_alpha);
   }
   if (software_device_)
     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()) {
       SkiaGpuTraceMemoryDump trace_memory_dump(
           pmd, context_provider->ContextSupport()->ShareGroupTracingGUID());
       gr_context->dumpMemoryStatistics(&trace_memory_dump);
     }
   }
   if (auto* context_provider = worker_context_provider()) {
     ContextProvider::ScopedContextLock scoped_context(context_provider);
 
     if (auto* gr_context = context_provider->GrContext()) {
       SkiaGpuTraceMemoryDump trace_memory_dump(
           pmd, context_provider->ContextSupport()->ShareGroupTracingGUID());
       gr_context->dumpMemoryStatistics(&trace_memory_dump);
     }
   }
 
   return true;
 }
 
-void OutputSurface::DetachFromClientInternal() {
+void CompositorFrameSink::DetachFromClientInternal() {
   DCHECK(client_thread_checker_.CalledOnValidThread());
   DCHECK(client_);
 
   // Unregister any dump provider. Safe to call (no-op) if we have not yet
   // registered.
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 
   if (context_provider_.get()) {
     context_provider_->SetLostContextCallback(
         ContextProvider::LostContextCallback());
   }
   context_provider_ = nullptr;
   client_ = nullptr;
   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