Remove docked windows entirely in M59.

ash/wm/workspace_controller_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 "ash/common/wm/workspace_controller.h"
 
 #include <map>
 
 #include "ash/common/session/session_controller.h"
 #include "ash/common/shelf/shelf_layout_manager.h"
@@ skipping 1325 matching lines @@
   EXPECT_EQ(snapped_bounds, window->bounds());
   EXPECT_TRUE(window_state->bounds_changed_by_user());
 
   // Minimize and Restore |window|, the restored bounds should be equal to the
   // bounds of left snapped state.
   window_state->Minimize();
   window_state->Restore();
   EXPECT_EQ(snapped_bounds, window->bounds());
 }
 
-namespace {
-
-// Used by DragMaximizedNonTrackedWindow to track how many times the window
-// hierarchy changes affecting the specified window.
-class DragMaximizedNonTrackedWindowObserver : public aura::WindowObserver {
- public:
-  DragMaximizedNonTrackedWindowObserver(aura::Window* window)
-      : change_count_(0), window_(window) {}
-
-  // Number of times OnWindowHierarchyChanged() has been received.
-  void clear_change_count() { change_count_ = 0; }
-  int change_count() const { return change_count_; }
-
-  // aura::WindowObserver overrides:
-  // Counts number of times a window is reparented. Ignores reparenting into and
-  // from a docked container which is expected when a tab is dragged.
-  void OnWindowHierarchyChanged(const HierarchyChangeParams& params) override {
-    if (params.target != window_ ||
-        (params.old_parent->id() == kShellWindowId_DefaultContainer &&
-         params.new_parent->id() == kShellWindowId_DockedContainer) ||
-        (params.old_parent->id() == kShellWindowId_DockedContainer &&
-         params.new_parent->id() == kShellWindowId_DefaultContainer)) {
-      return;
-    }
-    change_count_++;
-  }
-
- private:
-  int change_count_;
-  aura::Window* window_;
-
-  DISALLOW_COPY_AND_ASSIGN(DragMaximizedNonTrackedWindowObserver);
-};
-
-}  // namespace
-
 // Verifies that a new maximized window becomes visible after its activation
 // is requested, even though it does not become activated because a system
 // modal window is active.
 TEST_F(WorkspaceControllerTest, SwitchFromModal) {
   std::unique_ptr<Window> modal_window(CreateTestWindowUnparented());
   modal_window->SetBounds(gfx::Rect(10, 11, 21, 22));
   modal_window->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_SYSTEM);
   ParentWindowInPrimaryRootWindow(modal_window.get());
   modal_window->Show();
   wm::ActivateWindow(modal_window.get());
 
   std::unique_ptr<Window> maximized_window(CreateTestWindow());
   maximized_window->SetProperty(aura::client::kShowStateKey,
                                 ui::SHOW_STATE_MAXIMIZED);
   maximized_window->Show();
   wm::ActivateWindow(maximized_window.get());
   EXPECT_TRUE(maximized_window->IsVisible());
 }
 
