wm: public window_types.

ash/wm/dock/docked_window_layout_manager_unittest.cc

 // Copyright (c) 2013 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/dock/docked_window_layout_manager.h"
 
 #include "ash/ash_switches.h"
 #include "ash/launcher/launcher.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
@@ skipping 22 matching lines @@
 #include "ui/aura/window.h"
 #include "ui/base/hit_test.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace internal {
 
 class DockedWindowLayoutManagerTest
     : public test::AshTestBase,
-      public testing::WithParamInterface<aura::client::WindowType> {
+      public testing::WithParamInterface<ui::wm::WindowType> {
  public:
   DockedWindowLayoutManagerTest() : window_type_(GetParam()) {}
   virtual ~DockedWindowLayoutManagerTest() {}
 
   virtual void SetUp() OVERRIDE {
     CommandLine::ForCurrentProcess()->AppendSwitch(
         ash::switches::kAshEnableDockedWindows);
     AshTestBase::SetUp();
     UpdateDisplay("600x600");
     ASSERT_TRUE(test::TestShelfDelegate::instance());
@@ skipping 12 matching lines @@
 
   int min_dock_gap() const { return DockedWindowLayoutManager::kMinDockGap; }
   int ideal_width() const { return DockedWindowLayoutManager::kIdealWidth; }
   int docked_width(const DockedWindowLayoutManager* layout_manager) const {
     return layout_manager->docked_width_;
   }
 
   aura::Window* CreateTestWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateTestWindowInShellWithDelegateAndType(
         NULL, window_type_, 0, bounds);
-    if (window_type_ == aura::client::WINDOW_TYPE_PANEL) {
+    if (window_type_ == ui::wm::WINDOW_TYPE_PANEL) {
       test::TestShelfDelegate* shelf_delegate =
           test::TestShelfDelegate::instance();
       shelf_delegate->AddLauncherItem(window);
       PanelLayoutManager* manager =
           static_cast<PanelLayoutManager*>(GetPanelContainer(window)->
               layout_manager());
       manager->Relayout();
     }
     return window;
   }
 
   aura::Window* CreateTestWindowWithDelegate(
       const gfx::Rect& bounds,
       aura::test::TestWindowDelegate* delegate) {
     aura::Window* window = CreateTestWindowInShellWithDelegateAndType(
         delegate, window_type_, 0, bounds);
-    if (window_type_ == aura::client::WINDOW_TYPE_PANEL) {
+    if (window_type_ == ui::wm::WINDOW_TYPE_PANEL) {
       test::TestShelfDelegate* shelf_delegate =
           test::TestShelfDelegate::instance();
       shelf_delegate->AddLauncherItem(window);
       PanelLayoutManager* manager =
           static_cast<PanelLayoutManager*>(GetPanelContainer(window)->
               layout_manager());
       manager->Relayout();
     }
     return window;
   }
@@ skipping 40 matching lines @@
   void DragRevert() {
     resizer_->RevertDrag();
     resizer_.reset();
   }
 
   // Panels are parented by panel container during drags.
   // Docked windows are parented by dock container during drags.
   // All other windows that we are testing here have default container as a
   // parent.
   int CorrectContainerIdDuringDrag() {
-    if (window_type_ == aura::client::WINDOW_TYPE_PANEL)
+    if (window_type_ == ui::wm::WINDOW_TYPE_PANEL)
       return internal::kShellWindowId_PanelContainer;
     return internal::kShellWindowId_DockedContainer;
   }
 
   // Test dragging the window vertically (to detach if it is a panel) and then
   // horizontally to the edge with an added offset from the edge of |dx|.
-  void DragRelativeToEdge(DockedEdge edge,
-                          aura::Window* window,
-                          int dx) {
+  void DragRelativeToEdge(DockedEdge edge, aura::Window* window, int dx) {
     DragVerticallyAndRelativeToEdge(
         edge,
         window,
         dx,
-        window_type_ == aura::client::WINDOW_TYPE_PANEL ? -100 : 20);
+        window_type_ == ui::wm::WINDOW_TYPE_PANEL ? -100 : 20);
   }
 
   void DragToVerticalPositionAndToEdge(DockedEdge edge,
                                        aura::Window* window,
                                        int y) {
     DragToVerticalPositionRelativeToEdge(edge, window, 0, y);
   }
 
   void DragToVerticalPositionRelativeToEdge(DockedEdge edge,
                                             aura::Window* window,
@@ skipping 30 matching lines @@
     // y-coordinate could be changed by possible automatic layout if docked.
     if (window->parent()->id() != internal::kShellWindowId_DockedContainer &&
         !wm::GetWindowState(window)->HasRestoreBounds()) {
       EXPECT_EQ(initial_bounds.y() + dy, window->GetBoundsInScreen().y());
     }
   }
 
  private:
   scoped_ptr<WindowResizer> resizer_;
   scoped_ptr<test::ShelfViewTestAPI> shelf_view_test_;
-  aura::client::WindowType window_type_;
+  ui::wm::WindowType window_type_;
 
   // Location at start of the drag in |window->parent()|'s coordinates.
   gfx::Point initial_location_in_parent_;
 
   DISALLOW_COPY_AND_ASSIGN(DockedWindowLayoutManagerTest);
 };
 
 // Tests that a created window is successfully added to the dock
 // layout manager.
 TEST_P(DockedWindowLayoutManagerTest, AddOneWindow) {
@@ skipping 576 matching lines @@
   // w2 should be less than half of the work area height (even with a margin).
   gfx::Rect work_area =
       Shell::GetScreen()->GetDisplayNearestWindow(w1.get()).work_area();
   EXPECT_GT(w1->GetBoundsInScreen().height(), work_area.height() / 2 + 10);
   EXPECT_LT(w2->GetBoundsInScreen().height(), work_area.height() / 2 - 10);
 }
 
 // Tests run twice - on both panels and normal windows
 INSTANTIATE_TEST_CASE_P(NormalOrPanel,
                         DockedWindowLayoutManagerTest,
-                        testing::Values(aura::client::WINDOW_TYPE_NORMAL,
-                                        aura::client::WINDOW_TYPE_PANEL));
+                        testing::Values(ui::wm::WINDOW_TYPE_NORMAL,
+                                        ui::wm::WINDOW_TYPE_PANEL));
 }  // namespace internal
 }  // namespace ash