Revert 251206 "Fixes crashes wrt to the maximize button when:"

trunk/src/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;
 
-}  // namespace
+// 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 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) {
-  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.
+  // 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)
     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);
-    window->RemoveObserver(this);
-    wm::GetWindowState(window)->RemoveObserver(this);
+    frame_->GetNativeWindow()->RemoveObserver(this);
     frame_->RemoveObserver(this);
     observing_frame_ = false;
   }
 }
 
-void FrameMaximizeButton::OnWindowShowTypeChanged(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;
-      aura::Window* window = frame_->GetNativeWindow();
-      window->AddObserver(this);
-      wm::GetWindowState(window)->AddObserver(this);
+      frame_->GetNativeWindow()->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());
-  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;
-  }
+  // 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).
   return FRAME_STATE_NONE;
 }
 
 }  // namespace ash