Renames some WindowManager classes

components/mus/mus_app.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 "components/mus/mus_app.h"
 
 #include "base/stl_util.h"
 #include "build/build_config.h"
 #include "components/mus/common/args.h"
 #include "components/mus/gles2/gpu_impl.h"
@@ skipping 23 matching lines @@
 using mojo::ApplicationConnection;
 using mojo::ApplicationImpl;
 using mojo::InterfaceRequest;
 using mus::mojom::WindowTreeHostFactory;
 using mus::mojom::Gpu;
 
 namespace mus {
 
 struct MandolineUIServicesApp::PendingRequest {
   scoped_ptr<mojo::InterfaceRequest<mojom::DisplayManager>> dm_request;
-  scoped_ptr<mojo::InterfaceRequest<mojom::WindowManager>> wm_request;
+  scoped_ptr<mojo::InterfaceRequest<mojom::WindowManagerDeprecated>> wm_request;
 };
 
 MandolineUIServicesApp::MandolineUIServicesApp()
     : app_impl_(nullptr) {}
 
 MandolineUIServicesApp::~MandolineUIServicesApp() {
   if (gpu_state_)
     gpu_state_->StopThreads();
   // Destroy |connection_manager_| first, since it depends on |event_source_|.
   connection_manager_.reset();
@@ skipping 31 matching lines @@
     gpu_state_ = new GpuState(hardware_rendering_available);
   connection_manager_.reset(new ws::ConnectionManager(this, surfaces_state_));
 
   tracing_.Initialize(app);
 }
 
 bool MandolineUIServicesApp::ConfigureIncomingConnection(
     ApplicationConnection* connection) {
   connection->AddService<Gpu>(this);
   connection->AddService<mojom::DisplayManager>(this);
-  connection->AddService<mojom::WindowManager>(this);
+  connection->AddService<mojom::WindowManagerDeprecated>(this);
   connection->AddService<WindowTreeHostFactory>(this);
   return true;
 }
 
 void MandolineUIServicesApp::OnFirstRootConnectionCreated() {
   PendingRequests requests;
   requests.swap(pending_requests_);
   for (auto& request : requests) {
     if (request->dm_request)
       Create(nullptr, std::move(*request->dm_request));
@@ skipping 28 matching lines @@
     pending_request->dm_request.reset(
         new mojo::InterfaceRequest<mojom::DisplayManager>(std::move(request)));
     pending_requests_.push_back(std::move(pending_request));
     return;
   }
   connection_manager_->AddDisplayManagerBinding(std::move(request));
 }
 
 void MandolineUIServicesApp::Create(
     mojo::ApplicationConnection* connection,
-    mojo::InterfaceRequest<mojom::WindowManager> request) {
+    mojo::InterfaceRequest<mojom::WindowManagerDeprecated> request) {
   if (!connection_manager_->has_tree_host_connections()) {
     scoped_ptr<PendingRequest> pending_request(new PendingRequest);
     pending_request->wm_request.reset(
-        new mojo::InterfaceRequest<mojom::WindowManager>(std::move(request)));
+        new mojo::InterfaceRequest<mojom::WindowManagerDeprecated>(
+            std::move(request)));
     pending_requests_.push_back(std::move(pending_request));
     return;
   }
   if (!window_manager_impl_) {
     window_manager_impl_.reset(
         new ws::ForwardingWindowManager(connection_manager_.get()));
   }
   window_manager_bindings_.AddBinding(window_manager_impl_.get(),
                                       std::move(request));
 }
 
 void MandolineUIServicesApp::Create(
     ApplicationConnection* connection,
     InterfaceRequest<WindowTreeHostFactory> request) {
   factory_bindings_.AddBinding(this, std::move(request));
 }
 
 void MandolineUIServicesApp::Create(mojo::ApplicationConnection* connection,
                                     mojo::InterfaceRequest<Gpu> request) {
   DCHECK(gpu_state_);
   new GpuImpl(std::move(request), gpu_state_);
 }
 
 void MandolineUIServicesApp::CreateWindowTreeHost(
     mojo::InterfaceRequest<mojom::WindowTreeHost> host,
     mojom::WindowTreeHostClientPtr host_client,
     mojom::WindowTreeClientPtr tree_client,
-    mojom::WindowManagerPtr window_manager) {
+    mojom::WindowManagerDeprecatedPtr window_manager) {
   DCHECK(connection_manager_);
 
   // TODO(fsamuel): We need to make sure that only the window manager can create
   // new roots.
   ws::WindowTreeHostImpl* host_impl = new ws::WindowTreeHostImpl(
       std::move(host_client), connection_manager_.get(), app_impl_, gpu_state_,
       surfaces_state_, std::move(window_manager));
 
   // WindowTreeHostConnection manages its own lifetime.
   host_impl->Init(new ws::WindowTreeHostConnectionImpl(
       std::move(host), make_scoped_ptr(host_impl), std::move(tree_client),
       connection_manager_.get()));
 }
 
 }  // namespace mus