Introduce Display Compositor mojo interface. Use InProcessContextProvider.

services/ui/ws/frame_generator.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 "services/ui/ws/frame_generator.h"
 
 #include "base/containers/adapters.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/surface_draw_quad.h"
-#include "gpu/ipc/client/gpu_channel_host.h"
-#include "services/ui/surfaces/display_compositor.h"
-#include "services/ui/surfaces/surfaces_context_provider.h"
+#include "cc/surfaces/surface_id.h"
 #include "services/ui/ws/frame_generator_delegate.h"
 #include "services/ui/ws/server_window.h"
 #include "services/ui/ws/server_window_compositor_frame_sink_manager.h"
 #include "services/ui/ws/server_window_delegate.h"
 
 namespace ui {
 
 namespace ws {
 
 FrameGenerator::FrameGenerator(FrameGeneratorDelegate* delegate,
@@ skipping 10 matching lines @@
 
 FrameGenerator::~FrameGenerator() {
   RemoveDeadSurfaceReferences();
   RemoveAllSurfaceReferences();
   // Invalidate WeakPtrs now to avoid callbacks back into the
   // FrameGenerator during destruction of |compositor_frame_sink_|.
   weak_factory_.InvalidateWeakPtrs();
   compositor_frame_sink_.reset();
 }
 
-void FrameGenerator::OnGpuChannelEstablished(
-    scoped_refptr<gpu::GpuChannelHost> channel) {
-  if (widget_ != gfx::kNullAcceleratedWidget) {
-    cc::mojom::MojoCompositorFrameSinkRequest request =
-        mojo::GetProxy(&compositor_frame_sink_);
-    // TODO(fsamuel): FrameGenerator should not know about
-    // SurfacesContextProvider. In fact, FrameGenerator should not know
-    // about GpuChannelHost.
-    root_window_->CreateCompositorFrameSink(
-        mojom::CompositorFrameSinkType::DEFAULT, widget_,
-        channel->gpu_memory_buffer_manager(),
-        new SurfacesContextProvider(widget_, channel), std::move(request),
-        binding_.CreateInterfacePtrAndBind());
-    // TODO(fsamuel): This means we're always requesting a new BeginFrame signal
-    // even when we don't need it. Once surface ID propagation work is done,
-    // this will not be necessary because FrameGenerator will only need a
-    // BeginFrame if the window manager changes.
-    compositor_frame_sink_->SetNeedsBeginFrame(true);
-  } else {
-    gpu_channel_ = std::move(channel);
-  }
-}
-
 void FrameGenerator::OnAcceleratedWidgetAvailable(
     gfx::AcceleratedWidget widget) {
-  widget_ = widget;
-  if (gpu_channel_ && widget != gfx::kNullAcceleratedWidget) {
-    cc::mojom::MojoCompositorFrameSinkRequest request =
-        mojo::GetProxy(&compositor_frame_sink_);
-    root_window_->CreateCompositorFrameSink(
-        mojom::CompositorFrameSinkType::DEFAULT, widget_,
-        gpu_channel_->gpu_memory_buffer_manager(),
-        new SurfacesContextProvider(widget_, gpu_channel_),
-        std::move(request), binding_.CreateInterfacePtrAndBind());
-    // TODO(fsamuel): This means we're always requesting a new BeginFrame signal
-    // even when we don't need it. Once surface ID propagation work is done,
-    // this will not be necessary because FrameGenerator will only need a
-    // BeginFrame if the window manager changes.
-    compositor_frame_sink_->SetNeedsBeginFrame(true);
-  }
+  DCHECK_NE(gfx::kNullAcceleratedWidget, widget);
+  cc::mojom::MojoCompositorFrameSinkRequest request =
+      mojo::GetProxy(&compositor_frame_sink_);
+  root_window_->CreateCompositorFrameSink(
+      mojom::CompositorFrameSinkType::DEFAULT, widget, std::move(request),
+      binding_.CreateInterfacePtrAndBind());
+  // TODO(fsamuel): This means we're always requesting a new BeginFrame signal
+  // even when we don't need it. Once surface ID propagation work is done,
+  // this will not be necessary because FrameGenerator will only need a
+  // BeginFrame if the window manager changes.
+  compositor_frame_sink_->SetNeedsBeginFrame(true);
 }
 
 void FrameGenerator::OnSurfaceCreated(const cc::SurfaceId& surface_id,
                                       ServerWindow* window) {
   DCHECK(surface_id.is_valid());
 
   // TODO(kylechar): Adding surface references should be synchronized with
   // SubmitCompositorFrame().
 
   auto iter = active_references_.find(surface_id.frame_sink_id());
@@ skipping 208 matching lines @@
 
   // Observe |window| so that we can remove references when it's destroyed.
   Add(window);
 }
 
 void FrameGenerator::AddNewParentReferences(
     const cc::SurfaceId& old_surface_id,
     const cc::SurfaceId& new_surface_id) {
   DCHECK(old_surface_id.frame_sink_id() == new_surface_id.frame_sink_id());
 
-  DisplayCompositor* display_compositor = GetDisplayCompositor();
+  cc::mojom::DisplayCompositor* display_compositor = GetDisplayCompositor();
   for (auto& map_entry : active_references_) {
     SurfaceReference& ref = map_entry.second;
     if (ref.parent_id == old_surface_id) {
       display_compositor->AddSurfaceReference(new_surface_id, ref.child_id);
       ref.parent_id = new_surface_id;
     }
   }
 }
 
 void FrameGenerator::RemoveDeadSurfaceReferences() {
   if (dead_references_.empty())
     return;
 
-  DisplayCompositor* display_compositor = GetDisplayCompositor();
+  cc::mojom::DisplayCompositor* display_compositor = GetDisplayCompositor();
   for (auto& ref : dead_references_) {
     if (ref.parent_id == top_level_root_surface_id_)
       display_compositor->RemoveRootSurfaceReference(ref.child_id);
     else
       display_compositor->RemoveSurfaceReference(ref.parent_id, ref.child_id);
   }
   dead_references_.clear();
 }
 
 void FrameGenerator::RemoveFrameSinkReference(
     const cc::FrameSinkId& frame_sink_id) {
   auto it = active_references_.find(frame_sink_id);
   if (it == active_references_.end())
     return;
   dead_references_.push_back(it->second);
   active_references_.erase(it);
 }
 
 void FrameGenerator::RemoveAllSurfaceReferences() {
   // TODO(kylechar): Remove multiple surfaces with one IPC call.
-  DisplayCompositor* display_compositor = GetDisplayCompositor();
+  cc::mojom::DisplayCompositor* display_compositor = GetDisplayCompositor();
   for (auto& map_entry : active_references_) {
     const SurfaceReference& ref = map_entry.second;
     display_compositor->RemoveSurfaceReference(ref.parent_id, ref.child_id);
   }
   active_references_.clear();
 }
 
-ui::DisplayCompositor* FrameGenerator::GetDisplayCompositor() {
+cc::mojom::DisplayCompositor* FrameGenerator::GetDisplayCompositor() {
   return root_window_->delegate()->GetDisplayCompositor();
 }
 
 void FrameGenerator::OnWindowDestroying(ServerWindow* window) {
   Remove(window);
   ServerWindowCompositorFrameSinkManager* compositor_frame_sink_manager =
       window->compositor_frame_sink_manager();
   // If FrameGenerator was observing |window|, then that means it had a
   // CompositorFrame at some point in time and should have a
   // ServerWindowCompositorFrameSinkManager.
   DCHECK(compositor_frame_sink_manager);
 
   cc::SurfaceId default_surface_id =
       window->compositor_frame_sink_manager()->GetLatestSurfaceId(
           mojom::CompositorFrameSinkType::DEFAULT);
   if (default_surface_id.is_valid())
     RemoveFrameSinkReference(default_surface_id.frame_sink_id());
 
   cc::SurfaceId underlay_surface_id =
       window->compositor_frame_sink_manager()->GetLatestSurfaceId(
           mojom::CompositorFrameSinkType::UNDERLAY);
   if (underlay_surface_id.is_valid())
     RemoveFrameSinkReference(underlay_surface_id.frame_sink_id());
 }
 
 }  // namespace ws
 
 }  // namespace ui