Consolidate into a single shutdown path.

chrome/browser/gtk/browser_window_gtk.cc

 // Copyright (c) 2009 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/gtk/browser_window_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 
 #include "base/base_paths_linux.h"
 #include "base/logging.h"
@@ skipping 49 matching lines @@
   browser_win->OnBoundsChanged(bounds);
   return FALSE;
 }
 
 gboolean MainWindowStateChanged(GtkWindow* window, GdkEventWindowState* event,
                                 BrowserWindowGtk* browser_win) {
   browser_win->OnStateChanged(event->new_window_state);
   return FALSE;
 }
 
+// Callback for the delete event.  This event is fired when the user tries to
+// close the window (e.g., clicking on the X in the window manager title bar).
+gboolean MainWindowDeleteEvent(GtkWidget* widget, GdkEvent* event,
+                               BrowserWindowGtk* window) {
+  window->Close();
+
+  // Return true to prevent the gtk window from being destroyed.  Close will
+  // destroy it for us.
+  return TRUE;
+}
+
+void MainWindowDestroy(GtkWidget* widget, BrowserWindowGtk* window) {
+  // BUG 8712. When we gtk_widget_destroy() in Close(), this will emit the
+  // signal right away, and we will be here (while Close() is still in the
+  // call stack).  In order to not reenter Close(), and to also follow the
+  // expectations of BrowserList, we should run the BrowserWindowGtk destructor
+  // not now, but after the run loop goes back to process messages.  Otherwise
+  // we will remove ourself from BrowserList while it's being iterated.
+  // Additionally, now that we know the window is gone, we need to make sure to
+  // set window_ to NULL, otherwise we will try to close the window again when
+  // we call Close() in the destructor.
+  MessageLoop::current()->DeleteSoon(FROM_HERE, window);
+}
+
 // Using gtk_window_get_position/size creates a race condition, so only use
 // this to get the initial bounds.  After window creation, we pick up the
 // normal bounds by connecting to the configure-event signal.
 gfx::Rect GetInitialWindowBounds(GtkWindow* window) {
   gint x, y, width, height;
   gtk_window_get_position(window, &x, &y);
   gtk_window_get_size(window, &width, &height);
   return gfx::Rect(x, y, width, height);
 }
 
@@ skipping 28 matching lines @@
 }  // namespace
 
 // TODO(estade): Break up this constructor into helper functions to improve
 // readability.
 BrowserWindowGtk::BrowserWindowGtk(Browser* browser)
     :  browser_(browser),
        // TODO(port): make this a pref.
        custom_frame_(false) {
   window_ = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
   gtk_window_set_default_size(window_, 640, 480);
+  g_signal_connect(window_, "delete-event",
+                   G_CALLBACK(MainWindowDeleteEvent), this);
   g_signal_connect(window_, "destroy",
-                   G_CALLBACK(OnWindowDestroyed), this);
+                   G_CALLBACK(MainWindowDestroy), this);
   g_signal_connect(window_, "configure-event",
                    G_CALLBACK(MainWindowConfigured), this);
   g_signal_connect(window_, "window-state-event",
                    G_CALLBACK(MainWindowStateChanged), this);
   g_signal_connect(window_, "key-press-event",
                    G_CALLBACK(OnKeyPress), NULL);
   ConnectAccelerators();
   bounds_ = GetInitialWindowBounds(window_);
 
   GdkPixbuf* images[9] = {
@@ skipping 37 matching lines @@
 
   status_bubble_.reset(new StatusBubbleGtk(window_));
 
   gtk_container_add(GTK_CONTAINER(window_), vbox_);
   gtk_widget_show(vbox_);
   browser_->tabstrip_model()->AddObserver(this);
 }
 
 BrowserWindowGtk::~BrowserWindowGtk() {
   browser_->tabstrip_model()->RemoveObserver(this);
-
-  Close();
 }
 
 gboolean BrowserWindowGtk::OnContentAreaExpose(GtkWidget* widget,
                                                GdkEventExpose* e,
                                                BrowserWindowGtk* window) {
   if (window->custom_frame_) {
     NOTIMPLEMENTED() << " needs custom drawing for the custom frame.";
     return FALSE;
   }
 
@@ skipping 33 matching lines @@
   gint x = static_cast<gint>(bounds.x());
   gint y = static_cast<gint>(bounds.y());
   gint width = static_cast<gint>(bounds.width());
   gint height = static_cast<gint>(bounds.height());
 
   gtk_window_move(window_, x, y);
   gtk_window_resize(window_, width, height);
 }
 
 void BrowserWindowGtk::Close() {
+  // TODO(tc): There's a lot missing here that's in the windows shutdown code
+  // path.  This method should try to close (see BrowserView::CanClose),
+  // although it may not succeed (e.g., if the page has an unload handler).
+  // Currently we just go ahead and close.
+
   // TODO(tc): Once the tab strip model is hooked up, this call can be removed.
   // It should get called by TabDetachedAt when the window is being closed, but
   // we don't have a TabStripModel yet.
   find_bar_controller_->ChangeWebContents(NULL);
 
-  if (!window_)
-    return;
-
   GtkWidget* window = GTK_WIDGET(window_);
   // To help catch bugs in any event handlers that might get fired during the
   // destruction, set window_ to NULL before any handlers will run.
   window_ = NULL;
   gtk_widget_destroy(window);
 }
 
 void BrowserWindowGtk::Activate() {
   gtk_window_present(window_);
 }
