Remove docked windows entirely in M59.

ash/common/wm/workspace/workspace_window_resizer.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_window_resizer.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 #include <vector>
 
-#include "ash/common/ash_switches.h"
 #include "ash/common/metrics/user_metrics_action.h"
 #include "ash/common/wm/default_window_resizer.h"
-#include "ash/common/wm/dock/docked_window_layout_manager.h"
-#include "ash/common/wm/dock/docked_window_resizer.h"
 #include "ash/common/wm/panels/panel_window_resizer.h"
 #include "ash/common/wm/window_positioning_utils.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_event.h"
 #include "ash/common/wm/wm_screen_util.h"
 #include "ash/common/wm/workspace/phantom_window_controller.h"
 #include "ash/common/wm/workspace/two_step_edge_cycler.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
@@ skipping 33 matching lines @@
   // implement proper transition from one resizer to another during or at the
   // end of the drag. This also causes http://crbug.com/247085.
   // It seems the only thing the panel or dock resizer needs to do is notify the
   // layout manager when a docked window is being dragged. We should have a
   // better way of doing this, perhaps by having a way of observing drags or
   // having a generic drag window wrapper which informs a layout manager that a
   // drag has started or stopped.
   // It may be possible to refactor and eliminate chaining.
   std::unique_ptr<WindowResizer> window_resizer;
 
-  if (!window_state->IsNormalOrSnapped() && !window_state->IsDocked())
+  if (!window_state->IsNormalOrSnapped())
     return std::unique_ptr<WindowResizer>();
 
   int bounds_change =
       WindowResizer::GetBoundsChangeForWindowComponent(window_component);
   if (bounds_change == WindowResizer::kBoundsChangeDirection_None)
     return std::unique_ptr<WindowResizer>();
 
   window_state->CreateDragDetails(point_in_parent, window_component, source);
   const int parent_shell_window_id =
       window->GetParent() ? window->GetParent()->GetShellWindowId() : -1;
   if (window->GetParent() &&
       (parent_shell_window_id == kShellWindowId_DefaultContainer ||
-       parent_shell_window_id == kShellWindowId_DockedContainer ||
        parent_shell_window_id == kShellWindowId_PanelContainer)) {
     window_resizer.reset(
         WorkspaceWindowResizer::Create(window_state, std::vector<WmWindow*>()));
   } else {
     window_resizer.reset(DefaultWindowResizer::Create(window_state));
   }
   window_resizer = window->GetShell()->CreateDragWindowResizer(
       std::move(window_resizer), window_state);
