Moves mash/wm into ash/mus

ash/mus/bridge/wm_window_mus.h

Index: ash/mus/bridge/wm_window_mus.h
diff --git a/mash/wm/bridge/wm_window_mus.h b/ash/mus/bridge/wm_window_mus.h
similarity index 70%
rename from mash/wm/bridge/wm_window_mus.h
rename to ash/mus/bridge/wm_window_mus.h
index 4e57232036fa868e4c2c90fa117de23d1a6cc9e2..d9ced0ca4619b2f9b8af31e32b7d97ce59fc103b 100644
--- a/mash/wm/bridge/wm_window_mus.h
+++ b/ash/mus/bridge/wm_window_mus.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef MASH_WM_BRIDGE_WM_WINDOW_MUS_H_
-#define MASH_WM_BRIDGE_WM_WINDOW_MUS_H_
+#ifndef ASH_MUS_BRIDGE_WM_WINDOW_MUS_H_
+#define ASH_MUS_BRIDGE_WM_WINDOW_MUS_H_
 
 #include <memory>
 
@@ -12,27 +12,26 @@
 #include "base/observer_list.h"
 #include "components/mus/public/cpp/window_observer.h"
 
-namespace ash {
-namespace wm {
-class WmLayoutManager;
-}
-}
-
 namespace views {
 class Widget;
 }
 
