Fork cc::OutputSurface into cc::CompositorFrameSink.

ui/compositor/test/in_process_context_factory.cc

 // Copyright 2014 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 "ui/compositor/test/in_process_context_factory.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/scheduler/begin_frame_source.h"
 #include "cc/scheduler/delay_based_time_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/test/pixel_test_output_surface.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/reflector.h"
 #include "ui/compositor/test/in_process_context_provider.h"
@@ skipping 66 matching lines @@
 
 }  // namespace
 
 InProcessContextFactory::InProcessContextFactory(
     bool context_factory_for_test,
     cc::SurfaceManager* surface_manager)
     : next_surface_client_id_(1u),
       use_test_surface_(true),
       context_factory_for_test_(context_factory_for_test),
       surface_manager_(surface_manager) {
+  DCHECK(surface_manager);
   DCHECK_NE(gl::GetGLImplementation(), gl::kGLImplementationNone)
       << "If running tests, ensure that main() is calling "
       << "gl::GLSurfaceTestSupport::InitializeOneOff()";
 }
 
 InProcessContextFactory::~InProcessContextFactory() {
   DCHECK(per_compositor_data_.empty());
 }
 
 void InProcessContextFactory::SendOnLostResources() {
   FOR_EACH_OBSERVER(ContextFactoryObserver, observer_list_, OnLostResources());
 }
 
-void InProcessContextFactory::CreateOutputSurface(
+void InProcessContextFactory::CreateCompositorFrameSink(
     base::WeakPtr<Compositor> compositor) {
   // Try to reuse existing shared worker context provider.
   bool shared_worker_context_provider_lost = false;
   if (shared_worker_context_provider_) {
     // Note: If context is lost, delete reference after releasing the lock.
     base::AutoLock lock(*shared_worker_context_provider_->GetLock());
     if (shared_worker_context_provider_->ContextGL()
             ->GetGraphicsResetStatusKHR() != GL_NO_ERROR) {
       shared_worker_context_provider_lost = true;
     }
@@ skipping 27 matching lines @@
   if (use_test_surface_) {
     bool flipped_output_surface = false;
     display_output_surface = base::MakeUnique<cc::PixelTestOutputSurface>(
         context_provider, shared_worker_context_provider_,
         flipped_output_surface);
   } else {
     display_output_surface = base::MakeUnique<DirectOutputSurface>(
         context_provider, shared_worker_context_provider_);
   }
 
-  if (surface_manager_) {
-    std::unique_ptr<cc::DelayBasedBeginFrameSource> begin_frame_source(
-        new cc::DelayBasedBeginFrameSource(
-            base::MakeUnique<cc::DelayBasedTimeSource>(
-                compositor->task_runner().get())));
-    std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler(
-        begin_frame_source.get(), compositor->task_runner().get(),
-        display_output_surface->capabilities().max_frames_pending));
-    per_compositor_data_[compositor.get()] = base::MakeUnique<cc::Display>(
-        GetSharedBitmapManager(), GetGpuMemoryBufferManager(),
-        compositor->GetRendererSettings(), std::move(begin_frame_source),
-        std::move(display_output_surface), std::move(scheduler),
-        base::MakeUnique<cc::TextureMailboxDeleter>(
-            compositor->task_runner().get()));
+  std::unique_ptr<cc::DelayBasedBeginFrameSource> begin_frame_source(
+      new cc::DelayBasedBeginFrameSource(
+          base::MakeUnique<cc::DelayBasedTimeSource>(
+              compositor->task_runner().get())));
+  std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler(
+      begin_frame_source.get(), compositor->task_runner().get(),
+      display_output_surface->capabilities().max_frames_pending));
+  per_compositor_data_[compositor.get()] = base::MakeUnique<cc::Display>(
+      GetSharedBitmapManager(), GetGpuMemoryBufferManager(),
+      compositor->GetRendererSettings(), std::move(begin_frame_source),
+      std::move(display_output_surface), std::move(scheduler),
+      base::MakeUnique<cc::TextureMailboxDeleter>(
+          compositor->task_runner().get()));
 
-    auto* display = per_compositor_data_[compositor.get()].get();
-    std::unique_ptr<cc::SurfaceDisplayOutputSurface> surface_output_surface(
-        new cc::SurfaceDisplayOutputSurface(
-            surface_manager_, compositor->surface_id_allocator(), display,
-            context_provider, shared_worker_context_provider_));
-    compositor->SetOutputSurface(std::move(surface_output_surface));
-  } else {
-    compositor->SetOutputSurface(std::move(display_output_surface));
-  }
+  auto* display = per_compositor_data_[compositor.get()].get();
+  auto compositor_frame_sink = base::MakeUnique<cc::DirectCompositorFrameSink>(
+      surface_manager_, compositor->surface_id_allocator(), display,
+      context_provider, shared_worker_context_provider_);
+  compositor->SetCompositorFrameSink(std::move(compositor_frame_sink));
 }
 
 std::unique_ptr<Reflector> InProcessContextFactory::CreateReflector(
     Compositor* mirrored_compositor,
     Layer* mirroring_layer) {
   return base::WrapUnique(new FakeReflector);
 }
 
 void InProcessContextFactory::RemoveReflector(Reflector* reflector) {
 }
@@ skipping 67 matching lines @@
 
 void InProcessContextFactory::AddObserver(ContextFactoryObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void InProcessContextFactory::RemoveObserver(ContextFactoryObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 }  // namespace ui