-  if (window->GetType() == ui::wm::WINDOW_TYPE_PANEL)
+  if (window->GetType() == ui::wm::WINDOW_TYPE_PANEL) {
     window_resizer.reset(
         PanelWindowResizer::Create(window_resizer.release(), window_state));
-  if (window_resizer && window->GetParent() && !window->GetTransientParent() &&
-      (parent_shell_window_id == kShellWindowId_DefaultContainer ||
-       parent_shell_window_id == kShellWindowId_DockedContainer ||
-       parent_shell_window_id == kShellWindowId_PanelContainer)) {
-    window_resizer.reset(
-        DockedWindowResizer::Create(window_resizer.release(), window_state));
   }
   return window_resizer;
 }
 
 namespace {
 
 // Snapping distance used instead of WorkspaceWindowResizer::kScreenEdgeInset
 // when resizing a window using touchscreen.
 const int kScreenEdgeInsetForTouchDrag = 32;
 
@@ skipping 271 matching lines @@
       return;
   }
   const bool in_original_root = !root || root == GetTarget()->GetRootWindow();
   // Hide a phantom window for snapping if the cursor is in another root window.
   if (in_original_root) {
     UpdateSnapPhantomWindow(location_in_parent, bounds);
   } else {
     snap_type_ = SNAP_NONE;
     snap_phantom_window_controller_.reset();
     edge_cycler_.reset();
-    SetDraggedWindowDocked(false);
   }
 }
 
 void WorkspaceWindowResizer::CompleteDrag() {
   if (!did_move_or_resize_)
     return;
 
   window_state()->set_bounds_changed_by_user(true);
   snap_phantom_window_controller_.reset();
 
   // If the window's state type changed over the course of the drag do not snap
   // the window. This happens when the user minimizes or maximizes the window
   // using a keyboard shortcut while dragging it.
   if (window_state()->GetStateType() != details().initial_state_type)
     return;
 
   bool snapped = false;
   if (snap_type_ == SNAP_LEFT || snap_type_ == SNAP_RIGHT) {
     if (!window_state()->HasRestoreBounds()) {
       gfx::Rect initial_bounds = GetTarget()->GetParent()->ConvertRectToScreen(
           details().initial_bounds_in_parent);
       window_state()->SetRestoreBoundsInScreen(
           details().restore_bounds.IsEmpty() ? initial_bounds
                                              : details().restore_bounds);
     }
-    if (!dock_layout_->is_dragged_window_docked()) {
-      // TODO(oshima): Add event source type to WMEvent and move
-      // metrics recording inside WindowState::OnWMEvent.
-      const wm::WMEvent event(snap_type_ == SNAP_LEFT
-                                  ? wm::WM_EVENT_SNAP_LEFT
-                                  : wm::WM_EVENT_SNAP_RIGHT);
-      window_state()->OnWMEvent(&event);
-      shell_->RecordUserMetricsAction(snap_type_ == SNAP_LEFT
-                                          ? UMA_DRAG_MAXIMIZE_LEFT
-                                          : UMA_DRAG_MAXIMIZE_RIGHT);
-      snapped = true;
-    }
+    // TODO(oshima): Add event source type to WMEvent and move
+    // metrics recording inside WindowState::OnWMEvent.
+    const wm::WMEvent event(snap_type_ == SNAP_LEFT ? wm::WM_EVENT_SNAP_LEFT
+                                                    : wm::WM_EVENT_SNAP_RIGHT);
+    window_state()->OnWMEvent(&event);
+    shell_->RecordUserMetricsAction(snap_type_ == SNAP_LEFT
+                                        ? UMA_DRAG_MAXIMIZE_LEFT
+                                        : UMA_DRAG_MAXIMIZE_RIGHT);
+    snapped = true;
   }
 
   if (!snapped) {
     if (window_state()->IsSnapped()) {
       // Keep the window snapped if the user resizes the window such that the
       // window has valid bounds for a snapped window. Always unsnap the window
       // if the user dragged the window via the caption area because doing this
       // is slightly less confusing.
       if (details().window_component == HTCAPTION ||
           !AreBoundsValidSnappedBounds(window_state()->GetStateType(),
                                        GetTarget()->GetBounds())) {
         // Set the window to WINDOW_STATE_TYPE_NORMAL but keep the
         // window at the bounds that the user has moved/resized the
         // window to.
         window_state()->SaveCurrentBoundsForRestore();
         window_state()->Restore();
       }
-    } else if (!dock_layout_->is_dragged_window_docked()) {
+    } else {
       // The window was not snapped and is not snapped. This is a user
       // resize/drag and so the current bounds should be maintained, clearing
       // any prior restore bounds. When the window is docked the restore bound
       // must be kept so the docked state can be reverted properly.
       window_state()->ClearRestoreBounds();
     }
   }
 }
 
 void WorkspaceWindowResizer::RevertDrag() {
@@ skipping 45 matching lines @@
       weak_ptr_factory_(this) {
   DCHECK(details().is_resizable);
 
   // A mousemove should still show the cursor even if the window is
   // being moved or resized with touch, so do not lock the cursor.
   if (details().source != aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
     shell_->LockCursor();
     did_lock_cursor_ = true;
   }
 
-  dock_layout_ = DockedWindowLayoutManager::Get(GetTarget());
-
   // Only support attaching to the right/bottom.
   DCHECK(attached_windows_.empty() || (details().window_component == HTRIGHT ||
                                        details().window_component == HTBOTTOM));
 
   // TODO: figure out how to deal with window going off the edge.
 
   // Calculate sizes so that we can maintain the ratios if we need to resize.
   int total_available = 0;
   for (size_t i = 0; i < attached_windows_.size(); ++i) {
     gfx::Size min(attached_windows_[i]->GetMinimumSize());
@@ skipping 343 matching lines @@
 void WorkspaceWindowResizer::UpdateSnapPhantomWindow(const gfx::Point& location,
                                                      const gfx::Rect& bounds) {
   if (!did_move_or_resize_ || details().window_component != HTCAPTION)
     return;
 
   SnapType last_type = snap_type_;
   snap_type_ = GetSnapType(location);
   if (snap_type_ == SNAP_NONE || snap_type_ != last_type) {
     snap_phantom_window_controller_.reset();
     edge_cycler_.reset();
-    if (snap_type_ == SNAP_NONE) {
-      SetDraggedWindowDocked(false);
+    if (snap_type_ == SNAP_NONE)
       return;
-    }
   }
 
   DCHECK(snap_type_ == SNAP_LEFT || snap_type_ == SNAP_RIGHT);
-  DockedAlignment desired_alignment = (snap_type_ == SNAP_LEFT)
-                                          ? DOCKED_ALIGNMENT_LEFT
-                                          : DOCKED_ALIGNMENT_RIGHT;
-  const bool can_dock =
-      ash::switches::DockedWindowsEnabled() &&
-      dock_layout_->CanDockWindow(GetTarget(), desired_alignment) &&
-      dock_layout_->GetAlignmentOfWindow(GetTarget()) != DOCKED_ALIGNMENT_NONE;
-  if (!can_dock) {
-    // If the window cannot be docked, undock the window. This may change the
-    // workspace bounds and hence |snap_type_|.
-    SetDraggedWindowDocked(false);
-    snap_type_ = GetSnapType(location);
-  }
   const bool can_snap = snap_type_ != SNAP_NONE && window_state()->CanSnap();
-  if (!can_snap && !can_dock) {
+  if (!can_snap) {
     snap_type_ = SNAP_NONE;
     snap_phantom_window_controller_.reset();
     edge_cycler_.reset();
     return;
   }
   if (!edge_cycler_) {
     edge_cycler_.reset(new TwoStepEdgeCycler(
         location, snap_type_ == SNAP_LEFT
                       ? TwoStepEdgeCycler::DIRECTION_LEFT
                       : TwoStepEdgeCycler::DIRECTION_RIGHT));
   } else {
     edge_cycler_->OnMove(location);
   }
 
   // Update phantom window with snapped or docked guide bounds.
   // Windows that cannot be snapped or are less wide than kMaxDockWidth can get
   // docked without going through a snapping sequence.
-  gfx::Rect phantom_bounds;
-  const bool should_dock =
-      can_dock && (!can_snap ||
-                   GetTarget()->GetBounds().width() <=
-                       DockedWindowLayoutManager::kMaxDockWidth ||
-                   edge_cycler_->use_second_mode() ||
-                   dock_layout_->is_dragged_window_docked());
-  if (should_dock) {
-    SetDraggedWindowDocked(true);
-    phantom_bounds = GetTarget()->GetParent()->ConvertRectFromScreen(
-        dock_layout_->dragged_bounds());
-  } else {
-    phantom_bounds =
-        (snap_type_ == SNAP_LEFT)
-            ? wm::GetDefaultLeftSnappedWindowBoundsInParent(GetTarget())
-            : wm::GetDefaultRightSnappedWindowBoundsInParent(GetTarget());
-  }
+  gfx::Rect phantom_bounds =

[varkha, 2017/02/28 00:59:02]

Can be const.

[afakhry, 2017/03/09 22:28:27]

Done.

+      (snap_type_ == SNAP_LEFT)
+          ? wm::GetDefaultLeftSnappedWindowBoundsInParent(GetTarget())
+          : wm::GetDefaultRightSnappedWindowBoundsInParent(GetTarget());
 
   if (!snap_phantom_window_controller_) {
     snap_phantom_window_controller_.reset(
         new PhantomWindowController(GetTarget()));
   }
   snap_phantom_window_controller_->Show(
       GetTarget()->GetParent()->ConvertRectToScreen(phantom_bounds));
 }
 
 void WorkspaceWindowResizer::RestackWindows() {
@@ skipping 42 matching lines @@
       inset_right = kScreenEdgeInsetForTouchDrag;
     area.Inset(inset_left, 0, inset_right, 0);
   }
   if (location.x() <= area.x())
     return SNAP_LEFT;
   if (location.x() >= area.right() - 1)
     return SNAP_RIGHT;
   return SNAP_NONE;
 }
 
-void WorkspaceWindowResizer::SetDraggedWindowDocked(bool should_dock) {
-  if (should_dock) {
-    if (!dock_layout_->is_dragged_window_docked()) {
-      window_state()->set_bounds_changed_by_user(false);
-      dock_layout_->DockDraggedWindow(GetTarget());
-    }
-  } else {
-    if (dock_layout_->is_dragged_window_docked()) {
-      dock_layout_->UndockDraggedWindow();
-      window_state()->set_bounds_changed_by_user(true);
-    }
-  }
-}
-
 bool WorkspaceWindowResizer::AreBoundsValidSnappedBounds(
     wm::WindowStateType snapped_type,
     const gfx::Rect& bounds_in_parent) const {
   DCHECK(snapped_type == wm::WINDOW_STATE_TYPE_LEFT_SNAPPED ||
          snapped_type == wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED);
   gfx::Rect snapped_bounds = wm::GetDisplayWorkAreaBoundsInParent(GetTarget());
   if (snapped_type == wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED)
     snapped_bounds.set_x(snapped_bounds.right() - bounds_in_parent.width());
   snapped_bounds.set_width(bounds_in_parent.width());
   return bounds_in_parent == snapped_bounds;
 }
 
 }  // namespace ash