Shuffles and renames ash/common/wm classes

ash/mus/workspace/workspace_layout_manager_unittest.cc

 // Copyright (c) 2012 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/common/wm/workspace/workspace_layout_manager.h"
 
 #include <string>
 #include <utility>
 
 #include "ash/common/wm/fullscreen_window_finder.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_event.h"
-#include "ash/common/wm/wm_root_window_controller_observer.h"
 #include "ash/common/wm/wm_screen_util.h"
+#include "ash/common/wm_root_window_controller_observer.h"
 #include "ash/mus/bridge/wm_root_window_controller_mus.h"
 #include "ash/mus/bridge/wm_window_mus.h"
 #include "ash/mus/test/wm_test_base.h"
 #include "components/mus/public/cpp/tests/test_window.h"
 #include "ui/display/display.h"
 
 namespace ash {
 namespace mus {
 namespace {
 
@@ skipping 14 matching lines @@
     return true;
   }
 
  private:
   const gfx::Rect initial_bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(MaximizeDelegateView);
 };
 */
 
-class FullscreenObserver : public wm::WmRootWindowControllerObserver {
+class FullscreenObserver : public WmRootWindowControllerObserver {
  public:
-  explicit FullscreenObserver(
-      wm::WmRootWindowController* root_window_controller)
+  explicit FullscreenObserver(WmRootWindowController* root_window_controller)
       : root_window_controller_(root_window_controller),
         call_count_(0),
         is_fullscreen_(false) {
     root_window_controller_->AddObserver(this);
   }
 
   ~FullscreenObserver() override {
     root_window_controller_->RemoveObserver(this);
   }
 
   void OnFullscreenStateChanged(bool is_fullscreen) override {
     call_count_++;
     is_fullscreen_ = is_fullscreen;
   }
 
   int call_count() const { return call_count_; }
 
   bool is_fullscreen() const { return is_fullscreen_; }
 
  private:
-  wm::WmRootWindowController* root_window_controller_;
+  WmRootWindowController* root_window_controller_;
   int call_count_;
   bool is_fullscreen_;
 
   DISALLOW_COPY_AND_ASSIGN(FullscreenObserver);
 };
 
 }  // namespace
 
 using WorkspaceLayoutManagerTest = WmTestBase;
 
 // Verifies that a window containing a restore coordinate will be restored to
 // to the size prior to minimize, keeping the restore rectangle in tact (if
 // there is one).
 TEST_F(WorkspaceLayoutManagerTest, RestoreFromMinimizeKeepsRestore) {
   ::mus::Window* mus_window = CreateTestWindow(gfx::Rect(1, 2, 3, 4));
-  wm::WmWindow* window = WmWindowMus::Get(mus_window);
+  WmWindow* window = WmWindowMus::Get(mus_window);
   gfx::Rect bounds(10, 15, 25, 35);
   window->SetBounds(bounds);
 
   wm::WindowState* window_state = window->GetWindowState();
 
   // This will not be used for un-minimizing window.
   window_state->SetRestoreBoundsInScreen(gfx::Rect(0, 0, 100, 100));
   window_state->Minimize();
   window_state->Restore();
   EXPECT_EQ("0,0 100x100", window_state->GetRestoreBoundsInScreen().ToString());
@@ skipping 245 matching lines @@
   window_state->Maximize();
   EXPECT_EQ("10,20 30x40",
             window_state->GetRestoreBoundsInScreen().ToString());
   window->RemoveObserver(&window_observer);
 }
 */
 
 // Verifies when a window is maximized all descendant windows have a size.
 TEST_F(WorkspaceLayoutManagerTest, ChildBoundsResetOnMaximize) {
   ::mus::Window* mus_window = CreateTestWindow(gfx::Rect(10, 20, 30, 40));
-  wm::WmWindow* window = WmWindowMus::Get(mus_window);
+  WmWindow* window = WmWindowMus::Get(mus_window);
 
   wm::WindowState* window_state = window->GetWindowState();
   window_state->Activate();
   ::mus::Window* child_window =
       CreateChildTestWindow(mus_window, gfx::Rect(5, 6, 7, 8));
   window_state->Maximize();
   EXPECT_EQ("5,6 7x8", child_window->bounds().ToString());
 }
 
 // Verifies a window created with maximized state has the maximized
 // bounds.
 TEST_F(WorkspaceLayoutManagerTest, MaximizeWithEmptySize) {
   ::mus::Window* mus_window = CreateTestWindow(gfx::Rect());
   WmWindowMus* window = WmWindowMus::Get(mus_window);
   window->GetWindowState()->Maximize();
   gfx::Rect work_area(GetPrimaryDisplay().work_area());
   EXPECT_EQ(work_area.ToString(), window->GetBoundsInScreen().ToString());
 }
 
 TEST_F(WorkspaceLayoutManagerTest, WindowShouldBeOnScreenWhenAdded) {
   // Normal window bounds shouldn't be changed.
   gfx::Rect window_bounds(100, 100, 200, 200);
   ::mus::Window* mus_window = CreateTestWindow(window_bounds);
-  wm::WmWindow* window = WmWindowMus::Get(mus_window);
+  WmWindow* window = WmWindowMus::Get(mus_window);
   EXPECT_EQ(window_bounds, mus_window->bounds());
 
   // If the window is out of the workspace, it would be moved on screen.
   gfx::Rect root_window_bounds = GetPrimaryRootWindow()->bounds();
   window_bounds.Offset(root_window_bounds.width(), root_window_bounds.height());
   ASSERT_FALSE(window_bounds.Intersects(root_window_bounds));
   ::mus::Window* out_mus_window = CreateTestWindow(window_bounds);
-  wm::WmWindow* out_window = WmWindowMus::Get(out_mus_window);
+  WmWindow* out_window = WmWindowMus::Get(out_mus_window);
   EXPECT_EQ(window_bounds.size(), out_mus_window->bounds().size());
   gfx::Rect bounds = out_mus_window->bounds();
   bounds.Intersect(root_window_bounds);
 
   // 30% of the window edge must be visible.
   EXPECT_GT(bounds.width(), out_mus_window->bounds().width() * 0.29);
   EXPECT_GT(bounds.height(), out_mus_window->bounds().height() * 0.29);
 
   ::mus::Window* mus_parent = out_mus_window->parent();
   mus_parent->RemoveChild(out_mus_window);
@@ skipping 93 matching lines @@
   EXPECT_EQ(6, observer.call_count());
   EXPECT_FALSE(observer.is_fullscreen());
 }
 // Following "Solo" tests were originally written for BaseLayoutManager.
 using WorkspaceLayoutManagerSoloTest = WmTestBase;
 
 // Tests normal->maximize->normal.
 TEST_F(WorkspaceLayoutManagerSoloTest, Maximize) {
   gfx::Rect bounds(100, 100, 200, 200);
   ::mus::Window* mus_window = CreateTestWindow(bounds);
-  wm::WmWindow* window = WmWindowMus::Get(mus_window);
+  WmWindow* window = WmWindowMus::Get(mus_window);
   window->SetShowState(ui::SHOW_STATE_MAXIMIZED);
   // Maximized window fills the work area, not the whole display.
   EXPECT_EQ(wm::GetMaximizedWindowBoundsInParent(window).ToString(),
             mus_window->bounds().ToString());
   window->SetShowState(ui::SHOW_STATE_NORMAL);
   EXPECT_EQ(bounds.ToString(), mus_window->bounds().ToString());
 }
 
 // Tests normal->minimize->normal.
 TEST_F(WorkspaceLayoutManagerSoloTest, Minimize) {
   gfx::Rect bounds(100, 100, 200, 200);
   ::mus::Window* mus_window = CreateTestWindow(bounds);
-  wm::WmWindow* window = WmWindowMus::Get(mus_window);
+  WmWindow* window = WmWindowMus::Get(mus_window);
   window->SetShowState(ui::SHOW_STATE_MINIMIZED);
   // Note: Currently minimize doesn't do anything except set the state.
   // See crbug.com/104571.
   EXPECT_EQ(bounds.ToString(), mus_window->bounds().ToString());
   window->SetShowState(ui::SHOW_STATE_NORMAL);
   EXPECT_EQ(bounds.ToString(), mus_window->bounds().ToString());
 }
 
 // A WindowObserver which sets the focus when the window becomes visible.
 class FocusObserver : public ::mus::WindowObserver {
@@ skipping 25 matching lines @@
 };
 
 // Make sure that the window's show state is correct in
 // |mus::WindowObserver::OnWindowVisibilityChanged|, and setting
 // focus in this callback doesn't cause DCHECK error.  See
 // crbug.com/168383.
 // NOTE: this was adapted from the ash test of the same name, I suspect this
 // test isn't particularly useful for mash.
 TEST_F(WorkspaceLayoutManagerSoloTest, FocusDuringUnminimize) {
   ::mus::Window* mus_window = CreateTestWindow(gfx::Rect(100, 100, 100, 100));
-  wm::WmWindow* window = WmWindowMus::Get(mus_window);
+  WmWindow* window = WmWindowMus::Get(mus_window);
   FocusObserver observer(mus_window);
   window->SetShowState(ui::SHOW_STATE_MINIMIZED);
   EXPECT_FALSE(window->IsVisible());
   EXPECT_EQ(ui::SHOW_STATE_MINIMIZED, observer.GetShowStateAndReset());
   window->Show();
   EXPECT_TRUE(window->IsVisible());
   EXPECT_EQ(ui::SHOW_STATE_NORMAL, observer.GetShowStateAndReset());
 }
 
 // Tests maximized window size during root window resize.
 TEST_F(WorkspaceLayoutManagerSoloTest, MaximizeRootWindowResize) {
   gfx::Rect bounds(100, 100, 200, 200);
   ::mus::Window* mus_window = CreateTestWindow(bounds);
-  wm::WmWindow* window = WmWindowMus::Get(mus_window);
+  WmWindow* window = WmWindowMus::Get(mus_window);
   window->SetShowState(ui::SHOW_STATE_MAXIMIZED);
   gfx::Rect initial_work_area_bounds =
       wm::GetMaximizedWindowBoundsInParent(window);
   EXPECT_EQ(initial_work_area_bounds.ToString(),
             mus_window->bounds().ToString());
   // Enlarge the root window.  We should still match the work area size.
   UpdateDisplay("900x700");
   EXPECT_EQ(wm::GetMaximizedWindowBoundsInParent(window).ToString(),
             mus_window->bounds().ToString());
   EXPECT_NE(initial_work_area_bounds.ToString(),
             wm::GetMaximizedWindowBoundsInParent(window).ToString());
 }
 
 // Tests normal->fullscreen->normal.
 TEST_F(WorkspaceLayoutManagerSoloTest, Fullscreen) {
   gfx::Rect bounds(100, 100, 200, 200);
   ::mus::Window* mus_window = CreateTestWindow(bounds);
-  wm::WmWindow* window = WmWindowMus::Get(mus_window);
+  WmWindow* window = WmWindowMus::Get(mus_window);
   window->SetShowState(ui::SHOW_STATE_FULLSCREEN);
   // Fullscreen window fills the whole display.
   EXPECT_EQ(window->GetDisplayNearestWindow().bounds().ToString(),
             mus_window->bounds().ToString());
   window->SetShowState(ui::SHOW_STATE_NORMAL);
   EXPECT_EQ(bounds.ToString(), mus_window->bounds().ToString());
 }
 
 // Tests that fullscreen window causes always_on_top windows to stack below.
 TEST_F(WorkspaceLayoutManagerSoloTest, FullscreenSuspendsAlwaysOnTop) {
   gfx::Rect bounds(100, 100, 200, 200);
   ::mus::Window* mus_fullscreen_window = CreateTestWindow(bounds);
   WmWindowMus* fullscreen_window = WmWindowMus::Get(mus_fullscreen_window);
   ::mus::Window* mus_always_on_top_window1 = CreateTestWindow(bounds);
   WmWindowMus* always_on_top_window1 =
       WmWindowMus::Get(mus_always_on_top_window1);
   ::mus::Window* mus_always_on_top_window2 = CreateTestWindow(bounds);
   WmWindowMus* always_on_top_window2 =
       WmWindowMus::Get(mus_always_on_top_window2);
   always_on_top_window1->SetAlwaysOnTop(true);
   always_on_top_window2->SetAlwaysOnTop(true);
   // Making a window fullscreen temporarily suspends always on top state.
   fullscreen_window->SetShowState(ui::SHOW_STATE_FULLSCREEN);
   EXPECT_FALSE(always_on_top_window1->IsAlwaysOnTop());
   EXPECT_FALSE(always_on_top_window2->IsAlwaysOnTop());
-  EXPECT_TRUE(GetWindowForFullscreenMode(fullscreen_window));
+  EXPECT_TRUE(wm::GetWindowForFullscreenMode(fullscreen_window));
   // Making fullscreen window normal restores always on top windows.
   fullscreen_window->SetShowState(ui::SHOW_STATE_NORMAL);
   EXPECT_TRUE(always_on_top_window1->IsAlwaysOnTop());
   EXPECT_TRUE(always_on_top_window2->IsAlwaysOnTop());
-  EXPECT_FALSE(GetWindowForFullscreenMode(fullscreen_window));
+  EXPECT_FALSE(wm::GetWindowForFullscreenMode(fullscreen_window));
 }
 
 // Tests fullscreen window size during root window resize.
 TEST_F(WorkspaceLayoutManagerSoloTest, FullscreenRootWindowResize) {
   gfx::Rect bounds(100, 100, 200, 200);
   ::mus::Window* mus_window = CreateTestWindow(bounds);
-  wm::WmWindow* window = WmWindowMus::Get(mus_window);
+  WmWindow* window = WmWindowMus::Get(mus_window);
   // Fullscreen window fills the whole display.
   window->SetShowState(ui::SHOW_STATE_FULLSCREEN);
   EXPECT_EQ(window->GetDisplayNearestWindow().bounds().ToString(),
             mus_window->bounds().ToString());
   // Enlarge the root window.  We should still match the display size.
   UpdateDisplay("1001x1201");
   EXPECT_EQ(window->GetDisplayNearestWindow().bounds().ToString(),
             mus_window->bounds().ToString());
 }
 
 // Tests that when the screen gets smaller the windows aren't bigger than
 // the screen.
 TEST_F(WorkspaceLayoutManagerSoloTest, RootWindowResizeShrinksWindows) {
   ::mus::Window* mus_window = CreateTestWindow(gfx::Rect(10, 20, 500, 400));
-  wm::WmWindow* window = WmWindowMus::Get(mus_window);
+  WmWindow* window = WmWindowMus::Get(mus_window);
   gfx::Rect work_area = window->GetDisplayNearestWindow().work_area();
   // Invariant: Window is smaller than work area.
   EXPECT_LE(mus_window->bounds().width(), work_area.width());
   EXPECT_LE(mus_window->bounds().height(), work_area.height());
 
   // Make the root window narrower than our window.
   UpdateDisplay("300x400");
   work_area = window->GetDisplayNearestWindow().work_area();
   EXPECT_LE(mus_window->bounds().width(), work_area.width());
   EXPECT_LE(mus_window->bounds().height(), work_area.height());
 
   // Make the root window shorter than our window.
   UpdateDisplay("300x200");
   work_area = window->GetDisplayNearestWindow().work_area();
   EXPECT_LE(mus_window->bounds().width(), work_area.width());
   EXPECT_LE(mus_window->bounds().height(), work_area.height());
 
   // Enlarging the root window does not change the window bounds.
   gfx::Rect old_bounds = mus_window->bounds();
   UpdateDisplay("800x600");
   EXPECT_EQ(old_bounds.width(), mus_window->bounds().width());
   EXPECT_EQ(old_bounds.height(), mus_window->bounds().height());
 }
 
 // Verifies maximizing sets the restore bounds, and restoring
 // restores the bounds.
 TEST_F(WorkspaceLayoutManagerSoloTest, MaximizeSetsRestoreBounds) {
   ::mus::Window* mus_window = CreateTestWindow(gfx::Rect(10, 20, 30, 40));
-  wm::WmWindow* window = WmWindowMus::Get(mus_window);
+  WmWindow* window = WmWindowMus::Get(mus_window);
   wm::WindowState* window_state = window->GetWindowState();
 
   // Maximize it, which will keep the previous restore bounds.
   window->SetShowState(ui::SHOW_STATE_MAXIMIZED);
   EXPECT_EQ("10,20 30x40", window_state->GetRestoreBoundsInParent().ToString());
 
   // Restore it, which should restore bounds and reset restore bounds.
   window->SetShowState(ui::SHOW_STATE_NORMAL);
   EXPECT_EQ("10,20 30x40", mus_window->bounds().ToString());
   EXPECT_FALSE(window_state->HasRestoreBounds());
 }
 
 // Verifies maximizing keeps the restore bounds if set.
 TEST_F(WorkspaceLayoutManagerSoloTest, MaximizeResetsRestoreBounds) {
   ::mus::Window* mus_window = CreateTestWindow(gfx::Rect(1, 2, 3, 4));
-  wm::WmWindow* window = WmWindowMus::Get(mus_window);
+  WmWindow* window = WmWindowMus::Get(mus_window);
 
   wm::WindowState* window_state = window->GetWindowState();
   window_state->SetRestoreBoundsInParent(gfx::Rect(10, 11, 12, 13));
 
   // Maximize it, which will keep the previous restore bounds.
   window->SetShowState(ui::SHOW_STATE_MAXIMIZED);
   EXPECT_EQ("10,11 12x13", window_state->GetRestoreBoundsInParent().ToString());
 }
 
 // Verifies that the restore bounds do not get reset when restoring to a
 // maximzied state from a minimized state.
 TEST_F(WorkspaceLayoutManagerSoloTest,
        BoundsAfterRestoringToMaximizeFromMinimize) {
   ::mus::Window* mus_window = CreateTestWindow(gfx::Rect(1, 2, 3, 4));
-  wm::WmWindow* window = WmWindowMus::Get(mus_window);
+  WmWindow* window = WmWindowMus::Get(mus_window);
   gfx::Rect bounds(10, 15, 25, 35);
   window->SetBounds(bounds);
 
   wm::WindowState* window_state = window->GetWindowState();
   // Maximize it, which should reset restore bounds.
   window_state->Maximize();
   EXPECT_EQ(bounds.ToString(),
             window_state->GetRestoreBoundsInParent().ToString());
   // Minimize the window. The restore bounds should not change.
   window_state->Minimize();
@@ skipping 46 matching lines @@
 
 // TODO(sky): these are commented out until maximize mode ported.
 // http://crbug.com/612629.
 
 // Following tests are written to test the backdrop functionality.
 
 namespace {
 
 WorkspaceLayoutManager* GetWorkspaceLayoutManager(aura::Window* container) {
   return static_cast<WorkspaceLayoutManager*>(
-      wm::WmWindowAura::Get(container)->GetLayoutManager());
+      WmWindowAura::Get(container)->GetLayoutManager());
 }
 
 class WorkspaceLayoutManagerBackdropTest : public test::AshTestBase {
  public:
   WorkspaceLayoutManagerBackdropTest() : default_container_(nullptr) {}
   ~WorkspaceLayoutManagerBackdropTest() override {}
 
   void SetUp() override {
     test::AshTestBase::SetUp();
     UpdateDisplay("800x600");
@@ skipping 313 matching lines @@
                       occluded_window_bounds.width(),
                       occluded_window_bounds.height()).ToString(),
             window->bounds().ToString());
   HideKeyboard();
   EXPECT_EQ(occluded_window_bounds.ToString(), window->bounds().ToString());
 }
 */
 
 }  // namespace mus
 }  // namespace ash