-namespace {
-
-// Subclass of WorkspaceControllerTest that runs tests with docked windows
-// enabled and disabled.
-class WorkspaceControllerTestDragging : public WorkspaceControllerTest {
- public:
-  WorkspaceControllerTestDragging() {}
-  ~WorkspaceControllerTestDragging() override {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(WorkspaceControllerTestDragging);
-};
-
-}  // namespace
-
 // Verifies that when dragging a window over the shelf overlap is detected
 // during and after the drag.
-TEST_F(WorkspaceControllerTestDragging, DragWindowOverlapShelf) {
+TEST_F(WorkspaceControllerTest, DragWindowOverlapShelf) {
   aura::test::TestWindowDelegate delegate;
   delegate.set_window_component(HTCAPTION);
   std::unique_ptr<Window> w1(aura::test::CreateTestWindowWithDelegate(
       &delegate, ui::wm::WINDOW_TYPE_NORMAL, gfx::Rect(5, 5, 100, 50), NULL));
   ParentWindowInPrimaryRootWindow(w1.get());
 
   GetPrimaryShelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
 
   // Drag near the shelf.
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                      gfx::Point());
   generator.MoveMouseTo(10, 10);
   generator.PressLeftButton();
   generator.MoveMouseTo(100, shelf_layout_manager()->GetIdealBounds().y() - 70);
 
   // Shelf should not be in overlapped state.
   EXPECT_FALSE(GetWindowOverlapsShelf());
 
   generator.MoveMouseTo(100, shelf_layout_manager()->GetIdealBounds().y() - 20);
 
   // Shelf should detect overlap. Overlap state stays after mouse is released.
   EXPECT_TRUE(GetWindowOverlapsShelf());
   generator.ReleaseLeftButton();
   EXPECT_TRUE(GetWindowOverlapsShelf());
 }
 
 // Verifies that when dragging a window autohidden shelf stays hidden during
 // and after the drag.
-TEST_F(WorkspaceControllerTestDragging, DragWindowKeepsShelfAutohidden) {
+TEST_F(WorkspaceControllerTest, DragWindowKeepsShelfAutohidden) {
   aura::test::TestWindowDelegate delegate;
   delegate.set_window_component(HTCAPTION);
   std::unique_ptr<Window> w1(aura::test::CreateTestWindowWithDelegate(
       &delegate, ui::wm::WINDOW_TYPE_NORMAL, gfx::Rect(5, 5, 100, 50), NULL));
   ParentWindowInPrimaryRootWindow(w1.get());
 
   WmShelf* shelf = GetPrimaryShelf();
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
 
@@ skipping 132 matching lines @@
     ui::TouchEvent touch(ui::ET_TOUCH_PRESSED, location, 0,
                          ui::EventTimeForNow());
     ui::EventTarget* target = targeter->FindTargetForEvent(root, &touch);
     if (points[i].is_target_hit)
       EXPECT_EQ(window.get(), target);
     else
       EXPECT_NE(window.get(), target);
   }
 }
 
-// Verifies events targeting just outside the window edges for docked windows.
-TEST_F(WorkspaceControllerTest, WindowEdgeHitTestDocked) {
-  aura::test::TestWindowDelegate delegate;
-  // Make window smaller than the minimum docked area so that the window edges
-  // are exposed.
-  delegate.set_maximum_size(gfx::Size(180, 200));
-  std::unique_ptr<Window> window(aura::test::CreateTestWindowWithDelegate(
-      &delegate, 123, gfx::Rect(20, 10, 100, 50), NULL));
-  ParentWindowInPrimaryRootWindow(window.get());
-  aura::Window* docked_container = Shell::GetContainer(
-      window->GetRootWindow(), kShellWindowId_DockedContainer);
-  docked_container->AddChild(window.get());
-  window->Show();
-  aura::Window* root = window->GetRootWindow();
-  ui::EventTargeter* targeter =
-      root->GetHost()->dispatcher()->GetDefaultEventTargeter();
-  const gfx::Rect bounds = window->bounds();
-  const int kNumPoints = 5;
-  struct {
-    const char* direction;
-    gfx::Point location;
-    bool is_target_hit;
-  } points[kNumPoints] = {
-      {"left", gfx::Point(bounds.x() - 2, bounds.y() + 10), true},
-      {"top", gfx::Point(bounds.x() + 10, bounds.y() - 2), true},
-      {"right", gfx::Point(bounds.right() + 2, bounds.y() + 10), true},
-      {"bottom", gfx::Point(bounds.x() + 10, bounds.bottom() + 2), true},
-      {"outside", gfx::Point(bounds.x() + 10, bounds.y() - 31), false},
-  };
-  for (int i = 0; i < kNumPoints; ++i) {
-    SCOPED_TRACE(points[i].direction);
-    const gfx::Point& location = points[i].location;
-    ui::MouseEvent mouse(ui::ET_MOUSE_MOVED, location, location,
-                         ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
-    ui::EventTarget* target = targeter->FindTargetForEvent(root, &mouse);
-    if (points[i].is_target_hit)
-      EXPECT_EQ(window.get(), target);
-    else
-      EXPECT_NE(window.get(), target);
-
-    ui::TouchEvent touch(ui::ET_TOUCH_PRESSED, location, 0,
-                         ui::EventTimeForNow());
-    target = targeter->FindTargetForEvent(root, &touch);
-    if (points[i].is_target_hit)
-      EXPECT_EQ(window.get(), target);
-    else
-      EXPECT_NE(window.get(), target);
-  }
-}
-
 }  // namespace ash