Shuffles and renames ash/common/wm classes

ash/mus/bridge/wm_window_mus.cc

 // Copyright 2016 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 "ash/mus/bridge/wm_window_mus.h"
 
 #include "ash/common/wm/container_finder.h"
 #include "ash/common/wm/window_state.h"
-#include "ash/common/wm/wm_layout_manager.h"
-#include "ash/common/wm/wm_window_observer.h"
-#include "ash/common/wm/wm_window_property.h"
+#include "ash/common/wm_layout_manager.h"
+#include "ash/common/wm_window_observer.h"
+#include "ash/common/wm_window_property.h"
 #include "ash/mus/bridge/mus_layout_manager_adapter.h"
-#include "ash/mus/bridge/wm_globals_mus.h"
 #include "ash/mus/bridge/wm_root_window_controller_mus.h"
+#include "ash/mus/bridge/wm_shell_mus.h"
 #include "ash/mus/property_util.h"
 #include "components/mus/public/cpp/property_type_converters.h"
 #include "components/mus/public/cpp/window.h"
 #include "components/mus/public/cpp/window_property.h"
 #include "components/mus/public/cpp/window_tree_client.h"
 #include "components/mus/public/interfaces/window_manager.mojom.h"
 #include "ui/aura/mus/mus_util.h"
 #include "ui/base/hit_test.h"
 #include "ui/display/display.h"
 #include "ui/views/widget/widget.h"
