Hide docked windows behind a flag

ash/wm/overview/window_selector_unittest.cc

 // Copyright 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 <algorithm>
 #include <vector>
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/accessibility_delegate.h"
 #include "ash/common/accessibility_types.h"
@@ skipping 528 matching lines @@
   ToggleOverview();
   const std::vector<WindowSelectorItem*>& overview2(GetWindowItemsForRoot(0));
 
   // The order should be MRU.
   EXPECT_EQ(2, overview2[0]->GetWindow()->GetShellWindowId());
   EXPECT_EQ(1, overview2[1]->GetWindow()->GetShellWindowId());
   EXPECT_EQ(3, overview2[2]->GetWindow()->GetShellWindowId());
   ToggleOverview();
 }
 
+// Test class used for tests that need docked windows enabled.
+class EnabledDockedWindowsWindowSelectorTest : public WindowSelectorTest {
+ public:
+  EnabledDockedWindowsWindowSelectorTest() = default;
+  ~EnabledDockedWindowsWindowSelectorTest() override = default;
+
+  void SetUp() override {
+    base::CommandLine::ForCurrentProcess()->AppendSwitch(
+        ash::switches::kAshEnableDockedWindows);
+    WindowSelectorTest::SetUp();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(EnabledDockedWindowsWindowSelectorTest);
+};
+
 // Tests entering overview mode with docked windows
-TEST_F(WindowSelectorTest, BasicWithDocked) {
+TEST_F(EnabledDockedWindowsWindowSelectorTest, BasicWithDocked) {
   // aura::Window* root_window = Shell::GetPrimaryRootWindow();
   gfx::Rect bounds(300, 0, 200, 200);
   std::unique_ptr<aura::Window> window1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> window2(CreateWindow(bounds));
   std::unique_ptr<aura::Window> docked1(CreateWindow(bounds));
   std::unique_ptr<aura::Window> docked2(CreateWindow(bounds));
 
   wm::WMEvent dock_event(wm::WM_EVENT_DOCK);
   wm::GetWindowState(docked1.get())->OnWMEvent(&dock_event);
 
@@ skipping 53 matching lines @@
                   ->GetDisplayNearestWindow(docked1.get())
                   .work_area();
   expected_work_area_bounds = container_bounds.size();
   expected_work_area_bounds.Enlarge(-manager->docked_bounds().width(),
                                     -shelf->GetWindowBoundsInScreen().height());
   EXPECT_EQ(expected_work_area_bounds.ToString(), work_area.size().ToString());
 }
 
 // Tests that selecting a docked window updates docked layout pushing another
 // window to get docked-minimized.
-TEST_F(WindowSelectorTest, ActivateDockedWindow) {
+TEST_F(EnabledDockedWindowsWindowSelectorTest, ActivateDockedWindow) {
   // aura::Window* root_window = Shell::GetPrimaryRootWindow();
   gfx::Rect bounds(300, 0, 200, 200);
   std::unique_ptr<views::Widget> widget1 = CreateWindowWidget(bounds);
   std::unique_ptr<views::Widget> widget2 = CreateWindowWidget(bounds);
 
   aura::test::TestWindowDelegate delegate;
   delegate.set_minimum_size(gfx::Size(200, 500));
   std::unique_ptr<aura::Window> docked_window1(
       CreateTestWindowInShellWithDelegate(&delegate, -1, bounds));
   docked_window1->SetProperty(aura::client::kTopViewInset, kHeaderHeight);
@@ skipping 45 matching lines @@
 
   // |docked_window1| is docked-minimized and hidden.
   EXPECT_FALSE(docked_window1->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED_MINIMIZED, state1->GetStateType());
   // |docked_window2| is docked and visible.
   EXPECT_TRUE(docked_window2->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED, state2->GetStateType());
 }
 
 // Tests that clicking on the close button closes the docked window.
-TEST_F(WindowSelectorTest, CloseDockedWindow) {
+TEST_F(EnabledDockedWindowsWindowSelectorTest, CloseDockedWindow) {
   // aura::Window* root_window = Shell::GetPrimaryRootWindow();
   gfx::Rect bounds(300, 0, 200, 200);
   std::unique_ptr<views::Widget> widget1 = CreateWindowWidget(bounds);
   std::unique_ptr<views::Widget> widget2 = CreateWindowWidget(bounds);
 
   aura::test::TestWindowDelegate delegate;
   delegate.set_minimum_size(gfx::Size(200, 500));
   std::unique_ptr<aura::Window> docked_window1(
       CreateTestWindowInShellWithDelegate(&delegate, -1, bounds));
   docked_window1->SetProperty(aura::client::kTopViewInset, kHeaderHeight);
@@ skipping 42 matching lines @@
 
   // Window bounds are still the same.
   EXPECT_EQ(expected_bounds1.ToString(), docked_window1->bounds().ToString());
 
   // |docked_window1| returns to docked-minimized and hidden state.
   EXPECT_FALSE(docked_window1->IsVisible());
   EXPECT_EQ(wm::WINDOW_STATE_TYPE_DOCKED_MINIMIZED, state1->GetStateType());
 }
 
 // Tests that clicking on the close button closes the docked-minimized window.
-TEST_F(WindowSelectorTest, CloseDockedMinimizedWindow) {
+TEST_F(EnabledDockedWindowsWindowSelectorTest, CloseDockedMinimizedWindow) {
   // aura::Window* root_window = Shell::GetPrimaryRootWindow();
   gfx::Rect bounds(300, 0, 200, 200);
   std::unique_ptr<views::Widget> widget1 = CreateWindowWidget(bounds);
   std::unique_ptr<views::Widget> widget2 = CreateWindowWidget(bounds);
 
   aura::test::TestWindowDelegate delegate;
   delegate.set_minimum_size(gfx::Size(200, 500));
   std::unique_ptr<aura::Window> docked_window1(
       CreateTestWindowInShellWithDelegate(&delegate, -1, bounds));
   docked_window1->SetProperty(aura::client::kTopViewInset, kHeaderHeight);
@@ skipping 1364 matching lines @@
                           HTCAPTION, aura::client::WINDOW_MOVE_SOURCE_MOUSE));
   ASSERT_TRUE(resizer.get());
   gfx::Point location = resizer->GetInitialLocation();
   location.Offset(20, 20);
   resizer->Drag(location, 0);
   ToggleOverview();
   resizer->RevertDrag();
 }
 
 }  // namespace ash