Remove docked windows entirely in M59.

ash/common/wm/default_state.cc

 // Copyright 2014 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/default_state.h"
 
-#include "ash/common/ash_switches.h"
-#include "ash/common/wm/dock/docked_window_layout_manager.h"
 #include "ash/common/wm/window_animation_types.h"
 #include "ash/common/wm/window_parenting_utils.h"
 #include "ash/common/wm/window_positioning_utils.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/window_state_delegate.h"
 #include "ash/common/wm/window_state_util.h"
 #include "ash/common/wm/wm_event.h"
 #include "ash/common/wm/wm_screen_util.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 
 namespace ash {
 namespace wm {
 namespace {
 
 // This specifies how much percent (30%) of a window rect
 // must be visible when the window is added to the workspace.
 const float kMinimumPercentOnScreenArea = 0.3f;
 
 // When a window that has restore bounds at least as large as a work area is
 // unmaximized, inset the bounds slightly so that they are not exactly the same.
 // This makes it easier to resize the window.
 const int kMaximizedWindowInset = 10;  // DIPs.
 
 bool IsMinimizedWindowState(const WindowStateType state_type) {
-  return state_type == WINDOW_STATE_TYPE_MINIMIZED ||
-         state_type == WINDOW_STATE_TYPE_DOCKED_MINIMIZED;
+  return state_type == WINDOW_STATE_TYPE_MINIMIZED;
 }
 
 void MoveToDisplayForRestore(WindowState* window_state) {
   if (!window_state->HasRestoreBounds())
     return;
   const gfx::Rect restore_bounds = window_state->GetRestoreBoundsInScreen();
 
   // Move only if the restore bounds is outside of
   // the display. There is no information about in which
   // display it should be restored, so this is best guess.
   // TODO(oshima): Restore information should contain the
   // work area information like WindowResizer does for the
   // last window location.
   gfx::Rect display_area =
       window_state->window()->GetDisplayNearestWindow().bounds();
 
   if (!display_area.Intersects(restore_bounds)) {
     const display::Display& display =
         display::Screen::GetScreen()->GetDisplayMatching(restore_bounds);
     WmShell* shell = window_state->window()->GetShell();
     WmWindow* new_root = shell->GetRootWindowForDisplayId(display.id());
     if (new_root != window_state->window()->GetRootWindow()) {
       WmWindow* new_container = new_root->GetChildByShellWindowId(
           window_state->window()->GetParent()->GetShellWindowId());
       new_container->AddChild(window_state->window());
     }
   }
 }
 
-DockedWindowLayoutManager* GetDockedWindowLayoutManager(WmShell* shell) {
-  return DockedWindowLayoutManager::Get(shell->GetActiveWindow());
-}
-
-class ScopedPreferredAlignmentResetter {
- public:
-  ScopedPreferredAlignmentResetter(DockedAlignment dock_alignment,
-                                   DockedWindowLayoutManager* dock_layout)
-      : docked_window_layout_manager_(dock_layout) {
-    docked_window_layout_manager_->set_preferred_alignment(dock_alignment);
-  }
-  ~ScopedPreferredAlignmentResetter() {
-    docked_window_layout_manager_->set_preferred_alignment(
-        DOCKED_ALIGNMENT_NONE);
-  }
-
- private:
-  DockedWindowLayoutManager* docked_window_layout_manager_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedPreferredAlignmentResetter);
-};
-
-class ScopedDockedLayoutEventSourceResetter {
- public:
-  ScopedDockedLayoutEventSourceResetter(DockedWindowLayoutManager* dock_layout)
-      : docked_window_layout_manager_(dock_layout) {
-    docked_window_layout_manager_->set_event_source(
-        DOCKED_ACTION_SOURCE_KEYBOARD);
-  }
-  ~ScopedDockedLayoutEventSourceResetter() {
-    docked_window_layout_manager_->set_event_source(
-        DOCKED_ACTION_SOURCE_UNKNOWN);
-  }
-
- private:
-  DockedWindowLayoutManager* docked_window_layout_manager_;
-
-  DISALLOW_COPY_AND_ASSIGN(ScopedDockedLayoutEventSourceResetter);
-};
-
 void CycleSnap(WindowState* window_state, WMEventType event) {
-  DCHECK(!ash::switches::DockedWindowsEnabled());
-
   wm::WindowStateType desired_snap_state =
-      event == WM_EVENT_CYCLE_SNAP_DOCK_LEFT
-          ? wm::WINDOW_STATE_TYPE_LEFT_SNAPPED
-          : wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED;
+      event == WM_EVENT_CYCLE_SNAP_LEFT ? wm::WINDOW_STATE_TYPE_LEFT_SNAPPED
+                                        : wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED;
 
   if (window_state->CanSnap() &&
       window_state->GetStateType() != desired_snap_state &&
       window_state->window()->GetType() != ui::wm::WINDOW_TYPE_PANEL) {
     const wm::WMEvent event(desired_snap_state ==
                                     wm::WINDOW_STATE_TYPE_LEFT_SNAPPED
                                 ? wm::WM_EVENT_SNAP_LEFT
                                 : wm::WM_EVENT_SNAP_RIGHT);
     window_state->OnWMEvent(&event);
     return;
   }
 
   if (window_state->IsSnapped()) {
     window_state->Restore();
     return;
   }
   window_state->window()->Animate(::wm::WINDOW_ANIMATION_TYPE_BOUNCE);
 }
 
-void CycleSnapDock(WindowState* window_state, WMEventType event) {
-  DCHECK(ash::switches::DockedWindowsEnabled());
-
-  DockedWindowLayoutManager* dock_layout =
-      GetDockedWindowLayoutManager(window_state->window()->GetShell());
-  wm::WindowStateType desired_snap_state =
-      event == WM_EVENT_CYCLE_SNAP_DOCK_LEFT
-          ? wm::WINDOW_STATE_TYPE_LEFT_SNAPPED
-          : wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED;
-  DockedAlignment desired_dock_alignment =
-      event == WM_EVENT_CYCLE_SNAP_DOCK_LEFT ? DOCKED_ALIGNMENT_LEFT
-                                             : DOCKED_ALIGNMENT_RIGHT;
-  DockedAlignment current_dock_alignment =
-      dock_layout ? dock_layout->CalculateAlignment() : DOCKED_ALIGNMENT_NONE;
-
-  if (!window_state->IsDocked() ||
-      (current_dock_alignment != DOCKED_ALIGNMENT_NONE &&
-       current_dock_alignment != desired_dock_alignment)) {
-    if (window_state->CanSnap() &&
-        window_state->GetStateType() != desired_snap_state &&
-        window_state->window()->GetType() != ui::wm::WINDOW_TYPE_PANEL) {
-      const wm::WMEvent event(desired_snap_state ==
-                                      wm::WINDOW_STATE_TYPE_LEFT_SNAPPED
-                                  ? wm::WM_EVENT_SNAP_LEFT
-                                  : wm::WM_EVENT_SNAP_RIGHT);
-      window_state->OnWMEvent(&event);
-      return;
-    }
-
-    if (dock_layout &&
-        dock_layout->CanDockWindow(window_state->window(),
-                                   desired_dock_alignment)) {
-      if (window_state->IsDocked()) {
-        dock_layout->MaybeSetDesiredDockedAlignment(desired_dock_alignment);
-        return;
-      }
-
-      ScopedDockedLayoutEventSourceResetter event_source_resetter(dock_layout);
-      ScopedPreferredAlignmentResetter alignmentResetter(desired_dock_alignment,
-                                                         dock_layout);
-      const wm::WMEvent event(wm::WM_EVENT_DOCK);
-      window_state->OnWMEvent(&event);
-      return;
-    }
-  }
-
-  if (window_state->IsDocked() || window_state->IsSnapped()) {
-    ScopedDockedLayoutEventSourceResetter event_source_resetter(dock_layout);
-    window_state->Restore();
-    return;
-  }
-  window_state->window()->Animate(::wm::WINDOW_ANIMATION_TYPE_BOUNCE);
-}
-
 }  // namespace
 
 DefaultState::DefaultState(WindowStateType initial_state_type)
     : state_type_(initial_state_type), stored_window_state_(nullptr) {}
 DefaultState::~DefaultState() {}
 
 void DefaultState::OnWMEvent(WindowState* window_state, const WMEvent* event) {
   if (ProcessWorkspaceEvents(window_state, event))
     return;
 
   // Do not change the PINNED window state if this is not unpin event.
   if (window_state->IsTrustedPinned() && event->type() != WM_EVENT_NORMAL)
     return;
 
   if (ProcessCompoundEvents(window_state, event))
     return;
 
   WindowStateType current_state_type = window_state->GetStateType();
   WindowStateType next_state_type = WINDOW_STATE_TYPE_NORMAL;
   switch (event->type()) {
     case WM_EVENT_NORMAL:
-      next_state_type = current_state_type == WINDOW_STATE_TYPE_DOCKED_MINIMIZED
-                            ? WINDOW_STATE_TYPE_DOCKED
-                            : WINDOW_STATE_TYPE_NORMAL;
+      next_state_type = WINDOW_STATE_TYPE_NORMAL;
       break;
     case WM_EVENT_MAXIMIZE:
       next_state_type = WINDOW_STATE_TYPE_MAXIMIZED;
       break;
     case WM_EVENT_MINIMIZE:
-      next_state_type = current_state_type == WINDOW_STATE_TYPE_DOCKED
-                            ? WINDOW_STATE_TYPE_DOCKED_MINIMIZED
-                            : WINDOW_STATE_TYPE_MINIMIZED;
+      next_state_type = WINDOW_STATE_TYPE_MINIMIZED;
       break;
     case WM_EVENT_FULLSCREEN:
       next_state_type = WINDOW_STATE_TYPE_FULLSCREEN;
       break;
     case WM_EVENT_SNAP_LEFT:
       next_state_type = WINDOW_STATE_TYPE_LEFT_SNAPPED;
       break;
     case WM_EVENT_SNAP_RIGHT:
       next_state_type = WINDOW_STATE_TYPE_RIGHT_SNAPPED;
       break;
-    case WM_EVENT_DOCK:
-      next_state_type = WINDOW_STATE_TYPE_DOCKED;
-      break;
     case WM_EVENT_SET_BOUNDS:
       SetBounds(window_state, static_cast<const SetBoundsEvent*>(event));
       return;
     case WM_EVENT_SHOW_INACTIVE:
       next_state_type = WINDOW_STATE_TYPE_INACTIVE;
       break;
     case WM_EVENT_PIN:
     case WM_EVENT_TRUSTED_PIN:
       // If there already is a pinned window, it is not allowed to set it
       // to this window.
       // TODO(hidehiko): If a system modal window is openening, the pinning
       // probably should fail.
       if (WmShell::Get()->IsPinned()) {
         LOG(ERROR) << "An PIN event will be failed since another window is "
                    << "already in pinned mode.";
         next_state_type = current_state_type;
       } else {
         next_state_type = event->type() == WM_EVENT_PIN
                               ? WINDOW_STATE_TYPE_PINNED
                               : WINDOW_STATE_TYPE_TRUSTED_PINNED;
       }
       break;
     case WM_EVENT_TOGGLE_MAXIMIZE_CAPTION:
     case WM_EVENT_TOGGLE_MAXIMIZE:
     case WM_EVENT_TOGGLE_VERTICAL_MAXIMIZE:
     case WM_EVENT_TOGGLE_HORIZONTAL_MAXIMIZE:
     case WM_EVENT_TOGGLE_FULLSCREEN:
-    case WM_EVENT_CYCLE_SNAP_DOCK_LEFT:
-    case WM_EVENT_CYCLE_SNAP_DOCK_RIGHT:
+    case WM_EVENT_CYCLE_SNAP_LEFT:
+    case WM_EVENT_CYCLE_SNAP_RIGHT:
     case WM_EVENT_CENTER:
       NOTREACHED() << "Compound event should not reach here:" << event;
       return;
     case WM_EVENT_ADDED_TO_WORKSPACE:
     case WM_EVENT_WORKAREA_BOUNDS_CHANGED:
     case WM_EVENT_DISPLAY_BOUNDS_CHANGED:
       NOTREACHED() << "Workspace event should not reach here:" << event;
       return;
   }
 
@@ skipping 131 matching lines @@
         }
 
         window_state->SetRestoreBoundsInParent(restore_bounds);
         window->SetBounds(new_bounds);
       }
       return true;
     }
     case WM_EVENT_TOGGLE_FULLSCREEN:
       ToggleFullScreen(window_state, window_state->delegate());
       return true;