-namespace mash {
+namespace ash {
+
 namespace wm {
+class WmLayoutManager;
+}
+
+namespace mus {
 
 class MusLayoutManagerAdapter;
 class WmRootWindowControllerMus;
 
 // WmWindow implementation for mus.
 //
-// WmWindowMus is tied to the life of the underlying mus::Window (it is stored
+// WmWindowMus is tied to the life of the underlying ::mus::Window (it is stored
 // as an owned property).
-class WmWindowMus : public ash::wm::WmWindow, public mus::WindowObserver {
+class WmWindowMus : public wm::WmWindow, public ::mus::WindowObserver {
  public:
   // Indicates the source of the widget creation.
   enum class WidgetCreationType {
@@ -51,24 +50,24 @@ class WmWindowMus : public ash::wm::WmWindow, public mus::WindowObserver {
     FOR_CLIENT,
   };
 
-  explicit WmWindowMus(mus::Window* window);
+  explicit WmWindowMus(::mus::Window* window);
   // NOTE: this class is owned by the corresponding window. You shouldn't delete
   // TODO(sky): friend deleter and make private.
   ~WmWindowMus() override;
 
   // Returns a WmWindow for an mus::Window, creating if necessary.
-  static WmWindowMus* Get(mus::Window* window);
+  static WmWindowMus* Get(::mus::Window* window);
 
   static WmWindowMus* Get(views::Widget* widget);
 
-  static mus::Window* GetMusWindow(ash::wm::WmWindow* wm_window) {
-    return const_cast<mus::Window*>(
-        GetMusWindow(const_cast<const ash::wm::WmWindow*>(wm_window)));
+  static ::mus::Window* GetMusWindow(wm::WmWindow* wm_window) {
+    return const_cast<::mus::Window*>(
+        GetMusWindow(const_cast<const wm::WmWindow*>(wm_window)));
   }
-  static const mus::Window* GetMusWindow(const ash::wm::WmWindow* wm_window);
+  static const ::mus::Window* GetMusWindow(const wm::WmWindow* wm_window);
 
   static std::vector<WmWindow*> FromMusWindows(
-      const std::vector<mus::Window*>& mus_windows);
+      const std::vector<::mus::Window*>& mus_windows);
 
   // Sets the widget associated with the window. The widget is used to query
   // state, such as min/max size. The widget is not owned by the WmWindowMus.
@@ -77,8 +76,8 @@ class WmWindowMus : public ash::wm::WmWindow, public mus::WindowObserver {
     widget_creation_type_ = type;
   }
 
-  mus::Window* mus_window() { return window_; }
-  const mus::Window* mus_window() const { return window_; }
+  ::mus::Window* mus_window() { return window_; }
+  const ::mus::Window* mus_window() const { return window_; }
 
   WmRootWindowControllerMus* GetRootWindowControllerMus() {
     return const_cast<WmRootWindowControllerMus*>(
@@ -86,35 +85,33 @@ class WmWindowMus : public ash::wm::WmWindow, public mus::WindowObserver {
   }
   const WmRootWindowControllerMus* GetRootWindowControllerMus() const;
 
-  static WmWindowMus* AsWmWindowMus(ash::wm::WmWindow* window) {
+  static WmWindowMus* AsWmWindowMus(wm::WmWindow* window) {
     return static_cast<WmWindowMus*>(window);
   }
-  static const WmWindowMus* AsWmWindowMus(const ash::wm::WmWindow* window) {
+  static const WmWindowMus* AsWmWindowMus(const wm::WmWindow* window) {
     return static_cast<const WmWindowMus*>(window);
   }
 
-  ash::wm::WindowState* GetWindowState() {
-    return ash::wm::WmWindow::GetWindowState();
-  }
+  wm::WindowState* GetWindowState() { return wm::WmWindow::GetWindowState(); }
 
   // See description of |children_use_extended_hit_region_|.
   bool ShouldUseExtendedHitRegion() const;
 
   // WmWindow:
-  const ash::wm::WmWindow* GetRootWindow() const override;
-  ash::wm::WmRootWindowController* GetRootWindowController() override;
-  ash::wm::WmGlobals* GetGlobals() const override;
+  const wm::WmWindow* GetRootWindow() const override;
+  wm::WmRootWindowController* GetRootWindowController() override;
+  wm::WmGlobals* GetGlobals() const override;
   void SetName(const char* name) override;
   base::string16 GetTitle() const override;
   void SetShellWindowId(int id) override;
   int GetShellWindowId() const override;
-  ash::wm::WmWindow* GetChildByShellWindowId(int id) override;
+  wm::WmWindow* GetChildByShellWindowId(int id) override;
   ui::wm::WindowType GetType() const override;
   ui::Layer* GetLayer() override;
   display::Display GetDisplayNearestWindow() override;
   bool HasNonClientArea() override;
   int GetNonClientComponent(const gfx::Point& location) override;
-  gfx::Point ConvertPointToTarget(const ash::wm::WmWindow* target,
+  gfx::Point ConvertPointToTarget(const wm::WmWindow* target,
                                   const gfx::Point& point) const override;
   gfx::Point ConvertPointToScreen(const gfx::Point& point) const override;
   gfx::Point ConvertPointFromScreen(const gfx::Point& point) const override;
@@ -129,19 +126,19 @@ class WmWindowMus : public ash::wm::WmWindow, public mus::WindowObserver {
   void SetTransform(const gfx::Transform& transform) override;
   gfx::Transform GetTargetTransform() const override;
   bool IsSystemModal() const override;
-  bool GetBoolProperty(ash::wm::WmWindowProperty key) override;
-  int GetIntProperty(ash::wm::WmWindowProperty key) override;
-  const ash::wm::WindowState* GetWindowState() const override;
-  ash::wm::WmWindow* GetToplevelWindow() override;
-  void SetParentUsingContext(ash::wm::WmWindow* context,
+  bool GetBoolProperty(wm::WmWindowProperty key) override;
+  int GetIntProperty(wm::WmWindowProperty key) override;
+  const wm::WindowState* GetWindowState() const override;
+  wm::WmWindow* GetToplevelWindow() override;
+  void SetParentUsingContext(wm::WmWindow* context,
                              const gfx::Rect& screen_bounds) override;
-  void AddChild(ash::wm::WmWindow* window) override;
-  ash::wm::WmWindow* GetParent() override;
-  const ash::wm::WmWindow* GetTransientParent() const override;
-  std::vector<ash::wm::WmWindow*> GetTransientChildren() override;
+  void AddChild(wm::WmWindow* window) override;
+  wm::WmWindow* GetParent() override;
+  const wm::WmWindow* GetTransientParent() const override;
+  std::vector<wm::WmWindow*> GetTransientChildren() override;
   void SetLayoutManager(
-      std::unique_ptr<ash::wm::WmLayoutManager> layout_manager) override;
-  ash::wm::WmLayoutManager* GetLayoutManager() override;
+      std::unique_ptr<wm::WmLayoutManager> layout_manager) override;
+  wm::WmLayoutManager* GetLayoutManager() override;
   void SetVisibilityAnimationType(int type) override;
   void SetVisibilityAnimationDuration(base::TimeDelta delta) override;
   void SetVisibilityAnimationTransition(
@@ -165,7 +162,7 @@ class WmWindowMus : public ash::wm::WmWindow, public mus::WindowObserver {
   void ClearRestoreBounds() override;
   void SetRestoreBoundsInScreen(const gfx::Rect& bounds) override;
   gfx::Rect GetRestoreBoundsInScreen() const override;
-  bool Contains(const ash::wm::WmWindow* other) const override;
+  bool Contains(const wm::WmWindow* other) const override;
   void SetShowState(ui::WindowShowState show_state) override;
   ui::WindowShowState GetShowState() const override;
   void SetRestoreShowState(ui::WindowShowState show_state) override;
@@ -191,13 +188,11 @@ class WmWindowMus : public ash::wm::WmWindow, public mus::WindowObserver {
   bool CanMinimize() const override;
   bool CanResize() const override;
   bool CanActivate() const override;
-  void StackChildAtTop(ash::wm::WmWindow* child) override;
-  void StackChildAtBottom(ash::wm::WmWindow* child) override;
-  void StackChildAbove(ash::wm::WmWindow* child,
-                       ash::wm::WmWindow* target) override;
-  void StackChildBelow(ash::wm::WmWindow* child,
-                       ash::wm::WmWindow* target) override;
-  std::vector<ash::wm::WmWindow*> GetChildren() override;
+  void StackChildAtTop(wm::WmWindow* child) override;
+  void StackChildAtBottom(wm::WmWindow* child) override;
+  void StackChildAbove(wm::WmWindow* child, wm::WmWindow* target) override;
+  void StackChildBelow(wm::WmWindow* child, wm::WmWindow* target) override;
+  std::vector<wm::WmWindow*> GetChildren() override;
   void ShowResizeShadow(int component) override;
   void HideResizeShadow() override;
   void SetBoundsInScreenBehaviorForChildren(
@@ -206,38 +201,38 @@ class WmWindowMus : public ash::wm::WmWindow, public mus::WindowObserver {
   void SnapToPixelBoundaryIfNecessary() override;
   void SetChildrenUseExtendedHitRegion() override;
   void SetDescendantsStayInSameRootWindow(bool value) override;
-  void AddObserver(ash::wm::WmWindowObserver* observer) override;
-  void RemoveObserver(ash::wm::WmWindowObserver* observer) override;
+  void AddObserver(wm::WmWindowObserver* observer) override;
+  void RemoveObserver(wm::WmWindowObserver* observer) override;
 
  private:
   // mus::WindowObserver:
   void OnTreeChanged(const TreeChangeParams& params) override;
-  void OnWindowReordered(mus::Window* window,
-                         mus::Window* relative_window,
-                         mus::mojom::OrderDirection direction) override;
+  void OnWindowReordered(::mus::Window* window,
+                         ::mus::Window* relative_window,
+                         ::mus::mojom::OrderDirection direction) override;
   void OnWindowSharedPropertyChanged(
-      mus::Window* window,
+      ::mus::Window* window,
       const std::string& name,
       const std::vector<uint8_t>* old_data,
       const std::vector<uint8_t>* new_data) override;
-  void OnWindowBoundsChanged(mus::Window* window,
+  void OnWindowBoundsChanged(::mus::Window* window,
                              const gfx::Rect& old_bounds,
                              const gfx::Rect& new_bounds) override;
-  void OnWindowDestroying(mus::Window* window) override;
+  void OnWindowDestroying(::mus::Window* window) override;
 
-  mus::Window* window_;
+  ::mus::Window* window_;
 
   // The shell window id of this window. Shell window ids are defined in
   // ash/common/shell_window_ids.h.
   int shell_window_id_ = -1;
 
-  std::unique_ptr<ash::wm::WindowState> window_state_;
+  std::unique_ptr<wm::WindowState> window_state_;
 
   views::Widget* widget_ = nullptr;
 
   WidgetCreationType widget_creation_type_ = WidgetCreationType::INTERNAL;
 
-  base::ObserverList<ash::wm::WmWindowObserver> observers_;
+  base::ObserverList<wm::WmWindowObserver> observers_;
 
   std::unique_ptr<MusLayoutManagerAdapter> layout_manager_adapter_;
 
@@ -254,7 +249,7 @@ class WmWindowMus : public ash::wm::WmWindow, public mus::WindowObserver {
   DISALLOW_COPY_AND_ASSIGN(WmWindowMus);
 };
 
-}  // namespace wm
-}  // namespace mash
+}  // namespace mus
+}  // namespace ash
 
-#endif  // MASH_WM_BRIDGE_WM_WINDOW_MUS_H_
+#endif  // ASH_MUS_BRIDGE_WM_WINDOW_MUS_H_