@@ skipping 19 matching lines @@
 
 StatusBubble* BrowserWindowGtk::GetStatusBubble() {
   return status_bubble_.get();
 }
 
 void BrowserWindowGtk::SelectedTabToolbarSizeChanged(bool is_animating) {
   NOTIMPLEMENTED();
 }
 
 void BrowserWindowGtk::UpdateTitleBar() {
-  if (!window_)
-    return;
-
   std::wstring title = browser_->GetCurrentPageTitle();
   gtk_window_set_title(window_, WideToUTF8(title).c_str());
   if (browser_->SupportsWindowFeature(Browser::FEATURE_TITLEBAR)) {
     // If we're showing a title bar, we should update the app icon.
     NOTIMPLEMENTED();
   }
 }
 
 void BrowserWindowGtk::UpdateLoadingAnimations(bool should_animate) {
   NOTIMPLEMENTED();
@@ skipping 182 matching lines @@
   if (custom_frame_) {
     gtk_container_set_border_width(GTK_CONTAINER(vbox_), 2);
     // TODO(port): all the crazy blue title bar, etc.
     NOTIMPLEMENTED();
   } else {
     gtk_container_set_border_width(GTK_CONTAINER(vbox_), 0);
   }
 }
 
 // static
-gboolean BrowserWindowGtk::OnWindowDestroyed(GtkWidget* window,
-                                             BrowserWindowGtk* browser_win) {
-  // BUG 8712. When we gtk_widget_destroy() in Close(), this will emit the
-  // signal right away, and we will be here (while Close() is still in the
-  // call stack).  In order to not reenter Close(), and to also follow the
-  // expectations of BrowserList, we should run the BrowserWindowGtk destructor
-  // not now, but after the run loop goes back to process messages.  Otherwise
-  // we will remove ourself from BrowserList while it's being iterated.
-  // Additionally, now that we know the window is gone, we need to make sure to
-  // set window_ to NULL, otherwise we will try to close the window again when
-  // we call Close() in the destructor.
-  browser_win->window_ = NULL;
-  MessageLoop::current()->DeleteSoon(FROM_HERE, browser_win);
-  return FALSE;  // Don't stop this message.
-}
-
-// static
 gboolean BrowserWindowGtk::OnAccelerator(GtkAccelGroup* accel_group,
                                          GObject* acceleratable,
                                          guint keyval,
                                          GdkModifierType modifier,
                                          BrowserWindowGtk* browser_window) {
   browser_window->browser_->ExecuteCommand(GetCommandFromKeyval(keyval));
   return TRUE;
 }