Fix crash which occurs when a widget destroys itself as a result of ET_GESTURE_TAP_DOWN

ash/wm/caption_buttons/frame_maximize_button.cc

 // Copyright 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/caption_buttons/frame_maximize_button.h"
 
 #include "ash/metrics/user_metrics_recorder.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
@@ skipping 20 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;
-}
+}  // namespace
 
 // 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 ui::EventHandler {
  public:
   explicit EscapeEventFilter(FrameMaximizeButton* button);
   virtual ~EscapeEventFilter();
 
   // EventFilter overrides:
@@ skipping 88 matching lines @@
     default:
       // We should not come here.
       NOTREACHED();
   }
   // Note: There is no hover with touch - we can therefore pass false for touch
   // operations.
   UpdateSnap(location, true, false);
 }
 
 void FrameMaximizeButton::ExecuteSnapAndCloseMenu(SnapType snap_type) {
-  // We can come here with no snap type set in case that the mouse opened the
-  // maximize button and a touch event "touched" a button.
-  if (snap_type_ == SNAP_NONE)
+  if (snap_type_ != snap_type) {
+    // This occurs if mouse hover opened the maximize bubble and a user
+    // "touched" one of the maximize bubble's buttons.
     SnapButtonHovered(snap_type);
+  }
 
   Cancel(true);
   // Tell our menu to close.
   maximizer_.reset();
   snap_type_ = snap_type;
   // 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());
 }
@@ skipping 18 matching lines @@
 void FrameMaximizeButton::OnWindowPropertyChanged(aura::Window* window,
                                                   const void* key,
                                                   intptr_t old) {
   Cancel(false);
 }
 
 void FrameMaximizeButton::OnWindowDestroying(aura::Window* window) {
   maximizer_.reset();
   if (observing_frame_) {
     CHECK_EQ(frame_->GetNativeWindow(), window);
-    frame_->GetNativeWindow()->RemoveObserver(this);
+    window->RemoveObserver(this);
+    wm::GetWindowState(window)->RemoveObserver(this);
     frame_->RemoveObserver(this);
     observing_frame_ = false;
   }
 }
 
+void FrameMaximizeButton::OnPostWindowShowTypeChange(
+    wm::WindowState* window_state,
+    wm::WindowShowType old_type) {
+  Cancel(false);
+}
+
 void FrameMaximizeButton::OnWidgetActivationChanged(views::Widget* widget,
                                                     bool active) {
   // Upon losing focus, the bubble menu and the phantom window should hide.
   if (!active)
     Cancel(false);
 }
 
 bool FrameMaximizeButton::OnMousePressed(const ui::MouseEvent& event) {
   // If we are already in a mouse click / drag operation, a second button down
   // call will cancel (this addresses crbug.com/143755).
   if (is_snap_enabled_) {
     Cancel(false);
   } else {
     is_snap_enabled_ = event.IsOnlyLeftMouseButton();
     if (is_snap_enabled_)
       ProcessStartEvent(event);
   }
   FrameCaptionButton::OnMousePressed(event);
   return true;
 }
 
 void FrameMaximizeButton::OnMouseEntered(const ui::MouseEvent& event) {
   FrameCaptionButton::OnMouseEntered(event);
   if (!maximizer_) {
     DCHECK(GetWidget());
     if (!observing_frame_) {
       observing_frame_ = true;
-      frame_->GetNativeWindow()->AddObserver(this);
+      aura::Window* window = frame_->GetNativeWindow();
+      window->AddObserver(this);
+      wm::GetWindowState(window)->AddObserver(this);
       frame_->AddObserver(this);
     }
     maximizer_.reset(new MaximizeBubbleController(
         this,
         GetMaximizeBubbleFrameState(),
         bubble_appearance_delay_ms_));
   }
 }
 
 void FrameMaximizeButton::OnMouseExited(const ui::MouseEvent& event) {
@@ skipping 313 matching lines @@
       break;
     case SNAP_NONE:
       NOTREACHED();
   }
 }
 
 MaximizeBubbleFrameState
 FrameMaximizeButton::GetMaximizeBubbleFrameState() const {
   wm::WindowState* window_state =
       wm::GetWindowState(frame_->GetNativeWindow());
-  // When there are no restore bounds, we are in normal mode.
-  if (!window_state->HasRestoreBounds())
-    return FRAME_STATE_NONE;
-  // The normal maximized test can be used.
-  if (frame_->IsMaximized())
-    return FRAME_STATE_FULL;
-  // For Left/right maximize we need to check the dimensions.
-  gfx::Rect bounds = frame_->GetWindowBoundsInScreen();
-  gfx::Rect screen = Shell::GetScreen()->GetDisplayNearestWindow(
-      frame_->GetNativeView()).work_area();
-  if (bounds.width() < (screen.width() * kMinSnapSizePercent) / 100)
-    return FRAME_STATE_NONE;
-  // We might still have a horizontally filled window at this point which we
-  // treat as no special state.
-  if (bounds.y() != screen.y() || bounds.height() != screen.height())
-    return FRAME_STATE_NONE;
-
-  // We have to be in a maximize mode at this point.
-  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).
+  switch (window_state->window_show_type()) {
+    case wm::SHOW_TYPE_MAXIMIZED:
+    case wm::SHOW_TYPE_FULLSCREEN:
+      return FRAME_STATE_FULL;
+    case wm::SHOW_TYPE_LEFT_SNAPPED:
+      return FRAME_STATE_SNAP_LEFT;
+    case wm::SHOW_TYPE_RIGHT_SNAPPED:
+      return FRAME_STATE_SNAP_RIGHT;
+    case wm::SHOW_TYPE_DEFAULT:
+    case wm::SHOW_TYPE_NORMAL:
+    case wm::SHOW_TYPE_MINIMIZED:
+    case wm::SHOW_TYPE_INACTIVE:
+    case wm::SHOW_TYPE_DETACHED:
+    case wm::SHOW_TYPE_END:
+    case wm::SHOW_TYPE_AUTO_POSITIONED:
+      return FRAME_STATE_NONE;
+  }
   return FRAME_STATE_NONE;
 }
 
 }  // namespace ash