Fork cc::OutputSurface into cc::CompositorFrameSink.

content/browser/renderer_host/compositor_impl_android.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 #include <stdint.h>
 #include <unordered_set>
@@ skipping 23 matching lines @@
 #include "cc/layers/layer.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/output/vulkan_in_process_context_provider.h"
 #include "cc/raster/single_thread_task_graph_runner.h"
 #include "cc/resources/ui_resource_manager.h"
 #include "cc/scheduler/begin_frame_source.h"
+#include "cc/surfaces/direct_compositor_frame_sink.h"
 #include "cc/surfaces/display.h"
 #include "cc/surfaces/display_scheduler.h"
-#include "cc/surfaces/surface_display_output_surface.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "components/display_compositor/compositor_overlay_candidate_validator_android.h"
 #include "components/display_compositor/gl_helper.h"
 #include "content/browser/android/child_process_launcher_android.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/renderer_host/context_provider_factory_impl_android.h"
@@ skipping 148 matching lines @@
   base::TimeTicks deadline = frame_time + vsync_period;
   last_begin_frame_args_ =
       cc::BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, deadline,
                                  vsync_period, cc::BeginFrameArgs::NORMAL);
   std::unordered_set<cc::BeginFrameObserver*> observers(observers_);
   for (auto* obs : observers)
     obs->OnBeginFrame(last_begin_frame_args_);
 }
 
 // Used to override capabilities_.adjust_deadline_for_parent to false
