Avoids updating dock alignment when drag is cancelled

ash/wm/dock/docked_window_layout_manager.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/screen_ash.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_constants.h"
@@ skipping 446 matching lines @@
 void DockedWindowLayoutManager::StartDragging(aura::Window* window) {
   DCHECK(!dragged_window_);
   dragged_window_ = window;
   DCHECK(!IsPopupOrTransient(window));
   // Start observing a window unless it is docked container's child in which
   // case it is already observed.
   wm::WindowState* dragged_state = wm::GetWindowState(dragged_window_);
   if (dragged_window_->parent() != dock_container_) {
     dragged_window_->AddObserver(this);
     dragged_state->AddObserver(this);
+  } else if (!IsAnyWindowDocked() &&
+             dragged_state->drag_details() &&
+             !(dragged_state->drag_details()->bounds_change &
+                 WindowResizer::kBoundsChange_Resizes)) {
+    // If there are no other docked windows clear alignment when a docked window
+    // is moved (but not when it is resized or the window could get undocked
+    // when resized away from the edge while docked).
+    alignment_ = DOCKED_ALIGNMENT_NONE;
   }
   is_dragged_from_dock_ = window->parent() == dock_container_;
   DCHECK(!is_dragged_window_docked_);
 
   // Resize all windows that are flush with the dock edge together if one of
   // them gets resized.
   if (dragged_window_->bounds().width() == docked_width_ &&
       (dragged_state->drag_details()->bounds_change &
           WindowResizer::kBoundsChange_Resizes) &&
       (dragged_state->drag_details()->size_change_direction &
@@ skipping 34 matching lines @@
   // case it needs to keep being observed after the drag completes.
   if (dragged_window_->parent() != dock_container_) {
     dragged_window_->RemoveObserver(this);
     wm::GetWindowState(dragged_window_)->RemoveObserver(this);
     if (last_active_window_ == dragged_window_)
       last_active_window_ = NULL;
 
     views::corewm::SetWindowShowAnimationDuration(dragged_window_,
                                                   base::TimeDelta());
   } else {
+    // If this is the first window that got docked by a move update alignment.
+    if (alignment_ == DOCKED_ALIGNMENT_NONE) {
+      alignment_ = GetAlignmentOfWindow(dragged_window_);
+      DCHECK(action == DOCKED_ACTION_NONE ||
+             alignment_ != DOCKED_ALIGNMENT_NONE);
+    }
     // A window is no longer dragged and is a child.
     // When a window becomes a child at drag start this is
     // the only opportunity we will have to enforce a window
     // count limit so do it here.
     MaybeMinimizeChildrenExcept(dragged_window_);
 
     views::corewm::SetWindowShowAnimationDuration(dragged_window_,
         base::TimeDelta::FromMilliseconds(kFadeDurationMs));
   }
   dragged_window_ = NULL;
@@ skipping 119 matching lines @@
   // Dragged windows are already observed by StartDragging and do not change
   // docked alignment during the drag.
   if (child == dragged_window_)
     return;
   // If this is the first window getting docked - update alignment.
   // TODO(oshima|varkha): A window can be added without proper bounds when
   // window is moved to another display via API or due to display configuration
   // change, so the the alignment may not be valid.
   if (alignment_ == DOCKED_ALIGNMENT_NONE) {
     alignment_ = GetAlignmentOfWindow(child);
-    DCHECK(alignment_ != DOCKED_ALIGNMENT_NONE);
+    DCHECK_NE(DOCKED_ALIGNMENT_NONE, alignment_);
   }
   MaybeMinimizeChildrenExcept(child);
   child->AddObserver(this);
   wm::GetWindowState(child)->AddObserver(this);
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
   views::corewm::SetWindowShowAnimationDuration(child,
       base::TimeDelta::FromMilliseconds(kFadeDurationMs));
 }
 
@@ skipping 152 matching lines @@
     const gfx::Rect& new_bounds) {
   // Only relayout if the dragged window would get docked.
   if (window == dragged_window_ && is_dragged_window_docked_)
     Relayout();
 }
 
 void DockedWindowLayoutManager::OnWindowDestroying(aura::Window* window) {
   if (dragged_window_ == window) {
     FinishDragging(DOCKED_ACTION_NONE, DOCKED_ACTION_SOURCE_UNKNOWN);
     DCHECK(!dragged_window_);
-    DCHECK (!is_dragged_window_docked_);
+    DCHECK(!is_dragged_window_docked_);
   }
   if (window == last_active_window_)
     last_active_window_ = NULL;
   RecordUmaAction(DOCKED_ACTION_CLOSE, DOCKED_ACTION_SOURCE_UNKNOWN);
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // DockedWindowLayoutManager, aura::client::ActivationChangeObserver
 // implementation:
@@ skipping 134 matching lines @@
 void DockedWindowLayoutManager::UpdateDockedWidth(int width) {
   if (docked_width_ == width)
     return;
   docked_width_ = width;
   UMA_HISTOGRAM_COUNTS_10000("Ash.Dock.Width", docked_width_);
 }
 
 void DockedWindowLayoutManager::OnDraggedWindowDocked(aura::Window* window) {
   DCHECK(!is_dragged_window_docked_);
   is_dragged_window_docked_ = true;
-
-  // If there are no other docked windows update alignment when the window is
-  // moved.
-  if (!IsAnyWindowDocked() &&
-      wm::GetWindowState(dragged_window_)->drag_details() &&
-      !(wm::GetWindowState(dragged_window_)->drag_details()->bounds_change &
-          WindowResizer::kBoundsChange_Resizes)) {
-    alignment_ = DOCKED_ALIGNMENT_NONE;
-  }
 }
 
 void DockedWindowLayoutManager::OnDraggedWindowUndocked() {
-  // If this is the first window getting docked by moving it - update alignment.
-  if (!IsAnyWindowDocked() &&
-      wm::GetWindowState(dragged_window_)->drag_details() &&
-      !(wm::GetWindowState(dragged_window_)->drag_details()->bounds_change &
-          WindowResizer::kBoundsChange_Resizes)) {
-    alignment_ = GetAlignmentOfWindow(dragged_window_);
-  }
   DCHECK (is_dragged_window_docked_);
   is_dragged_window_docked_ = false;
 }
 
 bool DockedWindowLayoutManager::IsAnyWindowDocked() {
   return CalculateAlignment() != DOCKED_ALIGNMENT_NONE;
 }
 
 void DockedWindowLayoutManager::Relayout() {
   if (in_layout_)
@@ skipping 288 matching lines @@
 void DockedWindowLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& keyboard_bounds) {
   // This bounds change will have caused a change to the Shelf which does not
   // propagate automatically to this class, so manually recalculate bounds.
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::KEYBOARD_BOUNDS_CHANGING);
 }
 
 }  // namespace internal
 }  // namespace ash