Introduce Display Compositor mojo interface. Use InProcessContextProvider.

services/ui/ws/window_server.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 "services/ui/ws/window_server.h"
 
 #include <set>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 37 matching lines @@
 // GpuServiceProxy.
 WindowServer::WindowServer(WindowServerDelegate* delegate)
     : delegate_(delegate),
       next_client_id_(1),
       display_manager_(new DisplayManager(this, &user_id_tracker_)),
       current_operation_(nullptr),
       in_destructor_(false),
       next_wm_change_id_(0),
       gpu_proxy_(new GpuServiceProxy(this)),
       window_manager_window_tree_factory_set_(this, &user_id_tracker_),
-      display_compositor_client_binding_(this),
-      display_compositor_(new DisplayCompositor(
-          display_compositor_client_binding_.CreateInterfacePtrAndBind())) {
+      display_compositor_client_binding_(this) {
   user_id_tracker_.AddObserver(this);
   OnUserIdAdded(user_id_tracker_.active_id());
+  display_compositor_request_ = mojo::GetProxy(&display_compositor_);
 }
 
 WindowServer::~WindowServer() {
   in_destructor_ = true;
 
   for (auto& pair : tree_map_)
     pair.second->PrepareForWindowServerShutdown();
 
   // Destroys the window trees results in querying for the display. Tear down
   // the displays first so that the trees are notified of the display going
@@ skipping 415 matching lines @@
   return nullptr;
 }
 
 WindowTree* WindowServer::GetCurrentDragLoopInitiator() {
   if (current_drag_loop_)
     return current_drag_loop_->initiator;
   return nullptr;
 }
 
 void WindowServer::OnDisplayReady(Display* display, bool is_first) {
-  if (gpu_channel_)
-    display->platform_display()->OnGpuChannelEstablished(gpu_channel_);
   if (is_first)
     delegate_->OnFirstDisplayReady();
 }
 
 void WindowServer::OnNoMoreDisplays() {
   delegate_->OnNoMoreDisplays();
 }
 
 WindowManagerState* WindowServer::GetWindowManagerStateForUser(
     const UserId& user_id) {
   return window_manager_window_tree_factory_set_.GetWindowManagerStateForUser(
       user_id);
 }
 
-ui::DisplayCompositor* WindowServer::GetDisplayCompositor() {
+cc::mojom::DisplayCompositor* WindowServer::GetDisplayCompositor() {
   return display_compositor_.get();
 }
 
 bool WindowServer::GetFrameDecorationsForUser(
     const UserId& user_id,
     mojom::FrameDecorationValuesPtr* values) {
   WindowManagerState* window_manager_state =
       window_manager_window_tree_factory_set_.GetWindowManagerStateForUser(
           user_id);
   if (!window_manager_state)
@@ skipping 212 matching lines @@
                                             ServerWindow* transient_child) {
   // If we're deleting a window, then this is a superfluous message.
   if (current_operation_type() == OperationType::DELETE_WINDOW)
     return;
   for (auto& pair : tree_map_) {
     pair.second->ProcessTransientWindowRemoved(window, transient_child,
                                                IsOperationSource(pair.first));
   }
 }
 
-void WindowServer::OnGpuChannelEstablished(
-    scoped_refptr<gpu::GpuChannelHost> gpu_channel) {
-  gpu_channel_ = std::move(gpu_channel);
-  const std::set<Display*>& displays = display_manager()->displays();
-  for (auto* display : displays)
-    display->platform_display()->OnGpuChannelEstablished(gpu_channel_);
+void WindowServer::OnGpuServiceInitialized() {
+  gpu_proxy_->CreateDisplayCompositor(
+      std::move(display_compositor_request_),
+      display_compositor_client_binding_.CreateInterfacePtrAndBind());
   // TODO(kylechar): When gpu channel is removed, this can instead happen
   // earlier, after GpuServiceProxy::OnInitialized().
   delegate_->StartDisplayInit();
 }
 
 void WindowServer::OnSurfaceCreated(const cc::SurfaceId& surface_id,
                                     const gfx::Size& frame_size,
                                     float device_scale_factor) {
   WindowId window_id(
       WindowIdFromTransportId(surface_id.frame_sink_id().client_id()));
@@ skipping 36 matching lines @@
 void WindowServer::OnUserIdAdded(const UserId& id) {
   activity_monitor_map_[id] = base::MakeUnique<UserActivityMonitor>(nullptr);
 }
 
 void WindowServer::OnUserIdRemoved(const UserId& id) {
   activity_monitor_map_.erase(id);
 }
 
 }  // namespace ws
 }  // namespace ui