Introduce Display Compositor mojo interface. Use InProcessContextProvider.

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/ws/gpu_compositor_frame_sink.h"
+#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 "services/ui/surfaces/direct_output_surface.h"
 #include "services/ui/surfaces/display_compositor.h"
 
 #if defined(USE_OZONE)
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "services/ui/surfaces/direct_output_surface_ozone.h"
 #endif
 
 namespace ui {
-namespace ws {
 
 GpuCompositorFrameSink::GpuCompositorFrameSink(
-    scoped_refptr<DisplayCompositor> display_compositor,
+    DisplayCompositor* display_compositor,
     const cc::FrameSinkId& frame_sink_id,
-    gfx::AcceleratedWidget widget,
+    gpu::SurfaceHandle surface_handle,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
-    scoped_refptr<SurfacesContextProvider> context_provider,
+    scoped_refptr<cc::InProcessContextProvider> context_provider,
     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),
       surface_factory_(frame_sink_id_, display_compositor_->manager(), this),
       client_(std::move(client)),
-      binding_(this, std::move(request)) {
+      binding_(this, std::move(request)),
+      private_binding_(this, std::move(private_request)) {
   display_compositor_->manager()->RegisterFrameSinkId(frame_sink_id_);
   display_compositor_->manager()->RegisterSurfaceFactoryClient(frame_sink_id_,
                                                                this);
 
-  if (widget != gfx::kNullAcceleratedWidget)
-    InitDisplay(widget, gpu_memory_buffer_manager, std::move(context_provider));
+  if (surface_handle != gpu::kNullSurfaceHandle) {
+    InitDisplay(surface_handle, gpu_memory_buffer_manager,
+                std::move(context_provider));
+  }
+
+  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)));
 }
 
 GpuCompositorFrameSink::~GpuCompositorFrameSink() {
   // SurfaceFactory's destructor will attempt to return resources which will
   // call back into here and access |client_| so we should destroy
   // |surface_factory_|'s resources early on.
   surface_factory_.DestroyAll();
   display_compositor_->manager()->UnregisterSurfaceFactoryClient(
       frame_sink_id_);
   display_compositor_->manager()->InvalidateFrameSinkId(frame_sink_id_);
@@ skipping 48 matching lines @@
 }
 
 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(
-    gfx::AcceleratedWidget widget,
+    gpu::SurfaceHandle surface_handle,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
-    scoped_refptr<SurfacesContextProvider> context_provider) {
+    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<DirectOutputSurfaceOzone>(
-        context_provider, widget, synthetic_begin_frame_source.get(),
-        gpu_memory_buffer_manager, GL_TEXTURE_2D, GL_RGB);
+        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<DirectOutputSurface>(
-        context_provider, synthetic_begin_frame_source.get());
+        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));
 
@@ skipping 61 matching lines @@
   if (needs_begin_frame_ == added_frame_observer_)
     return;
 
   added_frame_observer_ = needs_begin_frame_;
   if (needs_begin_frame_)
     begin_frame_source_->AddObserver(this);
   else
     begin_frame_source_->RemoveObserver(this);
 }
 
-}  // namespace ws
+void GpuCompositorFrameSink::OnClientConnectionLost() {
+  client_connection_lost_ = true;
+  // Request destruction of |this| only if both connections are lost.
+  display_compositor_->OnCompositorFrameSinkClientConnectionLost(
+      frame_sink_id_, private_connection_lost_);
+}
+
+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