Moves mash/wm into ash/mus

ash/mus/root_window_controller.cc

Index: ash/mus/root_window_controller.cc
diff --git a/mash/wm/root_window_controller.cc b/ash/mus/root_window_controller.cc
similarity index 80%
rename from mash/wm/root_window_controller.cc
rename to ash/mus/root_window_controller.cc
index 5a1e8c7ab64ed31ac934aede351dbc3fb071f7cc..005efb07ce9cc3eba0d4c4022f1bfdb50f9f2340 100644
--- a/mash/wm/root_window_controller.cc
+++ b/ash/mus/root_window_controller.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "mash/wm/root_window_controller.h"
+#include "ash/mus/root_window_controller.h"
 
 #include <stdint.h>
 
@@ -15,6 +15,19 @@
 #include "ash/common/wm/panels/panel_layout_manager.h"
 #include "ash/common/wm/workspace/workspace_layout_manager.h"
 #include "ash/common/wm/workspace/workspace_layout_manager_delegate.h"
+#include "ash/mus/background_layout.h"
+#include "ash/mus/bridge/wm_globals_mus.h"
+#include "ash/mus/bridge/wm_root_window_controller_mus.h"
+#include "ash/mus/bridge/wm_shelf_mus.h"
+#include "ash/mus/bridge/wm_window_mus.h"
+#include "ash/mus/container_ids.h"
+#include "ash/mus/fill_layout.h"
+#include "ash/mus/screenlock_layout.h"
+#include "ash/mus/shadow_controller.h"
+#include "ash/mus/shelf_layout_manager.h"
+#include "ash/mus/status_layout_manager.h"
+#include "ash/mus/window_manager.h"
+#include "ash/mus/window_manager_application.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
@@ -27,27 +40,14 @@
 #include "components/mus/public/cpp/window_tree_host_factory.h"
 #include "components/mus/public/interfaces/window_manager.mojom.h"
 #include "mash/session/public/interfaces/session.mojom.h"
-#include "mash/wm/background_layout.h"
-#include "mash/wm/bridge/wm_globals_mus.h"
-#include "mash/wm/bridge/wm_root_window_controller_mus.h"
-#include "mash/wm/bridge/wm_shelf_mus.h"
-#include "mash/wm/bridge/wm_window_mus.h"
-#include "mash/wm/container_ids.h"
-#include "mash/wm/fill_layout.h"
-#include "mash/wm/screenlock_layout.h"
-#include "mash/wm/shadow_controller.h"
-#include "mash/wm/shelf_layout_manager.h"
-#include "mash/wm/status_layout_manager.h"
-#include "mash/wm/window_manager.h"
-#include "mash/wm/window_manager_application.h"
 #include "mojo/public/cpp/bindings/type_converter.h"
 #include "services/shell/public/cpp/connector.h"
 #include "ui/display/mojo/display_type_converters.h"
 
 using ash::mojom::Container;
 
