Mus+Ash: Replace (Server)WindowSurface with (Server)WindowCompositorFrameSink

services/ui/ws/server_window.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/server_window.h"
 
 #include <inttypes.h>
 #include <stddef.h>
 
 #include "base/strings/stringprintf.h"
 #include "services/ui/common/transient_window_utils.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
+#include "services/ui/ws/server_window_compositor_frame_sink_manager.h"
 #include "services/ui/ws/server_window_delegate.h"
 #include "services/ui/ws/server_window_observer.h"
-#include "services/ui/ws/server_window_surface_manager.h"
 
 namespace ui {
 
 namespace ws {
 
 ServerWindow::ServerWindow(ServerWindowDelegate* delegate, const WindowId& id)
     : ServerWindow(delegate, id, Properties()) {}
 
 ServerWindow::ServerWindow(ServerWindowDelegate* delegate,
                            const WindowId& id,
@@ skipping 50 matching lines @@
 
 void ServerWindow::RemoveObserver(ServerWindowObserver* observer) {
   DCHECK(observers_.HasObserver(observer));
   observers_.RemoveObserver(observer);
 }
 
 bool ServerWindow::HasObserver(ServerWindowObserver* observer) {
   return observers_.HasObserver(observer);
 }
 
-void ServerWindow::CreateSurface(
-    mojom::SurfaceType surface_type,
-    mojo::InterfaceRequest<cc::mojom::MojoCompositorFrameSink> request,
+void ServerWindow::CreateCompositorFrameSink(
+    mojom::CompositorFrameSinkType compositor_frame_sink_type,
+    cc::mojom::MojoCompositorFrameSinkRequest request,
     cc::mojom::MojoCompositorFrameSinkClientPtr client) {
-  GetOrCreateSurfaceManager()->CreateSurface(surface_type, std::move(request),
-                                             std::move(client));
+  GetOrCreateCompositorFrameSinkManager()->CreateCompositorFrameSink(
+      compositor_frame_sink_type, std::move(request), std::move(client));
 }
 
 void ServerWindow::Add(ServerWindow* child) {
   // We assume validation checks happened already.
   DCHECK(child);
   DCHECK(child != this);
   DCHECK(!child->Contains(this));
   if (child->parent() == this) {
     if (children_.size() == 1)
       return;  // Already in the right position.
@@ skipping 255 matching lines @@
 bool ServerWindow::IsDrawn() const {
   const ServerWindow* root = delegate_->GetRootWindow(this);
   if (!root || !root->visible())
     return false;
   const ServerWindow* window = this;
   while (window && window != root && window->visible())
     window = window->parent();
   return root == window;
 }
 
-ServerWindowSurfaceManager* ServerWindow::GetOrCreateSurfaceManager() {
-  if (!surface_manager_.get())
-    surface_manager_ = base::MakeUnique<ServerWindowSurfaceManager>(this);
-  return surface_manager_.get();
+ServerWindowCompositorFrameSinkManager*
+ServerWindow::GetOrCreateCompositorFrameSinkManager() {
+  if (!compositor_frame_sink_manager_.get())
+    compositor_frame_sink_manager_ =
+        base::MakeUnique<ServerWindowCompositorFrameSinkManager>(this);
+  return compositor_frame_sink_manager_.get();
 }
 
 void ServerWindow::SetUnderlayOffset(const gfx::Vector2d& offset) {
   if (offset == underlay_offset_)
     return;
 
   underlay_offset_ = offset;
   delegate_->OnScheduleWindowPaint(this);
 }
 
@@ skipping 74 matching lines @@
 }
 
 // static
 ServerWindow** ServerWindow::GetStackingTarget(ServerWindow* window) {
   return &window->stacking_target_;
 }
 
 }  // namespace ws
 
 }  // namespace ui