Fork cc::OutputSurface into cc::CompositorFrameSink.

blimp/client/app/compositor/browser_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/app/compositor/browser_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 37 matching lines @@
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 BrowserCompositor::BrowserCompositor(
     CompositorDependencies* compositor_dependencies)
     : compositor_dependencies_(compositor_dependencies),
       surface_id_allocator_(base::MakeUnique<cc::SurfaceIdAllocator>(
           compositor_dependencies->AllocateSurfaceClientId())),
       widget_(gfx::kNullAcceleratedWidget),
-      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 30 matching lines @@
     display_->Resize(viewport_size_in_px_);
   }
 }
 
 void BrowserCompositor::SetAcceleratedWidget(gfx::AcceleratedWidget widget) {
   // Kill all references to the old widget.
   if (widget_ != gfx::kNullAcceleratedWidget) {
     // We are always visible if we have a widget.
     DCHECK(host_->IsVisible());
     host_->SetVisible(false);
-    host_->ReleaseOutputSurface();
+    host_->ReleaseCompositorFrameSink();
     display_.reset();
   }
 
   widget_ = gfx::kNullAcceleratedWidget;
 
   if (widget != gfx::kNullAcceleratedWidget) {
     widget_ = widget;
     host_->SetVisible(true);
-    if (output_surface_request_pending_) {
-      HandlePendingOutputSurfaceRequest();
+    if (compositor_frame_sink_request_pending_) {
+      HandlePendingCompositorFrameSinkRequest();
     }
   }
 }
 
-void BrowserCompositor::RequestNewOutputSurface() {
-  DCHECK(!output_surface_request_pending_)
+void BrowserCompositor::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 BrowserCompositor::DidInitializeOutputSurface() {
-  output_surface_request_pending_ = false;
+void BrowserCompositor::DidInitializeCompositorFrameSink() {
+  compositor_frame_sink_request_pending_ = false;
 }
 
-void BrowserCompositor::DidFailToInitializeOutputSurface() {
-  NOTREACHED() << "Can't fail to initialize the OutputSurface here";
+void BrowserCompositor::DidFailToInitializeCompositorFrameSink() {
+  NOTREACHED() << "Can't fail to initialize the CompositorFrameSink here";
 }
 
 void BrowserCompositor::DidCompleteSwapBuffers() {
   if (!did_complete_swap_buffers_.is_null()) {
     did_complete_swap_buffers_.Run();
   }
 }
 
-void BrowserCompositor::HandlePendingOutputSurfaceRequest() {
-  DCHECK(output_surface_request_pending_);
+void BrowserCompositor::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_NE(gfx::kNullAcceleratedWidget, widget_);
 
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager =
       compositor_dependencies_->GetGpuMemoryBufferManager();
 
   scoped_refptr<cc::ContextProvider> context_provider =
       BlimpContextProvider::Create(widget_, gpu_memory_buffer_manager);
 
-  std::unique_ptr<cc::OutputSurface> display_output_surface =
+  std::unique_ptr<cc::OutputSurface> 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));
+      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),
+      std::move(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);
+  // The browser's layer tree and display compositors share the same context
+  // provider.
+  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