Mus: Move creation of cc::Display to DisplayCompositor

services/ui/surfaces/gpu_compositor_frame_sink.cc

 // Copyright 2015 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 "services/ui/surfaces/gpu_compositor_frame_sink.h"
 
 #include "base/callback.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/output_surface.h"
-#include "cc/output/texture_mailbox_deleter.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/scheduler/begin_frame_source.h"
-#include "cc/surfaces/display_scheduler.h"
+#include "cc/surfaces/display.h"
 #include "services/ui/surfaces/display_compositor.h"
-#include "services/ui/surfaces/display_output_surface.h"
-
-#if defined(USE_OZONE)
-#include "gpu/command_buffer/client/gles2_interface.h"
-#include "services/ui/surfaces/display_output_surface_ozone.h"
-#endif
 
 namespace ui {
 
 GpuCompositorFrameSink::GpuCompositorFrameSink(
     DisplayCompositor* display_compositor,
     const cc::FrameSinkId& frame_sink_id,
-    gpu::SurfaceHandle surface_handle,
-    gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
-    scoped_refptr<cc::InProcessContextProvider> context_provider,
+    std::unique_ptr<cc::Display> display,
     cc::mojom::MojoCompositorFrameSinkRequest request,
     cc::mojom::MojoCompositorFrameSinkPrivateRequest private_request,
     cc::mojom::MojoCompositorFrameSinkClientPtr client)
     : frame_sink_id_(frame_sink_id),
-      task_runner_(base::ThreadTaskRunnerHandle::Get()),
       display_compositor_(display_compositor),
+      display_(std::move(display)),
       surface_factory_(frame_sink_id_, display_compositor_->manager(), this),
       client_(std::move(client)),
       binding_(this, std::move(request)),
       private_binding_(this, std::move(private_request)),
       weak_factory_(this) {
   display_compositor_->manager()->RegisterFrameSinkId(frame_sink_id_);
   display_compositor_->manager()->RegisterSurfaceFactoryClient(frame_sink_id_,
                                                                this);
 
-  if (surface_handle != gpu::kNullSurfaceHandle) {
-    InitDisplay(surface_handle, gpu_memory_buffer_manager,
-                std::move(context_provider));
+  if (display_) {
+    display_->Initialize(this, display_compositor_->manager());
+    display_->SetVisible(true);
   }
 
   binding_.set_connection_error_handler(base::Bind(
       &GpuCompositorFrameSink::OnClientConnectionLost, base::Unretained(this)));
 
   private_binding_.set_connection_error_handler(
       base::Bind(&GpuCompositorFrameSink::OnPrivateConnectionLost,
                  base::Unretained(this)));
 }
 
@@ skipping 54 matching lines @@
                                               child_frame_sink_id);
 }
 
 void GpuCompositorFrameSink::RemoveChildFrameSink(
     const cc::FrameSinkId& child_frame_sink_id) {
   cc::SurfaceManager* surface_manager = display_compositor_->manager();
   surface_manager->UnregisterFrameSinkHierarchy(frame_sink_id_,
                                                 child_frame_sink_id);
 }
 
-void GpuCompositorFrameSink::InitDisplay(
-    gpu::SurfaceHandle surface_handle,
-    gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
-    scoped_refptr<cc::InProcessContextProvider> context_provider) {
-  // TODO(rjkroege): If there is something better to do than CHECK, add it.
-  CHECK(context_provider->BindToCurrentThread());
-
-  std::unique_ptr<cc::SyntheticBeginFrameSource> synthetic_begin_frame_source(
-      new cc::DelayBasedBeginFrameSource(
-          base::MakeUnique<cc::DelayBasedTimeSource>(task_runner_.get())));
-
-  std::unique_ptr<cc::OutputSurface> display_output_surface;
-  if (context_provider->ContextCapabilities().surfaceless) {
-#if defined(USE_OZONE)
-    display_output_surface = base::MakeUnique<DisplayOutputSurfaceOzone>(
-        std::move(context_provider), surface_handle,
-        synthetic_begin_frame_source.get(), gpu_memory_buffer_manager,
-        GL_TEXTURE_2D, GL_RGB);
-#else
-    NOTREACHED();
-#endif
-  } else {
-    display_output_surface = base::MakeUnique<DisplayOutputSurface>(
-        std::move(context_provider), synthetic_begin_frame_source.get());
-  }
-
-  int max_frames_pending =
-      display_output_surface->capabilities().max_frames_pending;
-  DCHECK_GT(max_frames_pending, 0);
-
-  std::unique_ptr<cc::DisplayScheduler> scheduler(
-      new cc::DisplayScheduler(synthetic_begin_frame_source.get(),
-                               task_runner_.get(), max_frames_pending));
-
-  display_.reset(new cc::Display(
-      nullptr /* bitmap_manager */, gpu_memory_buffer_manager,
-      cc::RendererSettings(), frame_sink_id_,
-      std::move(synthetic_begin_frame_source),
-      std::move(display_output_surface), std::move(scheduler),
-      base::MakeUnique<cc::TextureMailboxDeleter>(task_runner_.get())));
-  display_->Initialize(this, display_compositor_->manager());
-  display_->SetVisible(true);
-}
-
 void GpuCompositorFrameSink::DisplayOutputSurfaceLost() {}
 
 void GpuCompositorFrameSink::DisplayWillDrawAndSwap(
     bool will_draw_and_swap,
     const cc::RenderPassList& render_passes) {}
 
 void GpuCompositorFrameSink::DisplayDidDrawAndSwap() {}
 
 void GpuCompositorFrameSink::ReturnResources(
     const cc::ReturnedResourceArray& resources) {
@@ skipping 56 matching lines @@
 }
 
 void GpuCompositorFrameSink::OnPrivateConnectionLost() {
   private_connection_lost_ = true;
   // Request destruction of |this| only if both connections are lost.
   display_compositor_->OnCompositorFrameSinkPrivateConnectionLost(
       frame_sink_id_, client_connection_lost_);
 }
 
 }  // namespace ui