Fixing many problems around the maximize bubble

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 95 matching lines @@
       frame_(frame),
       is_snap_enabled_(false),
       exceeded_drag_threshold_(false),
       window_(NULL),
       snap_type_(SNAP_NONE) {
   // TODO(sky): nuke this. It's temporary while we don't have good images.
   SetImageAlignment(ALIGN_LEFT, ALIGN_BOTTOM);
 }
 
 FrameMaximizeButton::~FrameMaximizeButton() {
+  // Before the window gets destroyed, the maximizer dialog needs to be shut
+  // down since it would otherwise call into a deleted object.
+  maximizer_.reset();
   if (window_)
     OnWindowDestroying(window_);
 }
 
 void FrameMaximizeButton::SnapButtonHovered(SnapType type) {
   // Make sure to only show hover operations when no button is pressed and
   // a similar snap operation in progress does not get re-applied.
   if (is_snap_enabled_ || (type == snap_type_ && snap_sizer_.get()))
     return;
   // Prime the mouse location with the center of the (local) button.
@@ skipping 18 matching lines @@
       return;
     default:
       // We should not come here.
       NOTREACHED();
   }
   UpdateSnap(location);
 }
 
 void FrameMaximizeButton::ExecuteSnapAndCloseMenu(SnapType snap_type) {
   DCHECK_NE(snap_type_, SNAP_NONE);
+  Cancel(true);
+  // Tell our menu to close.
+  maximizer_.reset();
   snap_type_ = snap_type;
-  Snap();
-  // Remove any pending snap previews.
-  SnapButtonHovered(SNAP_NONE);
-  // At this point the operation has been performed and the menu should be
-  // closed - if not, it'll get now closed.
-  maximizer_.reset();
+  // Since Snap might destroy |this|, but the snap_sizer needs to be destroyed,
+  // The ownership of the snap_sizer is taken now.
+  scoped_ptr<SnapSizer> snap_sizer(snap_sizer_.release());
+  Snap(snap_sizer.get());
 }
 
 void FrameMaximizeButton::DestroyMaximizeMenu() {
   maximizer_.reset();
 }
 
 void FrameMaximizeButton::OnWindowBoundsChanged(
     aura::Window* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
@@ skipping 143 matching lines @@
   maximizer_.reset();
 
   if (!should_snap || snap_type_ == SNAP_NONE)
     return false;
 
   SetState(BS_NORMAL);
   // SetState will not call SchedulePaint() if state was already set to
   // BS_NORMAL during a drag.
   SchedulePaint();
   phantom_window_.reset();
-  Snap();
+  // Since Snap might destroy |this|, but the snap_sizer needs to be destroyed,
+  // The ownership of the snap_sizer is taken now.
+  scoped_ptr<SnapSizer> snap_sizer(snap_sizer_.release());
+  Snap(snap_sizer.get());
   return true;
 }
 
 void FrameMaximizeButton::Cancel(bool keep_menu_open) {
   if (!keep_menu_open) {
     maximizer_.reset();
     UninstallEventFilter();
     is_snap_enabled_ = false;
+    snap_sizer_.reset();
   }
   phantom_window_.reset();
-  snap_sizer_.reset();
   snap_type_ = SNAP_NONE;
   update_timer_.Stop();
   SchedulePaint();
 }
 
 void FrameMaximizeButton::InstallEventFilter() {
   if (escape_event_filter_.get())
     return;
 
   escape_event_filter_.reset(new EscapeEventFilter(this));
@@ skipping 41 matching lines @@
                                     snap_edge, grid_size));
   }
   if (!phantom_window_.get()) {
     phantom_window_.reset(new internal::PhantomWindowController(
                               frame_->GetWidget()->GetNativeWindow()));
   }
   if (maximizer_.get()) {
     phantom_window_->set_phantom_below_window(maximizer_->GetBubbleWindow());
     maximizer_->SetSnapType(snap_type_);
   }
-  phantom_window_->Show(ScreenBoundsForType(snap_type_));
+  phantom_window_->Show(ScreenBoundsForType(snap_type_, snap_sizer_.get()));
 }
 
 SnapType FrameMaximizeButton::SnapTypeForLocation(
     const gfx::Point& location) const {
   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;
   else if (delta_x < 0 && delta_y > delta_x && delta_y < -delta_x)
     return SNAP_LEFT;
   else if (delta_x > 0 && delta_y > -delta_x && delta_y < delta_x)
     return SNAP_RIGHT;
   else if (delta_y > 0)
     return SNAP_MINIMIZE;
   return !frame_->GetWidget()->IsMaximized() ? SNAP_MAXIMIZE : SNAP_RESTORE;
 }
 
-gfx::Rect FrameMaximizeButton::ScreenBoundsForType(SnapType type) const {
+gfx::Rect FrameMaximizeButton::ScreenBoundsForType(
+    SnapType type,
+    SnapSizer* snap_sizer) const {
   aura::Window* window = frame_->GetWidget()->GetNativeWindow();
   switch (type) {
     case SNAP_LEFT:
     case SNAP_RIGHT:
+      DCHECK(snap_sizer);
       return ScreenAsh::ConvertRectToScreen(
           frame_->GetWidget()->GetNativeView()->parent(),
-          snap_sizer_->target_bounds());
+          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));
       if (!item_rect.IsEmpty()) {
         // PhantomWindowController insets slightly, outset it so the phantom
         // doesn't appear inset.
@@ skipping 13 matching lines @@
   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() {
+void FrameMaximizeButton::Snap(SnapSizer* snap_sizer) {
   switch (snap_type_) {
     case SNAP_LEFT:
     case SNAP_RIGHT:
+      DCHECK(snap_sizer);
       if (frame_->GetWidget()->IsMaximized()) {
         ash::SetRestoreBoundsInScreen(frame_->GetWidget()->GetNativeWindow(),
-                                      ScreenBoundsForType(snap_type_));
+                                      ScreenBoundsForType(snap_type_,
+                                                          snap_sizer));
         frame_->GetWidget()->Restore();
       } else {
-        frame_->GetWidget()->SetBounds(ScreenBoundsForType(snap_type_));
+        frame_->GetWidget()->SetBounds(ScreenBoundsForType(snap_type_,
+                                                           snap_sizer));
       }
       break;
     case SNAP_MAXIMIZE:
       frame_->GetWidget()->Maximize();
       break;
     case SNAP_MINIMIZE:
       frame_->GetWidget()->Minimize();
       break;
     case SNAP_RESTORE:
       frame_->GetWidget()->Restore();
       break;
     case SNAP_NONE:
       NOTREACHED();
   }
 }
 
 }  // namespace ash