@@ skipping 16 matching lines @@
 namespace ash {
 namespace mus {
 
 namespace {
 
 // This classes is used so that the WindowState constructor can be made
 // protected. GetWindowState() is the only place that should be creating
 // WindowState.
 class WindowStateMus : public wm::WindowState {
  public:
-  explicit WindowStateMus(wm::WmWindow* window) : wm::WindowState(window) {}
+  explicit WindowStateMus(WmWindow* window) : wm::WindowState(window) {}
   ~WindowStateMus() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WindowStateMus);
 };
 
 ui::WindowShowState UIWindowShowStateFromMojom(::mus::mojom::ShowState state) {
   switch (state) {
     case ::mus::mojom::ShowState::DEFAULT:
       return ui::SHOW_STATE_DEFAULT;
@@ skipping 35 matching lines @@
       break;
   }
   return ::mus::mojom::ShowState::DEFAULT;
 }
 
 }  // namespace
 
 WmWindowMus::WmWindowMus(::mus::Window* window)
     : window_(window),
       // Matches aura, see aura::Window for details.
-      observers_(
-          base::ObserverList<wm::WmWindowObserver>::NOTIFY_EXISTING_ONLY) {
+      observers_(base::ObserverList<WmWindowObserver>::NOTIFY_EXISTING_ONLY) {
   window_->AddObserver(this);
   window_->SetLocalProperty(kWmWindowKey, this);
   window_state_.reset(new WindowStateMus(this));
 }
 
 WmWindowMus::~WmWindowMus() {
   window_->RemoveObserver(this);
 }
 
 // static
 WmWindowMus* WmWindowMus::Get(::mus::Window* window) {
   if (!window)
     return nullptr;
 
   WmWindowMus* wm_window = window->GetLocalProperty(kWmWindowKey);
   if (wm_window)
     return wm_window;
   // WmWindowMus is owned by the mus::Window.
   return new WmWindowMus(window);
 }
 
 // static
 WmWindowMus* WmWindowMus::Get(views::Widget* widget) {
   return WmWindowMus::Get(aura::GetMusWindow(widget->GetNativeView()));
 }
 
 // static
-const ::mus::Window* WmWindowMus::GetMusWindow(const wm::WmWindow* wm_window) {
+const ::mus::Window* WmWindowMus::GetMusWindow(const WmWindow* wm_window) {
   return static_cast<const WmWindowMus*>(wm_window)->mus_window();
 }
 
 // static
-std::vector<wm::WmWindow*> WmWindowMus::FromMusWindows(
+std::vector<WmWindow*> WmWindowMus::FromMusWindows(
     const std::vector<::mus::Window*>& mus_windows) {
-  std::vector<wm::WmWindow*> result(mus_windows.size());
+  std::vector<WmWindow*> result(mus_windows.size());
   for (size_t i = 0; i < mus_windows.size(); ++i)
     result[i] = Get(mus_windows[i]);
   return result;
 }
 
 const WmRootWindowControllerMus* WmWindowMus::GetRootWindowControllerMus()
     const {
   return WmRootWindowControllerMus::Get(window_->GetRoot());
 }
 
 bool WmWindowMus::ShouldUseExtendedHitRegion() const {
   const WmWindowMus* parent = Get(window_->parent());
   return parent && parent->children_use_extended_hit_region_;
 }
 
-const wm::WmWindow* WmWindowMus::GetRootWindow() const {
+const WmWindow* WmWindowMus::GetRootWindow() const {
   return Get(window_->GetRoot());
 }
 
-wm::WmRootWindowController* WmWindowMus::GetRootWindowController() {
+WmRootWindowController* WmWindowMus::GetRootWindowController() {
   return GetRootWindowControllerMus();
 }
 
-wm::WmGlobals* WmWindowMus::GetGlobals() const {
-  return WmGlobalsMus::Get();
+WmShell* WmWindowMus::GetShell() const {
+  return WmShellMus::Get();
 }
 
 void WmWindowMus::SetName(const char* name) {
   if (name) {
     window_->SetSharedProperty<std::string>(
         ::mus::mojom::WindowManager::kName_Property, std::string(name));
   } else {
     window_->ClearSharedProperty(::mus::mojom::WindowManager::kName_Property);
   }
 }
@@ skipping 110 matching lines @@
 gfx::Transform WmWindowMus::GetTargetTransform() const {
   // TODO: need animation support: http://crbug.com/615087.
   return gfx::Transform();
 }
 
 bool WmWindowMus::IsSystemModal() const {
   NOTIMPLEMENTED();
   return false;
 }
 
-bool WmWindowMus::GetBoolProperty(wm::WmWindowProperty key) {
+bool WmWindowMus::GetBoolProperty(WmWindowProperty key) {
   switch (key) {
-    case wm::WmWindowProperty::SNAP_CHILDREN_TO_PIXEL_BOUNDARY:
+    case WmWindowProperty::SNAP_CHILDREN_TO_PIXEL_BOUNDARY:
       return snap_children_to_pixel_boundary_;
 
-    case wm::WmWindowProperty::ALWAYS_ON_TOP:
+    case WmWindowProperty::ALWAYS_ON_TOP:
       return IsAlwaysOnTop();
 
     default:
       NOTREACHED();
       break;
   }
 
   NOTREACHED();
   return false;
 }
 
-int WmWindowMus::GetIntProperty(wm::WmWindowProperty key) {
-  if (key == wm::WmWindowProperty::SHELF_ID) {
+int WmWindowMus::GetIntProperty(WmWindowProperty key) {
+  if (key == WmWindowProperty::SHELF_ID) {
     NOTIMPLEMENTED();
     return 0;
   }
 
-  if (key == wm::WmWindowProperty::TOP_VIEW_INSET) {
+  if (key == WmWindowProperty::TOP_VIEW_INSET) {
     // TODO: need support for TOP_VIEW_INSET: http://crbug.com/615100.
     NOTIMPLEMENTED();
     return 0;
   }
 
   NOTREACHED();
   return 0;
 }
 
 const wm::WindowState* WmWindowMus::GetWindowState() const {
   return window_state_.get();
 }
 
-wm::WmWindow* WmWindowMus::GetToplevelWindow() {
-  return WmGlobalsMus::GetToplevelAncestor(window_);
+WmWindow* WmWindowMus::GetToplevelWindow() {
+  return WmShellMus::GetToplevelAncestor(window_);
 }
 
 void WmWindowMus::SetParentUsingContext(WmWindow* context,
                                         const gfx::Rect& screen_bounds) {
-  GetDefaultParent(context, this, screen_bounds)->AddChild(this);
+  wm::GetDefaultParent(context, this, screen_bounds)->AddChild(this);
 }
 
 void WmWindowMus::AddChild(WmWindow* window) {
   window_->AddChild(GetMusWindow(window));
 }
 
-wm::WmWindow* WmWindowMus::GetParent() {
+WmWindow* WmWindowMus::GetParent() {
   return Get(window_->parent());
 }
 
-const wm::WmWindow* WmWindowMus::GetTransientParent() const {
+const WmWindow* WmWindowMus::GetTransientParent() const {
   return Get(window_->transient_parent());
 }
 
-std::vector<wm::WmWindow*> WmWindowMus::GetTransientChildren() {
+std::vector<WmWindow*> WmWindowMus::GetTransientChildren() {
   return FromMusWindows(window_->transient_children());
 }
 
 void WmWindowMus::SetLayoutManager(
-    std::unique_ptr<wm::WmLayoutManager> layout_manager) {
+    std::unique_ptr<WmLayoutManager> layout_manager) {
   if (layout_manager) {
     layout_manager_adapter_.reset(
         new MusLayoutManagerAdapter(window_, std::move(layout_manager)));
   } else {
     layout_manager_adapter_.reset();
   }
 }
 
-wm::WmLayoutManager* WmWindowMus::GetLayoutManager() {
+WmLayoutManager* WmWindowMus::GetLayoutManager() {
   return layout_manager_adapter_ ? layout_manager_adapter_->layout_manager()
                                  : nullptr;
 }
 
 void WmWindowMus::SetVisibilityAnimationType(int type) {
   // TODO: need animation support: http://crbug.com/615087.
   NOTIMPLEMENTED();
 }
 
 void WmWindowMus::SetVisibilityAnimationDuration(base::TimeDelta delta) {
@@ skipping 91 matching lines @@
 }
 
 void WmWindowMus::SetRestoreBoundsInScreen(const gfx::Rect& bounds) {
   restore_bounds_in_screen_.reset(new gfx::Rect(bounds));
 }
 
 gfx::Rect WmWindowMus::GetRestoreBoundsInScreen() const {
   return *restore_bounds_in_screen_;
 }
 
-bool WmWindowMus::Contains(const wm::WmWindow* other) const {
+bool WmWindowMus::Contains(const WmWindow* other) const {
   return other
              ? window_->Contains(
                    static_cast<const WmWindowMus*>(other)->window_)
              : false;
 }
 
 void WmWindowMus::SetShowState(ui::WindowShowState show_state) {
   SetWindowShowState(window_, MojomWindowShowStateFromUI(show_state));
 }
 
@@ skipping 37 matching lines @@
 bool WmWindowMus::CanResize() const {
   return widget_ ? widget_->widget_delegate()->CanResize() : false;
 }
 
 bool WmWindowMus::CanActivate() const {
   // TODO(sky): this isn't quite right. Should key off CanFocus(), which is not
   // replicated.
   return widget_ != nullptr;
 }
 
-void WmWindowMus::StackChildAtTop(wm::WmWindow* child) {
+void WmWindowMus::StackChildAtTop(WmWindow* child) {
   GetMusWindow(child)->MoveToFront();
 }
 
-void WmWindowMus::StackChildAtBottom(wm::WmWindow* child) {
+void WmWindowMus::StackChildAtBottom(WmWindow* child) {
   GetMusWindow(child)->MoveToBack();
 }
 
-void WmWindowMus::StackChildAbove(wm::WmWindow* child, wm::WmWindow* target) {
+void WmWindowMus::StackChildAbove(WmWindow* child, WmWindow* target) {
   GetMusWindow(child)->Reorder(GetMusWindow(target),
                                ::mus::mojom::OrderDirection::ABOVE);
 }
 
 void WmWindowMus::StackChildBelow(WmWindow* child, WmWindow* target) {
   GetMusWindow(child)->Reorder(GetMusWindow(target),
                                ::mus::mojom::OrderDirection::BELOW);
 }
 
 void WmWindowMus::SetAlwaysOnTop(bool value) {
@@ skipping 25 matching lines @@
   return window_->HasFocus();
 }
 
 bool WmWindowMus::IsActive() const {
   ::mus::Window* focused = window_->window_tree()->GetFocusedWindow();
   return focused && window_->Contains(focused);
 }
 
 void WmWindowMus::Activate() {
   window_->SetFocus();
-  wm::WmWindow* top_level = GetToplevelWindow();
+  WmWindow* top_level = GetToplevelWindow();
   if (!top_level)
     return;
 
   // TODO(sky): mus should do this too.
   GetMusWindow(top_level)->MoveToFront();
 }
 
 void WmWindowMus::Deactivate() {
   if (IsActive())
     window_->window_tree()->ClearFocus();
 }
 
 void WmWindowMus::SetFullscreen() {
   SetWindowShowState(window_, ::mus::mojom::ShowState::FULLSCREEN);
 }
 
 void WmWindowMus::Maximize() {
   SetWindowShowState(window_, ::mus::mojom::ShowState::MAXIMIZED);
 }
 
 void WmWindowMus::Minimize() {
   SetWindowShowState(window_, ::mus::mojom::ShowState::MINIMIZED);
 }
 
 void WmWindowMus::Unminimize() {
   SetWindowShowState(window_, MojomWindowShowStateFromUI(restore_show_state_));
   restore_show_state_ = ui::SHOW_STATE_DEFAULT;
 }
 
-std::vector<wm::WmWindow*> WmWindowMus::GetChildren() {
+std::vector<WmWindow*> WmWindowMus::GetChildren() {
   return FromMusWindows(window_->children());
 }
 
-wm::WmWindow* WmWindowMus::GetChildByShellWindowId(int id) {
+WmWindow* WmWindowMus::GetChildByShellWindowId(int id) {
   if (id == shell_window_id_)
     return this;
   for (::mus::Window* child : window_->children()) {
-    wm::WmWindow* result = Get(child)->GetChildByShellWindowId(id);
+    WmWindow* result = Get(child)->GetChildByShellWindowId(id);
     if (result)
       return result;
   }
   return nullptr;
 }
 
 void WmWindowMus::ShowResizeShadow(int component) {
   NOTIMPLEMENTED();
 }
 
 void WmWindowMus::HideResizeShadow() {
   NOTIMPLEMENTED();
 }
 
 void WmWindowMus::SetBoundsInScreenBehaviorForChildren(
-    wm::WmWindow::BoundsInScreenBehavior behavior) {
+    WmWindow::BoundsInScreenBehavior behavior) {
   // TODO: SetBoundsInScreen isn't fully implemented yet,
   // http://crbug.com/615552.
   NOTIMPLEMENTED();
 }
 
 void WmWindowMus::SetSnapsChildrenToPhysicalPixelBoundary() {
   if (snap_children_to_pixel_boundary_)
     return;
 
   snap_children_to_pixel_boundary_ = true;
   FOR_EACH_OBSERVER(
-      wm::WmWindowObserver, observers_,
+      WmWindowObserver, observers_,
       OnWindowPropertyChanged(
-          this, wm::WmWindowProperty::SNAP_CHILDREN_TO_PIXEL_BOUNDARY));
+          this, WmWindowProperty::SNAP_CHILDREN_TO_PIXEL_BOUNDARY));
 }
 
 void WmWindowMus::SnapToPixelBoundaryIfNecessary() {
   WmWindowMus* parent = Get(window_->parent());
   if (parent && parent->snap_children_to_pixel_boundary_) {
     // TODO: implement snap to pixel: http://crbug.com/615554.
     NOTIMPLEMENTED();
   }
 }
 
 void WmWindowMus::SetChildrenUseExtendedHitRegion() {
   children_use_extended_hit_region_ = true;
 }
 
 void WmWindowMus::SetDescendantsStayInSameRootWindow(bool value) {
   // TODO: this logic feeds into SetBoundsInScreen(), which is not implemented:
   // http://crbug.com/615552.
   NOTIMPLEMENTED();
 }
 
-void WmWindowMus::AddObserver(wm::WmWindowObserver* observer) {
+void WmWindowMus::AddObserver(WmWindowObserver* observer) {
   observers_.AddObserver(observer);
 }
 
-void WmWindowMus::RemoveObserver(wm::WmWindowObserver* observer) {
+void WmWindowMus::RemoveObserver(WmWindowObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void WmWindowMus::OnTreeChanged(const TreeChangeParams& params) {
-  wm::WmWindowObserver::TreeChangeParams wm_params;
+  WmWindowObserver::TreeChangeParams wm_params;
   wm_params.target = Get(params.target);
   wm_params.new_parent = Get(params.new_parent);
   wm_params.old_parent = Get(params.old_parent);
-  FOR_EACH_OBSERVER(wm::WmWindowObserver, observers_,
+  FOR_EACH_OBSERVER(WmWindowObserver, observers_,
                     OnWindowTreeChanged(this, wm_params));
 }
 
 void WmWindowMus::OnWindowReordered(::mus::Window* window,
                                     ::mus::Window* relative_window,
                                     ::mus::mojom::OrderDirection direction) {
-  FOR_EACH_OBSERVER(wm::WmWindowObserver, observers_,
+  FOR_EACH_OBSERVER(WmWindowObserver, observers_,
                     OnWindowStackingChanged(this));
 }
 
 void WmWindowMus::OnWindowSharedPropertyChanged(
     ::mus::Window* window,
     const std::string& name,
     const std::vector<uint8_t>* old_data,
     const std::vector<uint8_t>* new_data) {
   if (name == ::mus::mojom::WindowManager::kShowState_Property) {
     GetWindowState()->OnWindowShowStateChanged();
     return;
   }
   if (name == ::mus::mojom::WindowManager::kAlwaysOnTop_Property) {
     FOR_EACH_OBSERVER(
-        wm::WmWindowObserver, observers_,
-        OnWindowPropertyChanged(this, wm::WmWindowProperty::ALWAYS_ON_TOP));
+        WmWindowObserver, observers_,
+        OnWindowPropertyChanged(this, WmWindowProperty::ALWAYS_ON_TOP));
     return;
   }
 
   // Deal with snap to pixel.
   NOTIMPLEMENTED();
 }
 
 void WmWindowMus::OnWindowBoundsChanged(::mus::Window* window,
                                         const gfx::Rect& old_bounds,
                                         const gfx::Rect& new_bounds) {
-  FOR_EACH_OBSERVER(wm::WmWindowObserver, observers_,
+  FOR_EACH_OBSERVER(WmWindowObserver, observers_,
                     OnWindowBoundsChanged(this, old_bounds, new_bounds));
 }
 
 void WmWindowMus::OnWindowDestroying(::mus::Window* window) {
-  FOR_EACH_OBSERVER(wm::WmWindowObserver, observers_, OnWindowDestroying(this));
+  FOR_EACH_OBSERVER(WmWindowObserver, observers_, OnWindowDestroying(this));
 }
 
 }  // namespace mus
 }  // namespace ash