GTK Panels - fix crash when clicking on titlebar to restore a panel.

chrome/browser/ui/panels/panel_drag_gtk.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 "chrome/browser/ui/panels/panel_drag_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 
 #include "chrome/browser/ui/panels/panel.h"
 #include "chrome/browser/ui/panels/panel_constants.h"
@@ skipping 130 matching lines @@
   DCHECK(!drag_delegate_);
   DCHECK(!initial_mouse_down_);
   DCHECK(!click_handler_);
 }
 
 void PanelDragGtk::InitialWindowEdgeMousePress(GdkEventButton* event,
                                                GdkCursor* cursor,
                                                GdkWindowEdge& edge) {
   AssertCleanState();
   drag_delegate_ = new ResizeDragDelegate(panel_, edge);
+  drag_state_ = DRAG_CAN_START;
   GrabPointerAndKeyboard(event, cursor);
 }
 
 void PanelDragGtk::InitialTitlebarMousePress(GdkEventButton* event,
                                              GtkWidget* titlebar_widget) {
   AssertCleanState();
   click_handler_ = titlebar_widget;
   drag_delegate_ = new MoveDragDelegate(panel_);
+  drag_state_ = DRAG_CAN_START;
   GrabPointerAndKeyboard(event, gfx::GetCursor(GDK_FLEUR));  // Drag cursor.
 }
 
 void PanelDragGtk::GrabPointerAndKeyboard(GdkEventButton* event,
                                           GdkCursor* cursor) {
   // Remember initial mouse event for use in determining when drag
   // threshold has been exceeded.
   initial_mouse_down_ = gdk_event_copy(reinterpret_cast<GdkEvent*>(event));
 
   // Grab pointer and keyboard to make sure we have the focus and get
@@ skipping 12 matching lines @@
   GdkGrabStatus keyboard_grab_status =
       gdk_keyboard_grab(gdk_window, TRUE, event->time);
   if (pointer_grab_status != GDK_GRAB_SUCCESS ||
       keyboard_grab_status != GDK_GRAB_SUCCESS) {
     // Grab could fail if someone else already has the pointer/keyboard
     // grabbed. Cancel the drag.
     DLOG(ERROR) << "Unable to grab pointer or keyboard (pointer_status="
                 << pointer_grab_status << ", keyboard_status="
                 << keyboard_grab_status << ")";
     EndDrag(true);
+    ReleasePointerAndKeyboardGrab();
     return;
   }
 
   gtk_grab_add(drag_widget_);
 }
 
 void PanelDragGtk::ReleasePointerAndKeyboardGrab() {
+  DCHECK(!drag_delegate_);
   if (drag_state_ == NOT_DRAGGING)
     return;
 
   DCHECK_EQ(DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE, drag_state_);
   gdk_pointer_ungrab(GDK_CURRENT_TIME);
   gdk_keyboard_ungrab(GDK_CURRENT_TIME);
   gtk_grab_remove(drag_widget_);
   drag_state_ = NOT_DRAGGING;  // Drag is truly over now.
 }
 
 void PanelDragGtk::EndDrag(bool canceled) {
+  if (drag_state_ == NOT_DRAGGING ||
+      drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE) {
+    DCHECK(!drag_delegate_);
+    return;
+  }
+
+  DCHECK(drag_delegate_);
+
   if (initial_mouse_down_) {
     gdk_event_free(initial_mouse_down_);
     initial_mouse_down_ = NULL;
   }
 
-  if (drag_delegate_) {
-    if (drag_state_ == DRAG_IN_PROGRESS) {
-      drag_delegate_->DragEnded(canceled);
-      drag_state_ = DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE;
-    }
+  if (drag_state_ == DRAG_IN_PROGRESS) {
+    drag_delegate_->DragEnded(canceled);
+  }
+  drag_state_ = DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE;
 
-    delete drag_delegate_;
-    drag_delegate_ = NULL;
-  }
+  delete drag_delegate_;
+  drag_delegate_ = NULL;
 
   click_handler_ = NULL;
 }
 
 gboolean PanelDragGtk::OnMouseMoveEvent(GtkWidget* widget,
                                         GdkEventMotion* event) {
-  DCHECK(drag_delegate_ || drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE);
-  if (!drag_delegate_)
+  DCHECK(drag_state_ != NOT_DRAGGING);
+
+  if (drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE) {
+    DCHECK(!drag_delegate_);
     return TRUE;
+  }
+
+  DCHECK(drag_delegate_);
 
   gdouble new_x_double;
   gdouble new_y_double;
   gdk_event_get_root_coords(reinterpret_cast<GdkEvent*>(event),
                             &new_x_double, &new_y_double);
   gint new_x = static_cast<gint>(new_x_double);
   gint new_y = static_cast<gint>(new_y_double);
 
   // Begin dragging only after mouse has moved beyond the drag threshold.
-  if (drag_state_ == NOT_DRAGGING) {
+  if (drag_state_ == DRAG_CAN_START) {
     DCHECK(initial_mouse_down_);
     gdouble old_x_double;
     gdouble old_y_double;
     gdk_event_get_root_coords(initial_mouse_down_,
                               &old_x_double, &old_y_double);
     gint old_x = static_cast<gint>(old_x_double);
     gint old_y = static_cast<gint>(old_y_double);
 
     if (gtk_drag_check_threshold(drag_widget_, old_x, old_y,
                                  new_x, new_y)) {
       drag_state_ = DRAG_IN_PROGRESS;
       drag_delegate_->DragStarted(gfx::Point(old_x, old_y));
       gdk_event_free(initial_mouse_down_);
       initial_mouse_down_ = NULL;
     }
   }
 
   if (drag_state_ == DRAG_IN_PROGRESS)
     drag_delegate_->Dragged(gfx::Point(new_x, new_y));
 
   return TRUE;
 }
 
 gboolean PanelDragGtk::OnButtonPressEvent(GtkWidget* widget,
                                           GdkEventButton* event) {
-  DCHECK(drag_delegate_ || drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE);
+  DCHECK(drag_state_ != NOT_DRAGGING);
   return TRUE;
 }
 
 gboolean PanelDragGtk::OnButtonReleaseEvent(GtkWidget* widget,
                                             GdkEventButton* event) {
-  DCHECK(drag_delegate_ || drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE);
+  DCHECK(drag_state_ != NOT_DRAGGING);
+
   if (event->button == 1) {
-    // There will be no drag delegate if drag was canceled/ended using
-    // the keyboard before the mouse was released.
-    if (drag_delegate_) {
-      // Treat release as a mouse click if drag was never started.
-      if (drag_state_ == NOT_DRAGGING && click_handler_) {
-        gtk_propagate_event(click_handler_,
-                            reinterpret_cast<GdkEvent*>(event));
-      }
-      //  Cleanup state regardless.
-      EndDrag(false);
+    // Treat release as a mouse click if drag was never started.
+    if (drag_state_ == DRAG_CAN_START && click_handler_) {
+      gtk_propagate_event(click_handler_,
+                          reinterpret_cast<GdkEvent*>(event));
     }
+    // Cleanup state regardless.
+    EndDrag(false);
     ReleasePointerAndKeyboardGrab();
   }
 
   return TRUE;
 }
 
 gboolean PanelDragGtk::OnKeyPressEvent(GtkWidget* widget,
                                        GdkEventKey* event) {
-  DCHECK(drag_delegate_ || drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE);
+  DCHECK(drag_state_ != NOT_DRAGGING);
   return TRUE;
 }
 
 gboolean PanelDragGtk::OnKeyReleaseEvent(GtkWidget* widget,
                                          GdkEventKey* event) {
-  DCHECK(drag_delegate_ || drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE);
-  if (!drag_delegate_)
+  DCHECK(drag_state_ != NOT_DRAGGING);
+
+  if (drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE) {
+    DCHECK(!drag_delegate_);
     return TRUE;
+  }
+
+  DCHECK(drag_delegate_);
 
   switch (event->keyval) {
   case GDK_Escape:
     EndDrag(true);  // Cancel drag.
     break;
   case GDK_Return:
   case GDK_KP_Enter:
   case GDK_ISO_Enter:
   case GDK_space:
     EndDrag(false);  // Normal end.
     break;
   }
   return TRUE;
 }
 
 gboolean PanelDragGtk::OnGrabBrokenEvent(GtkWidget* widget,
                                          GdkEventGrabBroken* event) {
-  DCHECK(drag_delegate_ || drag_state_ == DRAG_ENDED_WAITING_FOR_MOUSE_RELEASE);
+  DCHECK(drag_state_ != NOT_DRAGGING);
   EndDrag(true);  // Cancel drag.
   ReleasePointerAndKeyboardGrab();
   return TRUE;
 }