Fork cc::OutputSurface into cc::CompositorFrameSink.

blimp/client/support/compositor/blimp_embedder_compositor.cc

 // Copyright 2016 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 "blimp/client/support/compositor/blimp_embedder_compositor.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "blimp/client/public/compositor/compositor_dependencies.h"
 #include "blimp/client/support/compositor/blimp_context_provider.h"
 #include "cc/animation/animation_host.h"
 #include "cc/layers/layer.h"
 #include "cc/output/compositor_frame.h"
+#include "cc/output/output_surface.h"
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/raster/single_thread_task_graph_runner.h"
+#include "cc/surfaces/direct_compositor_frame_sink.h"
 #include "cc/surfaces/display.h"
-#include "cc/surfaces/surface_display_output_surface.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "cc/surfaces/surface_manager.h"
 #include "cc/trees/layer_tree_host.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_lib.h"
 
 namespace blimp {
 namespace client {
 
 namespace {
@@ skipping 36 matching lines @@
 base::LazyInstance<SimpleTaskGraphRunner> g_task_graph_runner =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 BlimpEmbedderCompositor::BlimpEmbedderCompositor(
     CompositorDependencies* compositor_dependencies)
     : compositor_dependencies_(compositor_dependencies),
       surface_id_allocator_(base::MakeUnique<cc::SurfaceIdAllocator>(
           compositor_dependencies->AllocateSurfaceClientId())),
-      output_surface_request_pending_(false),
+      compositor_frame_sink_request_pending_(false),
       root_layer_(cc::Layer::Create()) {
   compositor_dependencies_->GetSurfaceManager()->RegisterSurfaceClientId(
       surface_id_allocator_->client_id());
 
   cc::LayerTreeHost::InitParams params;
   params.client = this;
   params.gpu_memory_buffer_manager =
       compositor_dependencies_->GetGpuMemoryBufferManager();
   params.task_graph_runner = g_task_graph_runner.Pointer();
   cc::LayerTreeSettings settings;
@@ skipping 31 matching lines @@
   if (display_) {
     display_->Resize(viewport_size_in_px_);
   }
 }
 
 void BlimpEmbedderCompositor::SetContextProvider(
     scoped_refptr<cc::ContextProvider> context_provider) {
   if (context_provider_) {
     DCHECK(host_->IsVisible());
     host_->SetVisible(false);
-    host_->ReleaseOutputSurface();
+    host_->ReleaseCompositorFrameSink();
     display_.reset();
   }
 
   context_provider_ = std::move(context_provider);
 
   if (context_provider_) {
     host_->SetVisible(true);
-    if (output_surface_request_pending_) {
-      HandlePendingOutputSurfaceRequest();
+    if (compositor_frame_sink_request_pending_) {
+      HandlePendingCompositorFrameSinkRequest();
     }
   }
 }
 
-void BlimpEmbedderCompositor::RequestNewOutputSurface() {
-  DCHECK(!output_surface_request_pending_)
+void BlimpEmbedderCompositor::RequestNewCompositorFrameSink() {
+  DCHECK(!compositor_frame_sink_request_pending_)
       << "We already have a pending request?";
-  output_surface_request_pending_ = true;
-  HandlePendingOutputSurfaceRequest();
+  compositor_frame_sink_request_pending_ = true;
+  HandlePendingCompositorFrameSinkRequest();
 }
 
-void BlimpEmbedderCompositor::DidInitializeOutputSurface() {
-  output_surface_request_pending_ = false;
+void BlimpEmbedderCompositor::DidInitializeCompositorFrameSink() {
+  compositor_frame_sink_request_pending_ = false;
 }
 
-void BlimpEmbedderCompositor::DidFailToInitializeOutputSurface() {
-  NOTREACHED() << "Can't fail to initialize the OutputSurface here";
+void BlimpEmbedderCompositor::DidFailToInitializeCompositorFrameSink() {
+  NOTREACHED() << "Can't fail to initialize the CompositorFrameSink here";
 }
 
-void BlimpEmbedderCompositor::HandlePendingOutputSurfaceRequest() {
-  DCHECK(output_surface_request_pending_);
+void BlimpEmbedderCompositor::HandlePendingCompositorFrameSinkRequest() {
+  DCHECK(compositor_frame_sink_request_pending_);
 
   // Can't handle the request right now since we don't have a widget.
   if (!host_->IsVisible())
     return;
 
   DCHECK(context_provider_);
 
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager =
       compositor_dependencies_->GetGpuMemoryBufferManager();
 
-  std::unique_ptr<cc::OutputSurface> display_output_surface =
+  auto display_output_surface =
       base::MakeUnique<DisplayOutputSurface>(context_provider_);
 
   auto* task_runner = base::ThreadTaskRunnerHandle::Get().get();
   std::unique_ptr<cc::SyntheticBeginFrameSource> begin_frame_source(
       new cc::DelayBasedBeginFrameSource(
           base::MakeUnique<cc::DelayBasedTimeSource>(task_runner)));
   std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler(
       begin_frame_source.get(), task_runner,
       display_output_surface->capabilities().max_frames_pending));
 
   display_ = base::MakeUnique<cc::Display>(
       nullptr /*shared_bitmap_manager*/, gpu_memory_buffer_manager,
       host_->GetSettings().renderer_settings, std::move(begin_frame_source),
       std::move(display_output_surface), std::move(scheduler),
       base::MakeUnique<cc::TextureMailboxDeleter>(task_runner));
   display_->SetVisible(true);
   display_->Resize(viewport_size_in_px_);
 
   // The Browser compositor and display share the same context provider.
-  std::unique_ptr<cc::OutputSurface> delegated_output_surface =
-      base::MakeUnique<cc::SurfaceDisplayOutputSurface>(
-          compositor_dependencies_->GetSurfaceManager(),
-          surface_id_allocator_.get(), display_.get(), context_provider_,
-          nullptr);
+  auto compositor_frame_sink = base::MakeUnique<cc::DirectCompositorFrameSink>(
+      compositor_dependencies_->GetSurfaceManager(),
+      surface_id_allocator_.get(), display_.get(), context_provider_, nullptr);
 
-  host_->SetOutputSurface(std::move(delegated_output_surface));
+  host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
 }
 
 }  // namespace client
 }  // namespace blimp