Rename DisplayCompositor to MojoFrameSinkManager.

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 27 matching lines @@
   WindowTree* initiator;
   gfx::Rect revert_bounds;
 };
 
 struct WindowServer::CurrentDragLoopState {
   uint32_t change_id;
   ServerWindow* window;
   WindowTree* initiator;
 };
 
-// TODO(fsamuel): DisplayCompositor should be a mojo interface dispensed by
-// GpuHost.
 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_host_(new GpuHost(this)),
       window_manager_window_tree_factory_set_(this, &user_id_tracker_),
-      display_compositor_client_binding_(this) {
+      frame_sink_manager_client_binding_(this) {
   user_id_tracker_.AddObserver(this);
   OnUserIdAdded(user_id_tracker_.active_id());
-  gpu_host_->CreateDisplayCompositor(
-      mojo::MakeRequest(&display_compositor_),
-      display_compositor_client_binding_.CreateInterfacePtrAndBind());
+  gpu_host_->CreateFrameSinkManager(
+      mojo::MakeRequest(&frame_sink_manager_),
+      frame_sink_manager_client_binding_.CreateInterfacePtrAndBind());
 }
 
 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 453 matching lines @@
 void WindowServer::OnNoMoreDisplays() {
   delegate_->OnNoMoreDisplays();
 }
 
 WindowManagerState* WindowServer::GetWindowManagerStateForUser(
     const UserId& user_id) {
   return window_manager_window_tree_factory_set_.GetWindowManagerStateForUser(
       user_id);
 }
 
-cc::mojom::DisplayCompositor* WindowServer::GetDisplayCompositor() {
-  return display_compositor_.get();
+cc::mojom::FrameSinkManager* WindowServer::GetFrameSinkManager() {
+  return frame_sink_manager_.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)
     return false;
@@ skipping 81 matching lines @@
   // The client that embeds |window| is expected to submit a CompositorFrame
   // that references |surface_id|. Have the parent claim ownership of the
   // temporary reference to |surface_id|. If the parent client crashes before it
   // adds a surface reference then the GPU can cleanup temporary references. If
   // no parent client embeds |window| then tell the GPU to drop the temporary
   // reference immediately.
   if (current) {
     current->GetOrCreateCompositorFrameSinkManager()->ClaimTemporaryReference(
         surface_id);
   } else {
-    display_compositor_->DropTemporaryReference(surface_id);
+    frame_sink_manager_->DropTemporaryReference(surface_id);
   }
 }
 
 ServerWindow* WindowServer::GetRootWindow(const ServerWindow* window) {
   Display* display = display_manager_->GetDisplayContaining(window);
   return display ? display->root_window() : nullptr;
 }
 
 void WindowServer::OnWindowDestroyed(ServerWindow* window) {
   ProcessWindowDeleted(window);
@@ skipping 16 matching lines @@
 
   WindowManagerDisplayRoot* display_root =
       display_manager_->GetWindowManagerDisplayRoot(window);
   if (display_root)
     display_root->window_manager_state()
         ->ReleaseCaptureBlockedByAnyModalWindow();
 
   ProcessWindowHierarchyChanged(window, new_parent, old_parent);
 
   if (old_parent) {
-    display_compositor_->UnregisterFrameSinkHierarchy(
+    frame_sink_manager_->UnregisterFrameSinkHierarchy(
         old_parent->frame_sink_id(), window->frame_sink_id());
   }
   if (new_parent) {
-    display_compositor_->RegisterFrameSinkHierarchy(new_parent->frame_sink_id(),
+    frame_sink_manager_->RegisterFrameSinkHierarchy(new_parent->frame_sink_id(),
                                                     window->frame_sink_id());
   }
 
   UpdateNativeCursorFromMouseLocation(window);
 }
 
 void WindowServer::OnWindowBoundsChanged(ServerWindow* window,
                                          const gfx::Rect& old_bounds,
                                          const gfx::Rect& new_bounds) {
   if (in_destructor_)
@@ skipping 118 matching lines @@
   delegate_->StartDisplayInit();
 }
 
 void WindowServer::OnSurfaceCreated(const cc::SurfaceInfo& surface_info) {
   WindowId window_id(
       WindowIdFromTransportId(surface_info.id().frame_sink_id().client_id()));
   ServerWindow* window = GetWindow(window_id);
 
   // If the window doesn't exist then we have nothing to propagate.
   if (!window) {
-    display_compositor_->DropTemporaryReference(surface_info.id());
+    frame_sink_manager_->DropTemporaryReference(surface_info.id());
     return;
   }
 
   // This is only used for testing to observe that a window has a
   // CompositorFrame.
   if (!window_paint_callback_.is_null())
     window_paint_callback_.Run(window);
 
   auto* display = display_manager_->GetDisplayContaining(window);
   if (display && window == display->GetActiveRootWindow()) {
@@ skipping 26 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