-    case WM_EVENT_CYCLE_SNAP_DOCK_LEFT:
-    case WM_EVENT_CYCLE_SNAP_DOCK_RIGHT:
-      if (ash::switches::DockedWindowsEnabled())
-        CycleSnapDock(window_state, event->type());
-      else
-        CycleSnap(window_state, event->type());
+    case WM_EVENT_CYCLE_SNAP_LEFT:
+    case WM_EVENT_CYCLE_SNAP_RIGHT:
+      CycleSnap(window_state, event->type());
       return true;
     case WM_EVENT_CENTER:
       CenterWindow(window_state);
       return true;
     case WM_EVENT_NORMAL:
     case WM_EVENT_MAXIMIZE:
     case WM_EVENT_MINIMIZE:
     case WM_EVENT_FULLSCREEN:
     case WM_EVENT_PIN:
     case WM_EVENT_TRUSTED_PIN:
     case WM_EVENT_SNAP_LEFT:
     case WM_EVENT_SNAP_RIGHT:
     case WM_EVENT_SET_BOUNDS:
     case WM_EVENT_SHOW_INACTIVE:
-    case WM_EVENT_DOCK:
       break;
     case WM_EVENT_ADDED_TO_WORKSPACE:
     case WM_EVENT_WORKAREA_BOUNDS_CHANGED:
     case WM_EVENT_DISPLAY_BOUNDS_CHANGED:
       NOTREACHED() << "Workspace event should not reach here:" << event;
       break;
   }
   return false;
 }
 
