Added restore functionality for maximize full/left/right

ash/wm/workspace/frame_maximize_button.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/workspace/frame_maximize_button.h"
 
 #include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/wm/property_util.h"
@@ skipping 17 matching lines @@
 namespace ash {
 
 namespace {
 
 // Delay before forcing an update of the snap location.
 const int kUpdateDelayMS = 400;
 
 // The delay of the bubble appearance.
 const int kBubbleAppearanceDelayMS = 500;
 
+// The minimum sanp size in percent of the screen width.
+const int kMinSnapSizePercent = 50;
 }
 
 // EscapeEventFilter is installed on the RootWindow to track when the escape key
 // is pressed. We use an EventFilter for this as the FrameMaximizeButton
 // normally does not get focus.
 class FrameMaximizeButton::EscapeEventFilter : public aura::EventFilter {
  public:
   explicit EscapeEventFilter(FrameMaximizeButton* button);
   virtual ~EscapeEventFilter();
 
@@ skipping 157 matching lines @@
 void FrameMaximizeButton::OnMouseEntered(const ui::MouseEvent& event) {
   ImageButton::OnMouseEntered(event);
   if (!maximizer_.get()) {
     DCHECK(GetWidget());
     if (!window_) {
       window_ = frame_->GetWidget()->GetNativeWindow();
       window_->AddObserver(this);
     }
     maximizer_.reset(new MaximizeBubbleController(
         this,
-        frame_->GetWidget()->IsMaximized(),
+        GetMaximizeBubbleFrameState(),
         bubble_appearance_delay_ms_));
   }
 }
 
 void FrameMaximizeButton::OnMouseExited(const ui::MouseEvent& event) {
   ImageButton::OnMouseExited(event);
   // Remove the bubble menu when the button is not pressed and the mouse is not
   // within the bubble.
   if (!is_snap_enabled_ && maximizer_.get()) {
     if (maximizer_->GetBubbleWindow()) {
@@ skipping 71 matching lines @@
 
   return ImageButton::OnGestureEvent(event);
 }
 
 void FrameMaximizeButton::ProcessStartEvent(const ui::LocatedEvent& event) {
   DCHECK(is_snap_enabled_);
   // Prepare the help menu.
   if (!maximizer_.get()) {
     maximizer_.reset(new MaximizeBubbleController(
         this,
-        frame_->GetWidget()->IsMaximized(),
+        GetMaximizeBubbleFrameState(),
         bubble_appearance_delay_ms_));
   } else {
     // If the menu did not show up yet, we delay it even a bit more.
     maximizer_->DelayCreation();
   }
   snap_sizer_.reset(NULL);
   InstallEventFilter();
   snap_type_ = SNAP_NONE;
   press_location_ = event.location();
   exceeded_drag_threshold_ = false;
@@ skipping 108 matching lines @@
   if (maximizer_.get()) {
     phantom_window_->set_phantom_below_window(maximizer_->GetBubbleWindow());
     maximizer_->SetSnapType(snap_type_);
   }
   phantom_window_->Show(
       ScreenBoundsForType(snap_type_, *snap_sizer_.get()), NULL);
 }
 
 SnapType FrameMaximizeButton::SnapTypeForLocation(
     const gfx::Point& location) const {
+  MaximizeBubbleFrameState maximize_type = GetMaximizeBubbleFrameState();
   int delta_x = location.x() - press_location_.x();
   int delta_y = location.y() - press_location_.y();
   if (!views::View::ExceededDragThreshold(delta_x, delta_y))
-    return !frame_->GetWidget()->IsMaximized() ? SNAP_MAXIMIZE : SNAP_RESTORE;
+    return maximize_type != FRAME_STATE_FULL ? SNAP_MAXIMIZE : SNAP_RESTORE;
   else if (delta_x < 0 && delta_y > delta_x && delta_y < -delta_x)
-    return SNAP_LEFT;
+    return maximize_type == FRAME_STATE_SNAP_LEFT ? SNAP_RESTORE : SNAP_LEFT;
   else if (delta_x > 0 && delta_y > -delta_x && delta_y < delta_x)
-    return SNAP_RIGHT;
+    return maximize_type == FRAME_STATE_SNAP_RIGHT ? SNAP_RESTORE : SNAP_RIGHT;
   else if (delta_y > 0)
     return SNAP_MINIMIZE;
-  return !frame_->GetWidget()->IsMaximized() ? SNAP_MAXIMIZE : SNAP_RESTORE;
+  return maximize_type != FRAME_STATE_FULL ? SNAP_MAXIMIZE : SNAP_RESTORE;
 }
 
 gfx::Rect FrameMaximizeButton::ScreenBoundsForType(
     SnapType type,
     const SnapSizer& snap_sizer) const {
   aura::Window* window = frame_->GetWidget()->GetNativeWindow();
   switch (type) {
     case SNAP_LEFT:
     case SNAP_RIGHT:
       return ScreenAsh::ConvertRectToScreen(
           frame_->GetWidget()->GetNativeView()->parent(),
           snap_sizer.target_bounds());
     case SNAP_MAXIMIZE:
       return ScreenAsh::ConvertRectToScreen(
           window->parent(),
           ScreenAsh::GetMaximizedWindowBoundsInParent(window));
     case SNAP_MINIMIZE: {
       Launcher* launcher = Shell::GetInstance()->launcher();
-      gfx::Rect item_rect(launcher->GetScreenBoundsOfItemIconForWindow(window));
+      gfx::Rect item_rect(launcher->GetScreenBoundsOfItemIconForWindow(
+          window));
       if (!item_rect.IsEmpty()) {
         // PhantomWindowController insets slightly, outset it so the phantom
         // doesn't appear inset.
         item_rect.Inset(-8, -8);
         return item_rect;
       }
       return launcher->widget()->GetWindowBoundsInScreen();
     }
     case SNAP_RESTORE: {
       const gfx::Rect* restore = GetRestoreBoundsInScreen(window);
       return restore ?
           *restore : frame_->GetWidget()->GetWindowBoundsInScreen();
     }
     case SNAP_NONE:
       NOTREACHED();
   }
   return gfx::Rect();
 }
 
 gfx::Point FrameMaximizeButton::LocationForSnapSizer(
     const gfx::Point& location) const {
   gfx::Point result(location);
   views::View::ConvertPointToScreen(this, &result);
   return result;
 }
 
 void FrameMaximizeButton::Snap(const SnapSizer& snap_sizer) {
+  views::Widget* widget = frame_->GetWidget();
   switch (snap_type_) {
     case SNAP_LEFT:
-    case SNAP_RIGHT:
-      if (frame_->GetWidget()->IsMaximized()) {
-        ash::SetRestoreBoundsInScreen(frame_->GetWidget()->GetNativeWindow(),
+    case SNAP_RIGHT: {
+      // Get the window coordinates on the screen for restore purposes.
+      gfx::Rect restore = widget->GetNativeWindow()->bounds();
+      if (widget->IsMaximized()) {
+        // In case of maximized we have a restore boundary.
+        DCHECK(ash::GetRestoreBoundsInScreen(widget->GetNativeWindow()));
+        // If it was maximized we need to recover the old restore set.
+        restore = *ash::GetRestoreBoundsInScreen(widget->GetNativeWindow());
+        // Set the restore size we want to restore to.
+        ash::SetRestoreBoundsInScreen(widget->GetNativeWindow(),
                                       ScreenBoundsForType(snap_type_,
                                                           snap_sizer));
-        frame_->GetWidget()->Restore();
+        widget->Restore();
       } else {
-        frame_->GetWidget()->SetBounds(ScreenBoundsForType(snap_type_,
-                                                           snap_sizer));
+        // Others might also have set up a restore rectangle already. If so,
+        // we should not overwrite the restore rectangle.
+        bool restore_set =
+            GetRestoreBoundsInScreen(widget->GetNativeWindow()) != NULL;
+        widget->SetBounds(ScreenBoundsForType(snap_type_, snap_sizer));
+        if (restore_set)
+          break;
+      }
+      // Remember the widow's bounds for restoration.
+      ash::SetRestoreBoundsInScreen(widget->GetNativeWindow(), restore);
       }
       break;
     case SNAP_MAXIMIZE:
-      frame_->GetWidget()->Maximize();
+      widget->Maximize();
       break;
     case SNAP_MINIMIZE:
-      frame_->GetWidget()->Minimize();
+      widget->Minimize();
       break;
     case SNAP_RESTORE:
-      frame_->GetWidget()->Restore();
+      widget->Restore();
       break;
     case SNAP_NONE:
       NOTREACHED();
   }
 }
 
+MaximizeBubbleFrameState
+   FrameMaximizeButton::GetMaximizeBubbleFrameState() const {
+  // When there are no restore bounds, we are in normal mode.
+  if (!ash::GetRestoreBoundsInScreen(
+           frame_->GetWidget()->GetNativeWindow()))
+    return FRAME_STATE_NONE;
+  // The normal maximized test can be used.
+  if (frame_->GetWidget()->IsMaximized())
+    return FRAME_STATE_FULL;
+  // For Left/right maximize we need to check the dimensions.
+  gfx::Rect bounds = frame_->GetWidget()->GetWindowBoundsInScreen();
+  gfx::Rect screen = gfx::Screen::GetDisplayMatching(bounds).work_area();
+  if (bounds.width() < (screen.width() * kMinSnapSizePercent) / 100)
+    return FRAME_STATE_NONE;
+  // We have to be in a maximize mode at this point.
+  DCHECK(bounds.y() == screen.y());
+  DCHECK(bounds.height() >= screen.height());
+  if (bounds.x() == screen.x())
+    return FRAME_STATE_SNAP_LEFT;
+  if (bounds.right() == screen.right())
+    return FRAME_STATE_SNAP_RIGHT;
+  // If we come here, it is likely caused by the fact that the
+  // "VerticalResizeDoubleClick" stored a restore rectangle. In that case
+  // we allow all maximize operations (and keep the restore rectangle).
+  return FRAME_STATE_NONE;
+}
+
 }  // namespace ash