Wires up WorkspaceLayoutManager in mash

mash/wm/window_manager_application.cc

 // Copyright 2015 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 "mash/wm/window_manager_application.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "components/mus/common/event_matcher_util.h"
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/interfaces/window_manager_factory.mojom.h"
 #include "mash/wm/accelerator_registrar_impl.h"
+#include "mash/wm/bridge/wm_globals_mus.h"
+#include "mash/wm/bridge/wm_lookup_mus.h"
 #include "mash/wm/root_window_controller.h"
 #include "mash/wm/root_windows_observer.h"
 #include "mash/wm/shelf_layout_impl.h"
 #include "mash/wm/user_window_controller_impl.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "services/shell/public/cpp/connection.h"
 #include "services/shell/public/cpp/connector.h"
 #include "services/tracing/public/cpp/tracing_impl.h"
 #include "ui/events/event.h"
 #include "ui/views/mus/aura_init.h"
@@ skipping 23 matching lines @@
   std::set<RootWindowController*> root_controllers;
   for (RootWindowController* controller : root_controllers_) {
     if (controller->root())
       root_controllers.insert(controller);
   }
   return root_controllers;
 }
 
 void WindowManagerApplication::OnRootWindowControllerGotRoot(
     RootWindowController* root_controller) {
-  aura_init_.reset(new views::AuraInit(connector_, "mash_wm_resources.pak"));
+  if (connector_)
+    aura_init_.reset(new views::AuraInit(connector_, "mash_wm_resources.pak"));
+
+  globals_.reset(new WmGlobalsMus(root_controller->root()->connection()));
+  lookup_.reset(new WmLookupMus);
 }
 
 void WindowManagerApplication::OnRootWindowControllerDoneInit(
     RootWindowController* root_controller) {
-  screen_.reset(new views::ScreenMus(nullptr));
-  screen_->Init(connector_);
+  if (!screen_) {

[James Cook, 2016/05/19 05:08:22]

I'm a little confused here. This if() implies to me that this can be called
multiple times (presumably because there could be multiple root controllers for
multiple displays). But the function above looks like it would also be called
multiple times if there were multiple roots, which would reset globals_
repeatedly. Are they both supposed to tolerate being called multiple times?

Or is this supposed to be "if (connector_)"?

[sky, 2016/05/19 15:14:24]

Good catch. I made OnRootWindowControllerGotRoot early out if globals_ is
non-null.

+    std::unique_ptr<views::ScreenMus> screen(new views::ScreenMus(nullptr));
+    screen->Init(connector_);
+    screen_ = std::move(screen);
+  }
 
   // TODO(msw): figure out if this should be per display, or global.
   user_window_controller_->Initialize(root_controller);
   for (auto& request : user_window_controller_requests_)
     user_window_controller_bindings_.AddBinding(user_window_controller_.get(),
                                                 std::move(*request));
   user_window_controller_requests_.clear();
 
   // TODO(msw): figure out if this should be per display, or global.
   shelf_layout_->Initialize(root_controller);
@@ skipping 29 matching lines @@
 void WindowManagerApplication::RemoveRootWindowsObserver(
     RootWindowsObserver* observer) {
   root_windows_observers_.RemoveObserver(observer);
 }
 
 void WindowManagerApplication::OnAcceleratorRegistrarDestroyed(
     AcceleratorRegistrarImpl* registrar) {
   accelerator_registrars_.erase(registrar);
 }
 
+void WindowManagerApplication::AddRootWindowController(
+    RootWindowController* root_window_controller) {
+  root_controllers_.insert(root_window_controller);
+}
+
 void WindowManagerApplication::Initialize(shell::Connector* connector,
                                           const shell::Identity& identity,
                                           uint32_t id) {
   connector_ = connector;
-  tracing_.Initialize(connector, identity.name());
+  if (connector) {
+    tracing_.Initialize(connector, identity.name());
 
-  mus::mojom::WindowManagerFactoryServicePtr wm_factory_service;
-  connector_->ConnectToInterface("mojo:mus", &wm_factory_service);
-  wm_factory_service->SetWindowManagerFactory(
-      window_manager_factory_binding_.CreateInterfacePtrAndBind());
+    mus::mojom::WindowManagerFactoryServicePtr wm_factory_service;
+    connector_->ConnectToInterface("mojo:mus", &wm_factory_service);
+    wm_factory_service->SetWindowManagerFactory(
+        window_manager_factory_binding_.CreateInterfacePtrAndBind());
+  }
 
   shelf_layout_.reset(new ShelfLayoutImpl);
   user_window_controller_.reset(new UserWindowControllerImpl());
 }
 
 bool WindowManagerApplication::AcceptConnection(shell::Connection* connection) {
   connection->AddInterface<mojom::ShelfLayout>(this);
   connection->AddInterface<mojom::UserWindowController>(this);
   connection->AddInterface<mus::mojom::AcceleratorRegistrar>(this);
   if (connection->GetRemoteIdentity().name() == "mojo:mash_session")
@@ skipping 40 matching lines @@
   }
   accelerator_registrars_.insert(new AcceleratorRegistrarImpl(
       this, ++accelerator_registrar_count, std::move(request),
       base::Bind(&WindowManagerApplication::OnAcceleratorRegistrarDestroyed,
                  base::Unretained(this))));
 }
 
 void WindowManagerApplication::CreateWindowManager(
     mus::mojom::DisplayPtr display,
     mojo::InterfaceRequest<mus::mojom::WindowTreeClient> client_request) {
-  root_controllers_.insert(RootWindowController::CreateFromDisplay(
+  AddRootWindowController(RootWindowController::CreateFromDisplay(
       this, std::move(display), std::move(client_request)));
 }
 
 }  // namespace wm
 }  // namespace mash