-namespace mash {
-namespace wm {
+namespace ash {
+namespace mus {
 namespace {
 
 const uint32_t kWindowSwitchAccelerator = 1;
@@ -61,7 +61,7 @@ int ContainerToLocalId(Container container) {
 }
 
 class WorkspaceLayoutManagerDelegateImpl
-    : public ash::wm::WorkspaceLayoutManagerDelegate {
+    : public wm::WorkspaceLayoutManagerDelegate {
  public:
   explicit WorkspaceLayoutManagerDelegateImpl(
       WmRootWindowControllerMus* root_window_controller)
@@ -88,12 +88,12 @@ class WorkspaceLayoutManagerDelegateImpl
 // static
 RootWindowController* RootWindowController::CreateFromDisplay(
     WindowManagerApplication* app,
-    mus::mojom::DisplayPtr display,
-    mus::mojom::WindowTreeClientRequest client_request) {
+    ::mus::mojom::DisplayPtr display,
+    ::mus::mojom::WindowTreeClientRequest client_request) {
   RootWindowController* controller = new RootWindowController(app);
   controller->display_ = display.To<display::Display>();
-  new mus::WindowTreeClient(controller, controller->window_manager_.get(),
-                            std::move(client_request));
+  new ::mus::WindowTreeClient(controller, controller->window_manager_.get(),
+                              std::move(client_request));
   return controller;
 }
 
@@ -111,16 +111,18 @@ shell::Connector* RootWindowController::GetConnector() {
   return app_->connector();
 }
 
-mus::Window* RootWindowController::GetWindowForContainer(Container container) {
+::mus::Window* RootWindowController::GetWindowForContainer(
+    Container container) {
   return root_->GetChildByLocalId(ContainerToLocalId(container));
 }
 
-bool RootWindowController::WindowIsContainer(const mus::Window* window) const {
+bool RootWindowController::WindowIsContainer(
+    const ::mus::Window* window) const {
   return window && window->local_id() > ContainerToLocalId(Container::ROOT) &&
          window->local_id() < ContainerToLocalId(Container::COUNT);
 }
 
-mus::WindowManagerClient* RootWindowController::window_manager_client() {
+::mus::WindowManagerClient* RootWindowController::window_manager_client() {
   return window_manager_->window_manager_client();
 }
 
@@ -156,12 +158,12 @@ RootWindowController::~RootWindowController() {}
 void RootWindowController::AddAccelerators() {
   window_manager_client()->AddAccelerator(
       kWindowSwitchAccelerator,
-      mus::CreateKeyMatcher(mus::mojom::KeyboardCode::TAB,
-                            mus::mojom::kEventFlagControlDown),
+      ::mus::CreateKeyMatcher(::mus::mojom::KeyboardCode::TAB,
+                              ::mus::mojom::kEventFlagControlDown),
       base::Bind(&AssertTrue));
 }
 
-void RootWindowController::OnEmbed(mus::Window* root) {
+void RootWindowController::OnEmbed(::mus::Window* root) {
   root_ = root;
   root_->set_local_id(ContainerToLocalId(Container::ROOT));
   root_->AddObserver(this);
@@ -179,11 +181,11 @@ void RootWindowController::OnEmbed(mus::Window* root) {
         GetWindowForContainer(kActivationContainers[i]));
   }
 
-  ash::wm::WmWindow* always_on_top_container =
-      wm::WmWindowMus::Get(root)->GetChildByShellWindowId(
-          ash::kShellWindowId_AlwaysOnTopContainer);
+  wm::WmWindow* always_on_top_container =
+      WmWindowMus::Get(root)->GetChildByShellWindowId(
+          kShellWindowId_AlwaysOnTopContainer);
   always_on_top_controller_.reset(
-      new ash::AlwaysOnTopController(always_on_top_container));
+      new AlwaysOnTopController(always_on_top_container));
 
   AddAccelerators();
 
@@ -195,17 +197,17 @@ void RootWindowController::OnEmbed(mus::Window* root) {
 }
 
 void RootWindowController::OnWindowTreeClientDestroyed(
-    mus::WindowTreeClient* client) {
+    ::mus::WindowTreeClient* client) {
   shadow_controller_.reset();
   delete this;
 }
 
 void RootWindowController::OnEventObserved(const ui::Event& event,
-                                           mus::Window* target) {
+                                           ::mus::Window* target) {
   // Does not use EventObservers.
 }
 
-void RootWindowController::OnWindowDestroyed(mus::Window* window) {
+void RootWindowController::OnWindowDestroyed(::mus::Window* window) {
   DCHECK_EQ(window, root_);
   app_->OnRootWindowDestroyed(this);
   root_->RemoveObserver(this);
@@ -216,11 +218,10 @@ void RootWindowController::OnWindowDestroyed(mus::Window* window) {
 }
 
 void RootWindowController::OnShelfWindowAvailable() {
-  ash::DockedWindowLayoutManager::Get(WmWindowMus::Get(root_))
+  DockedWindowLayoutManager::Get(WmWindowMus::Get(root_))
       ->SetShelf(wm_shelf_.get());
 
-  ash::PanelLayoutManager::Get(WmWindowMus::Get(root_))
-      ->SetShelf(wm_shelf_.get());
+  PanelLayoutManager::Get(WmWindowMus::Get(root_))->SetShelf(wm_shelf_.get());
 
   // TODO: http://crbug.com/614182 Ash's ShelfLayoutManager implements
   // DockedWindowLayoutManagerObserver so that it can inset by the docked
@@ -235,10 +236,10 @@ void RootWindowController::CreateContainer(Container container,
   std::map<std::string, std::vector<uint8_t>> properties;
   std::ostringstream container_name;
   container_name << container;
-  properties[mus::mojom::WindowManager::kName_Property] =
+  properties[::mus::mojom::WindowManager::kName_Property] =
       mojo::ConvertTo<std::vector<uint8_t>>(container_name.str());
 
-  mus::Window* window = root_->window_tree()->NewWindow(&properties);
+  ::mus::Window* window = root_->window_tree()->NewWindow(&properties);
   window->set_local_id(ContainerToLocalId(container));
   layout_managers_[window].reset(new FillLayout(window));
   WmWindowMus::Get(window)->SetShellWindowId(
@@ -248,10 +249,10 @@ void RootWindowController::CreateContainer(Container container,
   // the lock state, so their contents are never accidentally revealed. Tests,
   // however, usually assume the screen is unlocked.
   const bool is_test = base::CommandLine::ForCurrentProcess()->HasSwitch(
-      mus::switches::kUseTestConfig);
+      ::mus::switches::kUseTestConfig);
   window->SetVisible(container != Container::USER_PRIVATE || is_test);
 
-  mus::Window* parent =
+  ::mus::Window* parent =
       root_->GetChildByLocalId(ContainerToLocalId(parent_container));
   parent->AddChild(window);
 }
@@ -285,15 +286,15 @@ void RootWindowController::CreateContainers() {
   CreateContainer(Container::DRAG_AND_TOOLTIPS, Container::ROOT);
 
   // Override the default layout managers for certain containers.
-  mus::Window* user_background =
+  ::mus::Window* user_background =
       GetWindowForContainer(Container::USER_BACKGROUND);
   layout_managers_[user_background].reset(
       new BackgroundLayout(user_background));
 
-  mus::Window* login_app = GetWindowForContainer(Container::LOGIN_APP);
+  ::mus::Window* login_app = GetWindowForContainer(Container::LOGIN_APP);
   layout_managers_[login_app].reset(new ScreenlockLayout(login_app));
 
-  mus::Window* user_shelf =
+  ::mus::Window* user_shelf =
       GetWindowForContainer(Container::USER_PRIVATE_SHELF);
   ShelfLayoutManager* shelf_layout_manager =
       new ShelfLayoutManager(user_shelf, this);
@@ -301,13 +302,13 @@ void RootWindowController::CreateContainers() {
 
   wm_shelf_.reset(new WmShelfMus(shelf_layout_manager));
 
-  mus::Window* status = GetWindowForContainer(Container::STATUS);
+  ::mus::Window* status = GetWindowForContainer(Container::STATUS);
   layout_managers_[status].reset(new StatusLayoutManager(status));
 
-  mus::Window* user_private_windows =
+  ::mus::Window* user_private_windows =
       GetWindowForContainer(Container::USER_PRIVATE_WINDOWS);
   // WorkspaceLayoutManager is not a mash::wm::LayoutManager (it's an

[msw, 2016/06/02 20:28:34]

nit: s/an/a/

[sky, 2016/06/02 21:31:51]

Done.

-  // ash::wm::LayoutManager), so it can't be in |layout_managers_|.
+  // wm::LayoutManager), so it can't be in |layout_managers_|.
   layout_managers_.erase(user_private_windows);
   std::unique_ptr<WorkspaceLayoutManagerDelegateImpl>
       workspace_layout_manager_delegate(new WorkspaceLayoutManagerDelegateImpl(
@@ -316,11 +317,11 @@ void RootWindowController::CreateContainers() {
   user_private_windows_wm->SetSnapsChildrenToPhysicalPixelBoundary();
   user_private_windows_wm->SetChildrenUseExtendedHitRegion();
   user_private_windows_wm->SetLayoutManager(
-      base::WrapUnique(new ash::WorkspaceLayoutManager(
+      base::WrapUnique(new WorkspaceLayoutManager(
           user_private_windows_wm,
           std::move(workspace_layout_manager_delegate))));
 
-  mus::Window* user_private_docked_windows =
+  ::mus::Window* user_private_docked_windows =
       GetWindowForContainer(Container::USER_PRIVATE_DOCKED_WINDOWS);
   WmWindowMus* user_private_docked_windows_wm =
       WmWindowMus::Get(user_private_docked_windows);
@@ -328,18 +329,18 @@ void RootWindowController::CreateContainers() {
   layout_managers_.erase(user_private_docked_windows);
   user_private_docked_windows_wm->SetChildrenUseExtendedHitRegion();
   user_private_docked_windows_wm->SetLayoutManager(base::WrapUnique(
-      new ash::DockedWindowLayoutManager(user_private_docked_windows_wm)));
+      new DockedWindowLayoutManager(user_private_docked_windows_wm)));
 
-  mus::Window* user_private_panels =
+  ::mus::Window* user_private_panels =
       GetWindowForContainer(Container::USER_PRIVATE_PANELS);
   WmWindowMus* user_private_panels_wm = WmWindowMus::Get(user_private_panels);
   user_private_panels_wm->SetSnapsChildrenToPhysicalPixelBoundary();
   layout_managers_.erase(user_private_panels);
   user_private_panels_wm->SetChildrenUseExtendedHitRegion();
   user_private_panels_wm->SetLayoutManager(
-      base::WrapUnique(new ash::PanelLayoutManager(user_private_panels_wm)));
+      base::WrapUnique(new PanelLayoutManager(user_private_panels_wm)));
 
-  mus::Window* user_private_always_on_top =
+  ::mus::Window* user_private_always_on_top =
       GetWindowForContainer(Container::USER_PRIVATE_ALWAYS_ON_TOP_WINDOWS);
   WmWindowMus* user_private_always_on_top_wm =
       WmWindowMus::Get(user_private_always_on_top);
@@ -347,5 +348,5 @@ void RootWindowController::CreateContainers() {
   user_private_always_on_top_wm->SetSnapsChildrenToPhysicalPixelBoundary();
 }
 
-}  // namespace wm
-}  // namespace mash
+}  // namespace mus
+}  // namespace ash