Adds WindowManagerManager to mus

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 <set>
 
+#include "base/memory/weak_ptr.h"
 #include "base/stl_util.h"
+#include "base/threading/platform_thread.h"
 #include "build/build_config.h"
-#include "base/threading/platform_thread.h"
 #include "components/mus/common/args.h"
 #include "components/mus/gles2/gpu_impl.h"
 #include "components/mus/ws/client_connection.h"
 #include "components/mus/ws/connection_manager.h"
 #include "components/mus/ws/window_tree_factory.h"
 #include "components/mus/ws/window_tree_host_connection.h"
 #include "components/mus/ws/window_tree_host_impl.h"
 #include "components/mus/ws/window_tree_impl.h"
 #include "components/resource_provider/public/cpp/resource_loader.h"
 #include "mojo/public/c/system/main.h"
@@ skipping 133 matching lines @@
   }
 }
 
 void MandolineUIServicesApp::OnNoMoreRootConnections() {
   base::MessageLoop::current()->QuitWhenIdle();
 }
 
 ws::ClientConnection*
 MandolineUIServicesApp::CreateClientConnectionForEmbedAtWindow(
     ws::ConnectionManager* connection_manager,
-    mojo::InterfaceRequest<mojom::WindowTree> tree_request,
+    mojom::WindowTreeRequest tree_request,
     ws::ServerWindow* root,
     uint32_t policy_bitmask,
     mojom::WindowTreeClientPtr client) {
   scoped_ptr<ws::WindowTreeImpl> service(
       new ws::WindowTreeImpl(connection_manager, root, policy_bitmask));
   return new ws::DefaultClientConnection(std::move(service), connection_manager,
                                          std::move(tree_request),
                                          std::move(client));
 }
 
-void MandolineUIServicesApp::Create(
-    mojo::Connection* connection,
-    mojo::InterfaceRequest<mojom::DisplayManager> request) {
+ws::ClientConnection*
+MandolineUIServicesApp::CreateClientConnectionForWindowManager(
+    ws::WindowTreeHostImpl* tree_host,
+    ws::ServerWindow* window,
+    const mojom::Display& display,
+    uint32_t user_id,
+    mojom::WindowManagerFactory* factory) {
+  // TODO(sky): figure out a better way to factor this. Having the delegate
+  // have to add to the ConnectionManager is ick!
+  mojom::WindowTreeClientPtr tree_client;
+  factory->CreateWindowManager(display.Clone(), GetProxy(&tree_client));
+  scoped_ptr<ws::WindowTreeImpl> service(
+      new ws::WindowTreeImpl(connection_manager_.get(), window,
+                             mojom::WindowTree::kAccessPolicyEmbedRoot));
+  scoped_ptr<ws::DefaultClientConnection> connection(
+      new ws::DefaultClientConnection(std::move(service),
+                                      connection_manager_.get(),
+                                      std::move(tree_client)));
+  mojom::WindowTreePtr tree = connection->CreateInterfacePtrAndBind();
+  ws::DefaultClientConnection* raw_connection = connection.get();
+  connection_manager_->AddConnection(std::move(connection), std::move(tree));
+  return raw_connection;
+}
+
+void MandolineUIServicesApp::CreateDefaultWindowTreeHosts() {
+  // WindowTreeHostImpl manages its own lifetime.
+  ws::WindowTreeHostImpl* host_impl = new ws::WindowTreeHostImpl(
+      connection_manager_.get(), connector_, gpu_state_, surfaces_state_);
+  host_impl->Init(nullptr);
+}
+
+void MandolineUIServicesApp::Create(mojo::Connection* connection,
+                                    mojom::DisplayManagerRequest request) {
   if (!connection_manager_->has_tree_host_connections()) {
     scoped_ptr<PendingRequest> pending_request(new PendingRequest);
     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::Connection* connection,
-    mojo::InterfaceRequest<mojom::WindowManagerFactoryService> request) {
-  connection_manager_->CreateWindowManagerFactoryService(std::move(request));
+    mojom::WindowManagerFactoryServiceRequest request) {
+  connection_manager_->CreateWindowManagerFactoryService(
+      connection->GetRemoteUserID(), std::move(request));
 }
 
-void MandolineUIServicesApp::Create(
-    Connection* connection,
-    InterfaceRequest<mojom::WindowTreeFactory> request) {
+void MandolineUIServicesApp::Create(Connection* connection,
+                                    mojom::WindowTreeFactoryRequest request) {
   if (!connection_manager_->has_tree_host_connections()) {
     scoped_ptr<PendingRequest> pending_request(new PendingRequest);
     pending_request->wtf_request.reset(
         new mojo::InterfaceRequest<mojom::WindowTreeFactory>(
             std::move(request)));
     pending_requests_.push_back(std::move(pending_request));
     return;
   }
   if (!window_tree_factory_) {
     window_tree_factory_.reset(
         new ws::WindowTreeFactory(connection_manager_.get()));
   }
   window_tree_factory_->AddBinding(std::move(request));
 }
 
 void MandolineUIServicesApp::Create(
     Connection* connection,
-    InterfaceRequest<WindowTreeHostFactory> request) {
+    mojom::WindowTreeHostFactoryRequest request) {
   factory_bindings_.AddBinding(this, std::move(request));
 }
 
 void MandolineUIServicesApp::Create(mojo::Connection* connection,
-                                    mojo::InterfaceRequest<Gpu> request) {
+                                    mojom::GpuRequest request) {
   DCHECK(gpu_state_);
   new GpuImpl(std::move(request), gpu_state_);
 }
 
 void MandolineUIServicesApp::CreateWindowTreeHost(
-    mojo::InterfaceRequest<mojom::WindowTreeHost> host,
+    mojom::WindowTreeHostRequest host,
     mojom::WindowTreeClientPtr tree_client) {
   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(
       connection_manager_.get(), connector_, gpu_state_, surfaces_state_);
 
   scoped_ptr<ws::WindowTreeHostConnectionImpl> host_connection(
       new ws::WindowTreeHostConnectionImpl(std::move(host), host_impl,
                                            std::move(tree_client),
                                            connection_manager_.get()));
   host_impl->Init(std::move(host_connection));
 }
 
 }  // namespace mus