-class OutputSurfaceWithoutParent : public cc::OutputSurface {
+class AndroidOutputSurface : public cc::OutputSurface {
  public:
-  OutputSurfaceWithoutParent(
+  AndroidOutputSurface(
       scoped_refptr<ContextProviderCommandBuffer> context_provider,
       const base::Callback<void(gpu::Capabilities)>&
           populate_gpu_capabilities_callback)
       : cc::OutputSurface(std::move(context_provider), nullptr, nullptr),
         populate_gpu_capabilities_callback_(populate_gpu_capabilities_callback),
         swap_buffers_completion_callback_(
-            base::Bind(&OutputSurfaceWithoutParent::OnSwapBuffersCompleted,
+            base::Bind(&AndroidOutputSurface::OnSwapBuffersCompleted,
                        base::Unretained(this))),
         overlay_candidate_validator_(
             new display_compositor::
                 CompositorOverlayCandidateValidatorAndroid()) {
     capabilities_.adjust_deadline_for_parent = false;
     capabilities_.max_frames_pending = kMaxDisplaySwapBuffers;
   }
 
-  ~OutputSurfaceWithoutParent() override = default;
+  ~AndroidOutputSurface() override = default;
 
   void SwapBuffers(cc::CompositorFrame frame) override {
     GetCommandBufferProxy()->SetLatencyInfo(frame.metadata.latency_info);
     if (frame.gl_frame_data->sub_buffer_rect.IsEmpty()) {
       context_provider_->ContextSupport()->CommitOverlayPlanes();
     } else {
       DCHECK(frame.gl_frame_data->sub_buffer_rect ==
              gfx::Rect(frame.gl_frame_data->size));
       context_provider_->ContextSupport()->Swap();
     }
@@ skipping 43 matching lines @@
   base::Callback<void(gpu::Capabilities)> populate_gpu_capabilities_callback_;
   base::CancelableCallback<void(
       const std::vector<ui::LatencyInfo>&,
       gfx::SwapResult,
       const gpu::GpuProcessHostedCALayerTreeParamsMac* params_mac)>
       swap_buffers_completion_callback_;
   std::unique_ptr<cc::OverlayCandidateValidator> overlay_candidate_validator_;
 };
 
 #if defined(ENABLE_VULKAN)
-class VulkanOutputSurface : public cc::OutputSurface {
+class VulkanOutputSurface : public cc::CompositorFrameSink {
  public:
   explicit VulkanOutputSurface(
       scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider)
-      : OutputSurface(std::move(vulkan_context_provider)) {}
+      : CompositorFrameSink(std::move(vulkan_context_provider)) {}
 
   ~VulkanOutputSurface() override { Destroy(); }
 
   bool Initialize(gfx::AcceleratedWidget widget) {
     DCHECK(!surface_);
     std::unique_ptr<gpu::VulkanSurface> surface(
         gpu::VulkanSurface::CreateViewSurface(widget));
     if (!surface->Initialize(vulkan_context_provider()->GetDeviceQueue(),
                              gpu::VulkanSurface::DEFAULT_SURFACE_FORMAT)) {
       return false;
     }
     surface_ = std::move(surface);
 
     return true;
   }
 
-  bool BindToClient(cc::OutputSurfaceClient* client) override {
-    if (!OutputSurface::BindToClient(client))
+  bool BindToClient(cc::CompositorFrameSinkClient* client) override {
+    if (!CompositorFrameSink::BindToClient(client))
       return false;
     return true;
   }
 
   void SwapBuffers(cc::CompositorFrame frame) override {
     surface_->SwapBuffers();
     PostSwapBuffersComplete();
   }
 
   void Destroy() {
     if (surface_) {
       surface_->Destroy();
       surface_.reset();
     }
   }
 
   void OnSwapBuffersCompleted(const std::vector<ui::LatencyInfo>& latency_info,
                               gfx::SwapResult result) {
     RenderWidgetHostImpl::CompositorFrameDrawn(latency_info);
-    OutputSurface::OnSwapBuffersComplete();
+    CompositorFrameSink::OnSwapBuffersComplete();
   }
 
  private:
   std::unique_ptr<gpu::VulkanSurface> surface_;
 
   DISALLOW_COPY_AND_ASSIGN(VulkanOutputSurface);
 };
 #endif
 
 static bool g_initialized = false;
@@ skipping 39 matching lines @@
       resource_manager_(root_window),
       has_transparent_background_(false),
       device_scale_factor_(1),
       window_(NULL),
       surface_handle_(gpu::kNullSurfaceHandle),
       client_(client),
       root_window_(root_window),
       needs_animate_(false),
       pending_swapbuffers_(0U),
       num_successive_context_creation_failures_(0),
-      output_surface_request_pending_(false),
+      compositor_frame_sink_request_pending_(false),
       needs_begin_frames_(false),
       weak_factory_(this) {
   ui::ContextProviderFactory::GetInstance()
       ->GetSurfaceManager()
       ->RegisterSurfaceClientId(surface_id_allocator_->client_id());
   DCHECK(client);
   DCHECK(root_window);
   DCHECK(root_window->GetLayer() == nullptr);
   root_window->SetLayer(cc::Layer::Create());
   readback_layer_tree_ = cc::Layer::Create();
@@ skipping 55 matching lines @@
     // ANativeWindow_fromSurface are released immediately. This is needed as a
     // workaround for https://code.google.com/p/android/issues/detail?id=68174
     base::android::ScopedJavaLocalFrame scoped_local_reference_frame(env);
     window = ANativeWindow_fromSurface(env, surface);
   }
 
   if (window) {
     window_ = window;
     ANativeWindow_acquire(window);
     surface_handle_ = tracker->AddSurfaceForNativeWidget(window);
-    // Register first, SetVisible() might create an OutputSurface.
+    // Register first, SetVisible() might create an CompositorFrameSink.
     RegisterViewSurface(surface_handle_, j_surface);
     SetVisible(true);
     ANativeWindow_release(window);
   }
 }
 
 void CompositorImpl::CreateLayerTreeHost() {
   DCHECK(!host_);
 
   cc::LayerTreeSettings settings;
@@ skipping 36 matching lines @@
   if (!visible) {
     DCHECK(host_->IsVisible());
 
     // Make a best effort to try to complete pending readbacks.
     // TODO(crbug.com/637035): Consider doing this in a better way,
     // ideally with the guarantee of readbacks completing.
     if (display_.get() && HavePendingReadbacks())
       display_->ForceImmediateDrawAndSwapIfPossible();
 
     host_->SetVisible(false);
-    host_->ReleaseOutputSurface();
+    host_->ReleaseCompositorFrameSink();
     pending_swapbuffers_ = 0;
     display_.reset();
   } else {
     host_->SetVisible(true);
-    if (output_surface_request_pending_)
-      HandlePendingOutputSurfaceRequest();
+    if (compositor_frame_sink_request_pending_)
+      HandlePendingCompositorFrameSinkRequest();
   }
 }
 
 void CompositorImpl::setDeviceScaleFactor(float factor) {
   device_scale_factor_ = factor;
   if (host_)
     host_->GetLayerTree()->SetDeviceScaleFactor(factor);
 }
 
 void CompositorImpl::SetWindowBounds(const gfx::Size& size) {
@@ skipping 22 matching lines @@
 }
 
 void CompositorImpl::UpdateLayerTreeHost() {
   client_->UpdateLayerTreeHost();
   if (needs_animate_) {
     needs_animate_ = false;
     root_window_->Animate(base::TimeTicks::Now());
   }
 }
 
-void CompositorImpl::RequestNewOutputSurface() {
-  DCHECK(!output_surface_request_pending_)
+void CompositorImpl::RequestNewCompositorFrameSink() {
+  DCHECK(!compositor_frame_sink_request_pending_)
       << "Output Surface Request is already pending?";
 
-  output_surface_request_pending_ = true;
-  HandlePendingOutputSurfaceRequest();
+  compositor_frame_sink_request_pending_ = true;
+  HandlePendingCompositorFrameSinkRequest();
 }
 
-void CompositorImpl::DidInitializeOutputSurface() {
+void CompositorImpl::DidInitializeCompositorFrameSink() {
   num_successive_context_creation_failures_ = 0;
-  output_surface_request_pending_ = false;
+  compositor_frame_sink_request_pending_ = false;
 }
 
-void CompositorImpl::DidFailToInitializeOutputSurface() {
-  LOG(ERROR) << "Failed to init OutputSurface for compositor.";
+void CompositorImpl::DidFailToInitializeCompositorFrameSink() {
+  LOG(ERROR) << "Failed to init CompositorFrameSink for compositor.";
   LOG_IF(FATAL, ++num_successive_context_creation_failures_ >= 2)
       << "Too many context creation failures. Giving up... ";
-  HandlePendingOutputSurfaceRequest();
+  HandlePendingCompositorFrameSinkRequest();
 }
 
-void CompositorImpl::HandlePendingOutputSurfaceRequest() {
-  DCHECK(output_surface_request_pending_);
+void CompositorImpl::HandlePendingCompositorFrameSinkRequest() {
+  DCHECK(compositor_frame_sink_request_pending_);
 
   // We might have been made invisible now.
   if (!host_->IsVisible())
     return;
 
 #if defined(ENABLE_VULKAN)
   CreateVulkanOutputSurface()
   if (display_)
     return;
 #endif
 
   DCHECK(surface_handle_ != gpu::kNullSurfaceHandle);
   ContextProviderFactoryImpl::GetInstance()->RequestGpuChannelHost(base::Bind(
       &CompositorImpl::OnGpuChannelEstablished, weak_factory_.GetWeakPtr()));
 }
 
 #if defined(ENABLE_VULKAN)
 void CompositorImpl::CreateVulkanOutputSurface() {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableVulkan))
     return;
 
-  std::unique_ptr<cc::OutputSurface> display_output_surface;
   scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider =
       ui::ContextProviderFactory::GetInstance()
           ->GetSharedVulkanContextProvider();
-  if (vulkan_context_provider) {
-    std::unique_ptr<VulkanOutputSurface> vulkan_surface(
-        new VulkanOutputSurface(std::move(vulkan_context_provider)));
-    if (!vulkan_surface->Initialize(window_)) {
-      vulkan_surface->Destroy();
-      vulkan_surface.reset();
-    } else {
-      display_output_surface = std::move(vulkan_surface);
-    }
-  }
-
-  if (!display_output_surface)
+  if (!vulkan_context_provider)
     return;
 
-  InitializeDisplay(std::move(display_output_surface),
+  auto vulkan_surface =
+      base::MakeUnique<VulkanOutputSurface>(vulkan_context_provider);
+  if (!vulkan_surface->Initialize(window_))
+    return;
+
+  InitializeDisplay(std::move(vulkan_surface),
                     std::move(vulkan_context_provider), nullptr);
 }
 #endif
 
 void CompositorImpl::OnGpuChannelEstablished(
     scoped_refptr<gpu::GpuChannelHost> gpu_channel_host,
     ui::ContextProviderFactory::GpuChannelHostResult result) {
   // We might end up queing multiple GpuChannel requests for the same
-  // OutputSurface request as the visibility of the compositor changes, so the
-  // OutputSurface request could have been handled already.
-  if (!output_surface_request_pending_)
+  // CompositorFrameSink request as the visibility of the compositor changes, so
+  // the

[enne (OOO), 2016/09/14 00:35:45]

@_@

+  // CompositorFrameSink request could have been handled already.
+  if (!compositor_frame_sink_request_pending_)
     return;
 
   switch (result) {
     // Don't retry if we are shutting down.
     case ui::ContextProviderFactory::GpuChannelHostResult::
         FAILURE_FACTORY_SHUTDOWN:
       break;
     case ui::ContextProviderFactory::GpuChannelHostResult::
         FAILURE_GPU_PROCESS_INITIALIZATION_FAILED:
       // TODO(khushalsagar): Retry or have a fallback path after
@@ skipping 11 matching lines @@
               ->CreateDisplayContextProvider(
                   surface_handle_, GetCompositorContextSharedMemoryLimits(),
                   GetCompositorContextAttributes(has_transparent_background_),
                   false /*support_locking*/, false /*automatic_flushes*/,
                   std::move(gpu_channel_host));
 
       scoped_refptr<ContextProviderCommandBuffer>
           context_provider_command_buffer =
               static_cast<ContextProviderCommandBuffer*>(
                   context_provider.get());
-      std::unique_ptr<cc::OutputSurface> display_output_surface(
-          new OutputSurfaceWithoutParent(
-              context_provider_command_buffer,
-              base::Bind(&CompositorImpl::PopulateGpuCapabilities,
-                         base::Unretained(this))));
+      auto display_output_surface = base::MakeUnique<AndroidOutputSurface>(
+          context_provider_command_buffer,
+          base::Bind(&CompositorImpl::PopulateGpuCapabilities,
+                     base::Unretained(this)));
       InitializeDisplay(std::move(display_output_surface), nullptr,
                         std::move(context_provider));
       break;
   }
 }
 
 void CompositorImpl::InitializeDisplay(
     std::unique_ptr<cc::OutputSurface> display_output_surface,
     scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider,
     scoped_refptr<cc::ContextProvider> context_provider) {
-  DCHECK(output_surface_request_pending_);
+  DCHECK(compositor_frame_sink_request_pending_);
 
   pending_swapbuffers_ = 0;
 
   cc::SurfaceManager* manager =
       ui::ContextProviderFactory::GetInstance()->GetSurfaceManager();
   auto* task_runner = base::ThreadTaskRunnerHandle::Get().get();
   std::unique_ptr<ExternalBeginFrameSource> begin_frame_source(
       new ExternalBeginFrameSource(this));
   std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler(
       begin_frame_source.get(), task_runner,
       display_output_surface->capabilities().max_frames_pending));
 
   display_.reset(new cc::Display(
       HostSharedBitmapManager::current(),
       BrowserGpuMemoryBufferManager::current(),
       host_->GetSettings().renderer_settings, std::move(begin_frame_source),
       std::move(display_output_surface), std::move(scheduler),
       base::MakeUnique<cc::TextureMailboxDeleter>(task_runner)));
 
-  std::unique_ptr<cc::SurfaceDisplayOutputSurface> delegated_output_surface(
-      vulkan_context_provider ? new cc::SurfaceDisplayOutputSurface(
+  auto compositor_frame_sink =
+      vulkan_context_provider ? base::MakeUnique<cc::DirectCompositorFrameSink>(
                                     manager, surface_id_allocator_.get(),
                                     display_.get(), vulkan_context_provider)
-                              : new cc::SurfaceDisplayOutputSurface(
+                              : base::MakeUnique<cc::DirectCompositorFrameSink>(
                                     manager, surface_id_allocator_.get(),
-                                    display_.get(), context_provider, nullptr));
+                                    display_.get(), context_provider, nullptr);
 
   display_->SetVisible(true);
   display_->Resize(size_);
-  host_->SetOutputSurface(std::move(delegated_output_surface));
+  host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
 }
 
 void CompositorImpl::PopulateGpuCapabilities(
     gpu::Capabilities gpu_capabilities) {
   gpu_capabilities_ = gpu_capabilities;
 }
 
 void CompositorImpl::AddObserver(VSyncObserver* observer) {
   observer_list_.AddObserver(observer);
 }
@@ skipping 25 matching lines @@
 void CompositorImpl::DidCompleteSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidCompleteSwapBuffers");
   DCHECK_GT(pending_swapbuffers_, 0U);
   pending_swapbuffers_--;
   client_->OnSwapBuffersCompleted(pending_swapbuffers_);
 }
 
 void CompositorImpl::DidAbortSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidAbortSwapBuffers");
   // This really gets called only once from
-  // SingleThreadProxy::DidLoseOutputSurfaceOnImplThread() when the
+  // SingleThreadProxy::DidLoseCompositorFrameSinkOnImplThread() when the
   // context was lost.
   if (host_->IsVisible())
     host_->SetNeedsCommit();
   client_->OnSwapBuffersCompleted(0);
 }
 
 void CompositorImpl::DidCommit() {
   root_window_->OnCompositingDidCommit();
 }
 
@@ skipping 30 matching lines @@
 
   TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
   host_->SetNeedsAnimate();
 }
 
 bool CompositorImpl::HavePendingReadbacks() {
   return !readback_layer_tree_->children().empty();
 }
 
 }  // namespace content