Adding proper dragging behavior for L/R maximized windows.

ash/wm/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/wm/window_resizer.h"
 
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
+#include "ash/wm/property_util.h"
+#include "ash/wm/window_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/screen.h"
 
 namespace ash {
@@ skipping 74 matching lines @@
 
 // static
 const int WindowResizer::kBoundsChangeDirection_None = 0;
 // static
 const int WindowResizer::kBoundsChangeDirection_Horizontal = 1;
 // static
 const int WindowResizer::kBoundsChangeDirection_Vertical = 2;
 
 WindowResizer::Details::Details()
     : window(NULL),
+      restore_bounds(gfx::Rect()),
       window_component(HTNOWHERE),
       bounds_change(0),
       position_change_direction(0),
       size_change_direction(0),
       is_resizable(false) {
 }
 
 WindowResizer::Details::Details(aura::Window* window,
                                 const gfx::Point& location,
                                 int window_component)
   : window(window),
     initial_bounds(window->bounds()),
+    restore_bounds(gfx::Rect()),
     initial_location_in_parent(location),
     initial_opacity(window->layer()->opacity()),
     window_component(window_component),
     bounds_change(GetBoundsChangeForWindowComponent(window_component)),
     position_change_direction(
         GetPositionChangeDirectionForWindowComponent(window_component)),
     size_change_direction(
         GetSizeChangeDirectionForWindowComponent(window_component)),
     is_resizable(bounds_change != kBoundsChangeDirection_None) {
+  if (wm::IsWindowNormal(window) &&
+      GetRestoreBoundsInScreen(window) &&
+      window_component == HTCAPTION)
+    restore_bounds = *GetRestoreBoundsInScreen(window);
 }
 
 WindowResizer::Details::~Details() {
 }
 
 WindowResizer::WindowResizer() {
 }
 
 WindowResizer::~WindowResizer() {
 }
@@ skipping 126 matching lines @@
                                         int grid_size) {
   gfx::Size size = details.initial_bounds.size();
   if (details.bounds_change & kBoundsChange_Resizes) {
     gfx::Size min_size = details.window->delegate()->GetMinimumSize();
     min_size.set_width(AlignToGridRoundUp(min_size.width(), grid_size));
     min_size.set_height(AlignToGridRoundUp(min_size.height(), grid_size));
     size.SetSize(GetWidthForDrag(details, min_size.width(), delta_x,
                                  grid_size),
                  GetHeightForDrag(details, min_size.height(), delta_y,
                                   grid_size));
+  } else {
+    if (!details.restore_bounds.IsEmpty())
+      size = details.restore_bounds.size();

[sky, 2012/09/06 19:45:11]

You may need to adjust the origin too. Consider the following: create a smallish
window, say 100x100, snap it to the left. Say it ends up with a width of 1024.
If you start dragging close the right, say 1000, the dragged window is going to
snap back to 100x100 and the window is no longer going to be under the mouse.

[Mr4D (OOO till 08-26), 2012/09/06 23:16:13]

I was first tempted to say that this was taken care off, but then realized that
you are right... Addressed.

   }
   return size;
 }
 
 // static
 int WindowResizer::GetWidthForDrag(const Details& details,
                                    int min_width,
                                    int* delta_x,
                                    int grid_size) {
   int width = details.initial_bounds.width();
@@ skipping 53 matching lines @@
         gfx::Screen::GetDisplayNearestWindow(details.window).bounds().height();
     if (height > max_height) {
       height = max_height;
       *delta_y = -y_multiplier * (details.initial_bounds.height() - max_height);
     }
   }
   return height;
 }
 
 }  // namespace aura