@@ skipping 19 matching lines @@
       if (bounds.IsEmpty())
         return true;
 
       // Only windows of type WINDOW_TYPE_NORMAL or WINDOW_TYPE_PANEL need to be
       // adjusted to have minimum visibility, because they are positioned by the
       // user and user should always be able to interact with them. Other
       // windows are positioned programmatically.
       if (!window_state->IsUserPositionable())
         return true;
 
-      // Use entire display instead of workarea because the workarea can
-      // be further shrunk by the docked area. The logic ensures 30%
+      // Use entire display instead of workarea. The logic ensures 30%
       // visibility which should be enough to see where the window gets
       // moved.
       gfx::Rect display_area = GetDisplayBoundsInParent(window);
       int min_width = bounds.width() * wm::kMinimumPercentOnScreenArea;
       int min_height = bounds.height() * wm::kMinimumPercentOnScreenArea;
       wm::AdjustBoundsToEnsureWindowVisibility(display_area, min_width,
                                                min_height, &bounds);
       window_state->AdjustSnappedBounds(&bounds);
       if (window->GetBounds() != bounds)
         window_state->SetBoundsConstrained(bounds);
@@ skipping 39 matching lines @@
       window_state->AdjustSnappedBounds(&bounds);
       if (window_state->window()->GetTargetBounds() != bounds)
         window_state->SetBoundsDirectAnimated(bounds);
       return true;
     }
     case WM_EVENT_TOGGLE_MAXIMIZE_CAPTION:
     case WM_EVENT_TOGGLE_MAXIMIZE:
     case WM_EVENT_TOGGLE_VERTICAL_MAXIMIZE:
     case WM_EVENT_TOGGLE_HORIZONTAL_MAXIMIZE:
     case WM_EVENT_TOGGLE_FULLSCREEN:
-    case WM_EVENT_CYCLE_SNAP_DOCK_LEFT:
-    case WM_EVENT_CYCLE_SNAP_DOCK_RIGHT:
+    case WM_EVENT_CYCLE_SNAP_LEFT:
+    case WM_EVENT_CYCLE_SNAP_RIGHT:
     case WM_EVENT_CENTER:
     case WM_EVENT_NORMAL:
     case WM_EVENT_MAXIMIZE:
     case WM_EVENT_MINIMIZE:
     case WM_EVENT_FULLSCREEN:
     case WM_EVENT_PIN:
     case WM_EVENT_TRUSTED_PIN:
     case WM_EVENT_SNAP_LEFT:
     case WM_EVENT_SNAP_RIGHT:
     case WM_EVENT_SET_BOUNDS:
     case WM_EVENT_SHOW_INACTIVE:
-    case WM_EVENT_DOCK:
       break;
   }
   return false;
 }
 
 // static
 bool DefaultState::SetMaximizedOrFullscreenBounds(WindowState* window_state) {
   DCHECK(!window_state->is_dragged());
   if (window_state->IsMaximized()) {
     window_state->SetBoundsDirect(
         GetMaximizedWindowBoundsInParent(window_state->window()));
     return true;
   }
   if (window_state->IsFullscreen()) {
     window_state->SetBoundsDirect(
         GetDisplayBoundsInParent(window_state->window()));
     return true;
   }
   return false;
 }
 
 // static
 void DefaultState::SetBounds(WindowState* window_state,
                              const SetBoundsEvent* event) {
   if (window_state->is_dragged()) {
-    // TODO(oshima|varkha): This may be no longer needed, as the dragging
-    // happens in docked window container. crbug.com/485612.
+    // TODO(oshima|varkha): Is this still needed? crbug.com/485612.
     window_state->SetBoundsDirect(event->requested_bounds());
   } else if (window_state->IsSnapped()) {
     gfx::Rect work_area_in_parent =
         GetDisplayWorkAreaBoundsInParent(window_state->window());
     gfx::Rect child_bounds(event->requested_bounds());
     wm::AdjustBoundsSmallerThan(work_area_in_parent.size(), &child_bounds);
     window_state->AdjustSnappedBounds(&child_bounds);
     window_state->SetBoundsDirect(child_bounds);
   } else if (!SetMaximizedOrFullscreenBounds(window_state) ||
              window_state->allow_set_bounds_in_maximized()) {
@@ skipping 100 matching lines @@
   WmWindow* window = window_state->window();
   gfx::Rect bounds_in_parent;
   switch (state_type_) {
     case WINDOW_STATE_TYPE_LEFT_SNAPPED:
     case WINDOW_STATE_TYPE_RIGHT_SNAPPED:
       bounds_in_parent =
           state_type_ == WINDOW_STATE_TYPE_LEFT_SNAPPED
               ? GetDefaultLeftSnappedWindowBoundsInParent(window)
               : GetDefaultRightSnappedWindowBoundsInParent(window);
       break;
-    case WINDOW_STATE_TYPE_DOCKED: {
-      // TODO(afakhry): Remove in M58.
-      DCHECK(ash::switches::DockedWindowsEnabled());
-      if (window->GetParent()->GetShellWindowId() !=
-          kShellWindowId_DockedContainer) {
-        WmWindow* docked_container =
-            window->GetRootWindow()->GetChildByShellWindowId(
-                kShellWindowId_DockedContainer);
-        ReparentChildWithTransientChildren(window->aura_window(),
-                                           window->aura_window()->parent(),
-                                           docked_container->aura_window());
-      }
-      // Return early because we don't want to update the bounds of the
-      // window below; as the bounds are managed by the dock layout.
-      return;
-    }
+
     case WINDOW_STATE_TYPE_DEFAULT:
     case WINDOW_STATE_TYPE_NORMAL: {
       gfx::Rect work_area_in_parent = GetDisplayWorkAreaBoundsInParent(window);
       if (window_state->HasRestoreBounds()) {
         bounds_in_parent = window_state->GetRestoreBoundsInParent();
         // Check if the |window|'s restored size is bigger than the working area
         // This may happen if a window was resized to maximized bounds or if the
         // display resolution changed while the window was maximized.
         if (previous_state_type == WINDOW_STATE_TYPE_MAXIMIZED &&
             bounds_in_parent.width() >= work_area_in_parent.width() &&
@@ skipping 18 matching lines @@
     case WINDOW_STATE_TYPE_MAXIMIZED:
       bounds_in_parent = GetMaximizedWindowBoundsInParent(window);
       break;
 
     case WINDOW_STATE_TYPE_FULLSCREEN:
     case WINDOW_STATE_TYPE_PINNED:
     case WINDOW_STATE_TYPE_TRUSTED_PINNED:
       bounds_in_parent = GetDisplayBoundsInParent(window);
       break;
 
-    case WINDOW_STATE_TYPE_DOCKED_MINIMIZED:
     case WINDOW_STATE_TYPE_MINIMIZED:
       break;
     case WINDOW_STATE_TYPE_INACTIVE:
     case WINDOW_STATE_TYPE_END:
     case WINDOW_STATE_TYPE_AUTO_POSITIONED:
       return;
   }
 
   if (!window_state->IsMinimized()) {
     if (IsMinimizedWindowState(previous_state_type) ||
@@ skipping 54 matching lines @@
     gfx::Rect center_in_parent = GetDisplayWorkAreaBoundsInParent(window);
     center_in_parent.ClampToCenteredSize(window->GetBounds().size());
     window_state->SetBoundsDirectAnimated(center_in_parent);
   }
   // Centering window is treated as if a user moved and resized the window.
   window_state->set_bounds_changed_by_user(true);
 }
 
 }  // namespace wm
 }  // namespace ash