Shuffles and renames ash/common/wm classes

ash/aura/wm_window_aura.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/wm/aura/wm_window_aura.h"
+#include "ash/aura/wm_window_aura.h"
 
 #include "ash/ash_constants.h"
+#include "ash/aura/aura_layout_manager_adapter.h"
+#include "ash/aura/wm_root_window_controller_aura.h"
+#include "ash/aura/wm_shell_aura.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/screen_util.h"
 #include "ash/shelf/shelf_util.h"
 #include "ash/shell.h"
-#include "ash/wm/aura/aura_layout_manager_adapter.h"
-#include "ash/wm/aura/wm_globals_aura.h"
-#include "ash/wm/aura/wm_root_window_controller_aura.h"
 #include "ash/wm/resize_shadow_controller.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_util.h"
 #include "base/memory/ptr_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer_tree_owner.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/coordinate_conversion.h"
 #include "ui/wm/core/easy_resize_window_targeter.h"
 #include "ui/wm/core/visibility_controller.h"
 #include "ui/wm/core/window_util.h"
 
-DECLARE_WINDOW_PROPERTY_TYPE(ash::wm::WmWindowAura*);
+DECLARE_WINDOW_PROPERTY_TYPE(ash::WmWindowAura*);
 
 namespace ash {
-namespace wm {
 
-DEFINE_OWNED_WINDOW_PROPERTY_KEY(ash::wm::WmWindowAura, kWmWindowKey, nullptr);
+DEFINE_OWNED_WINDOW_PROPERTY_KEY(ash::WmWindowAura, kWmWindowKey, nullptr);
 
 namespace {
 
 // A tentative class to set the bounds on the window.
 // TODO(oshima): Once all logic is cleaned up, move this to the real layout
 // manager with proper friendship.
 class BoundsSetter : public aura::LayoutManager {
  public:
   BoundsSetter() {}
   ~BoundsSetter() override {}
@@ skipping 56 matching lines @@
 
 const WmWindow* WmWindowAura::GetRootWindow() const {
   return Get(window_->GetRootWindow());
 }
 
 WmRootWindowController* WmWindowAura::GetRootWindowController() {
   aura::Window* root = window_->GetRootWindow();
   return root ? WmRootWindowControllerAura::Get(root) : nullptr;
 }
 
-WmGlobals* WmWindowAura::GetGlobals() const {
-  return WmGlobals::Get();
+WmShell* WmWindowAura::GetShell() const {
+  return WmShell::Get();
 }
 
 void WmWindowAura::SetName(const char* name) {
   window_->SetName(name);
 }
 
 base::string16 WmWindowAura::GetTitle() const {
   return window_->title();
 }
 
@@ skipping 112 matching lines @@
   if (key == WmWindowProperty::SHELF_ID)
     return GetShelfIDForWindow(window_);
 
   if (key == WmWindowProperty::TOP_VIEW_INSET)
     return window_->GetProperty(aura::client::kTopViewInset);
 
   NOTREACHED();
   return 0;
 }
 
-const WindowState* WmWindowAura::GetWindowState() const {
+const wm::WindowState* WmWindowAura::GetWindowState() const {
   return ash::wm::GetWindowState(window_);
 }
 
 WmWindow* WmWindowAura::GetToplevelWindow() {
   return Get(window_->GetToplevelWindow());
 }
 
 void WmWindowAura::SetParentUsingContext(WmWindow* context,
                                          const gfx::Rect& screen_bounds) {
   aura::client::ParentWindowWithContext(window_, GetAuraWindow(context),
@@ skipping 69 matching lines @@
     return;
   }
 
   ui::ScopedLayerAnimationSettings settings(window_->layer()->GetAnimator());
   settings.SetTransitionDuration(delta);
   window_->SetBounds(bounds);
 }
 
 void WmWindowAura::SetBoundsDirect(const gfx::Rect& bounds) {
   BoundsSetter().SetBounds(window_, bounds);
-  SnapWindowToPixelBoundary(window_);
+  wm::SnapWindowToPixelBoundary(window_);
 }
 
 void WmWindowAura::SetBoundsDirectAnimated(const gfx::Rect& bounds) {
   const int kBoundsChangeSlideDurationMs = 120;
 
   ui::Layer* layer = window_->layer();
   ui::ScopedLayerAnimationSettings slide_settings(layer->GetAnimator());
   slide_settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   slide_settings.SetTransitionDuration(
@@ skipping 147 matching lines @@
 void WmWindowAura::CloseWidget() {
   DCHECK(views::Widget::GetWidgetForNativeView(window_));
   views::Widget::GetWidgetForNativeView(window_)->Close();
 }
 
 bool WmWindowAura::IsFocused() const {
   return window_->HasFocus();
 }
 
 bool WmWindowAura::IsActive() const {
-  return IsActiveWindow(window_);
+  return wm::IsActiveWindow(window_);
 }
 
 void WmWindowAura::Activate() {
-  ActivateWindow(window_);
+  wm::ActivateWindow(window_);
 }
 
 void WmWindowAura::Deactivate() {
-  DeactivateWindow(window_);
+  wm::DeactivateWindow(window_);
 }
 
 void WmWindowAura::SetFullscreen() {
   window_->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
 }
 
 void WmWindowAura::Maximize() {
   return window_->SetProperty(aura::client::kShowStateKey,
                               ui::SHOW_STATE_MAXIMIZED);
 }
@@ skipping 36 matching lines @@
   window_->SetProperty(
       kUsesScreenCoordinatesKey,
       behavior == BoundsInScreenBehavior::USE_SCREEN_COORDINATES);
 }
 
 void WmWindowAura::SetSnapsChildrenToPhysicalPixelBoundary() {
   wm::SetSnapsChildrenToPhysicalPixelBoundary(window_);
 }
 
 void WmWindowAura::SnapToPixelBoundaryIfNecessary() {
-  SnapWindowToPixelBoundary(window_);
+  wm::SnapWindowToPixelBoundary(window_);
 }
 
 void WmWindowAura::SetChildrenUseExtendedHitRegion() {
   gfx::Insets mouse_extend(-kResizeOutsideBoundsSize, -kResizeOutsideBoundsSize,
                            -kResizeOutsideBoundsSize,
                            -kResizeOutsideBoundsSize);
   gfx::Insets touch_extend =
       mouse_extend.Scale(kResizeOutsideBoundsScaleForTouch);
   window_->SetEventTargeter(base::WrapUnique(
       new ::wm::EasyResizeWindowTargeter(window_, mouse_extend, touch_extend)));
@@ skipping 67 matching lines @@
 void WmWindowAura::OnWindowVisibilityChanging(aura::Window* window,
                                               bool visible) {
   FOR_EACH_OBSERVER(WmWindowObserver, observers_,
                     OnWindowVisibilityChanging(this, visible));
 }
 
 void WmWindowAura::OnWindowTitleChanged(aura::Window* window) {
   FOR_EACH_OBSERVER(WmWindowObserver, observers_, OnWindowTitleChanged(this));
 }
 
-}  // namespace wm
 }  // namespace ash