Fork cc::OutputSurface into cc::CompositorFrameSink.

blimp/client/app/compositor/browser_compositor.cc

Index: blimp/client/app/compositor/browser_compositor.cc
diff --git a/blimp/client/app/compositor/browser_compositor.cc b/blimp/client/app/compositor/browser_compositor.cc
index 81e278eb340cf6a64b55f072c62ca3d3497b5538..d6134624f53d5c545108a674c9b844b994629318 100644
--- a/blimp/client/app/compositor/browser_compositor.cc
+++ b/blimp/client/app/compositor/browser_compositor.cc
@@ -12,10 +12,11 @@
 #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"
@@ -73,7 +74,7 @@ BrowserCompositor::BrowserCompositor(
       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());
@@ -124,7 +125,7 @@ void BrowserCompositor::SetAcceleratedWidget(gfx::AcceleratedWidget widget) {
     // We are always visible if we have a widget.
     DCHECK(host_->IsVisible());
     host_->SetVisible(false);
-    host_->ReleaseOutputSurface();
+    host_->ReleaseCompositorFrameSink();
     display_.reset();
   }
 
@@ -133,25 +134,25 @@ void BrowserCompositor::SetAcceleratedWidget(gfx::AcceleratedWidget widget) {
   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() {
@@ -160,8 +161,8 @@ void BrowserCompositor::DidCompleteSwapBuffers() {
   }
 }
 
-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())
@@ -175,7 +176,7 @@ void BrowserCompositor::HandlePendingOutputSurfaceRequest() {
   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();
@@ -184,24 +185,23 @@ void BrowserCompositor::HandlePendingOutputSurfaceRequest() {
           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