Keep track of when file dialogs are destroyed.

chrome/browser/gtk/dialogs_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 <gtk/gtk.h>
 #include <map>
 #include <set>
 
 #include "app/l10n_util.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/mime_util.h"
-#include "base/thread.h"
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
+#include "base/thread.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/shell_dialogs.h"
 #include "grit/generated_resources.h"
 
 // The size of the preview we display for selected image files. We set height
 // larger than width because generally there is more free space vertically
 // than horiztonally (setting the preview image will alway expand the width of
 // the dialog, but usually not the height). The image's aspect ratio will always
 // be preserved.
@@ skipping 47 matching lines @@
   GtkWidget* CreateMultiFileOpenDialog(const std::string& title,
       const FilePath& default_path, gfx::NativeWindow parent);
 
   GtkWidget* CreateSaveAsDialog(const std::string& title,
       const FilePath& default_path, gfx::NativeWindow parent);
 
   // Removes and returns the |params| associated with |dialog| from
   // |params_map_|.
   void* PopParamsForDialog(GtkWidget* dialog);
 
-  // Removes and returns the parent associated with |dialog| from |parents_|.
-  void RemoveParentForDialog(GtkWidget* dialog);
+  // Take care of internal data structures when a file dialog is destroyed.
+  void FileDialogDestroyed(GtkWidget* dialog);
 
   // Check whether response_id corresponds to the user cancelling/closing the
   // dialog. Used as a helper for the below callbacks.
   static bool IsCancelResponse(gint response_id);
 
   // Common function for OnSelectSingleFileDialogResponse and
   // OnSelectSingleFolderDialogResponse.
   static void SelectSingleFileHelper(GtkWidget* dialog,
                                      gint response_id,
                                      SelectFileDialogImpl* dialog_impl,
                                      bool allow_folder);
 
   // Callback for when the user responds to a Save As or Open File dialog.
   static void OnSelectSingleFileDialogResponse(
       GtkWidget* dialog, gint response_id, SelectFileDialogImpl* dialog_impl);
 
   // Callback for when the user responds to a Select Folder dialog.
   static void OnSelectSingleFolderDialogResponse(
       GtkWidget* dialog, gint response_id, SelectFileDialogImpl* dialog_impl);
 
   // Callback for when the user responds to a Open Multiple Files dialog.
   static void OnSelectMultiFileDialogResponse(
       GtkWidget* dialog, gint response_id, SelectFileDialogImpl* dialog_impl);
 
+  // Callback for when the file chooser gets destroyed.
+  static void OnFileChooserDestroy(GtkWidget* dialog,
+                                   SelectFileDialogImpl* dialog_impl);
+
   // Callback for when we update the preview for the selection.
   static void OnUpdatePreview(GtkFileChooser* chooser,
                               SelectFileDialogImpl* dialog);
 
   // The listener to be notified of selection completion.
   Listener* listener_;
 
   // A map from dialog windows to the |params| user data associated with them.
   std::map<GtkWidget*, void*> params_map_;
 
@@ skipping 36 matching lines @@
 
 SelectFileDialogImpl::SelectFileDialogImpl(Listener* listener)
     : listener_(listener) {
   if (!last_saved_path_) {
     last_saved_path_ = new FilePath();
     last_opened_path_ = new FilePath();
   }
 }
 
 SelectFileDialogImpl::~SelectFileDialogImpl() {
-  for (std::set<GtkWidget*>::iterator iter = dialogs_.begin();
-       iter != dialogs_.end(); ++iter) {
-    gtk_widget_destroy(*iter);
+  while (dialogs_.begin() != dialogs_.end()) {
+    gtk_widget_destroy(*(dialogs_.begin()));
   }
 }
 
 bool SelectFileDialogImpl::IsRunning(gfx::NativeWindow parent_window) const {
   return parents_.find(parent_window) != parents_.end();
 }
 
 void SelectFileDialogImpl::ListenerDestroyed() {
   listener_ = NULL;
 }
@@ skipping 38 matching lines @@
     case SELECT_SAVEAS_FILE:
       dialog = CreateSaveAsDialog(title_string, default_path, owning_window);
       break;
     default:
       NOTREACHED();
       return;
   }
   dialogs_.insert(dialog);
 
   preview_ = gtk_image_new();
+  g_signal_connect(dialog, "destroy", G_CALLBACK(OnFileChooserDestroy), this);
   g_signal_connect(dialog, "update-preview", G_CALLBACK(OnUpdatePreview), this);
   gtk_file_chooser_set_preview_widget(GTK_FILE_CHOOSER(dialog), preview_);
 
   params_map_[dialog] = params;
 
   // Set window-to-parent modality by adding the dialog to the same window
   // group as the parent.
   gtk_window_group_add_window(gtk_window_get_group(owning_window),
                               GTK_WINDOW(dialog));
   gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
@@ skipping 58 matching lines @@
     NOTREACHED();
 
   if (listener_) {
     GtkFileFilter* selected_filter =
         gtk_file_chooser_get_filter(GTK_FILE_CHOOSER(dialog));
     GSList* filters = gtk_file_chooser_list_filters(GTK_FILE_CHOOSER(dialog));
     int idx = g_slist_index(filters, selected_filter);
     g_slist_free(filters);
     listener_->FileSelected(path, idx + 1, PopParamsForDialog(dialog));
   }
-  RemoveParentForDialog(dialog);
   gtk_widget_destroy(dialog);
-  dialogs_.erase(dialog);
 }
 
 void SelectFileDialogImpl::MultiFilesSelected(GtkWidget* dialog,
     const std::vector<FilePath>& files) {
   *last_opened_path_ = files[0].DirName();
 
   if (listener_)
     listener_->MultiFilesSelected(files, PopParamsForDialog(dialog));
-  RemoveParentForDialog(dialog);
   gtk_widget_destroy(dialog);
-  dialogs_.erase(dialog);
 }
 
 void SelectFileDialogImpl::FileNotSelected(GtkWidget* dialog) {
   void* params = PopParamsForDialog(dialog);
   if (listener_)
     listener_->FileSelectionCanceled(params);
-  RemoveParentForDialog(dialog);
   gtk_widget_destroy(dialog);
-  dialogs_.erase(dialog);
 }
 
 GtkWidget* SelectFileDialogImpl::CreateSelectFolderDialog(
     const std::string& title,
     const FilePath& default_path,
     gfx::NativeWindow parent) {
   std::string title_string = !title.empty() ? title :
         l10n_util::GetStringUTF8(IDS_SELECT_FOLDER_DIALOG_TITLE);
 
   GtkWidget* dialog =
@@ skipping 106 matching lines @@
 }
 
 void* SelectFileDialogImpl::PopParamsForDialog(GtkWidget* dialog) {
   std::map<GtkWidget*, void*>::iterator iter = params_map_.find(dialog);
   DCHECK(iter != params_map_.end());
   void* params = iter->second;
   params_map_.erase(iter);
   return params;
 }
 
-void SelectFileDialogImpl::RemoveParentForDialog(GtkWidget* dialog) {
+void SelectFileDialogImpl::FileDialogDestroyed(GtkWidget* dialog) {
+  dialogs_.erase(dialog);
+
+  // Parent may be NULL on shutdown when AllBrowsersClosed() trigger this
+  // handler after all the browser windows got destroyed.
   GtkWindow* parent = gtk_window_get_transient_for(GTK_WINDOW(dialog));
-  DCHECK(parent);
+  if (!parent)
+    return;
   std::set<GtkWindow*>::iterator iter = parents_.find(parent);
   if (iter != parents_.end())
     parents_.erase(iter);
   else
     NOTREACHED();
 }
 
 // static
 bool SelectFileDialogImpl::IsCancelResponse(gint response_id) {
   bool is_cancel = response_id == GTK_RESPONSE_CANCEL ||
@@ skipping 78 matching lines @@
   g_slist_free(filenames);
 
   if (filenames_fp.empty()) {
     dialog_impl->FileNotSelected(dialog);
     return;
   }
   dialog_impl->MultiFilesSelected(dialog, filenames_fp);
 }
 
 // static
+void SelectFileDialogImpl::OnFileChooserDestroy(GtkWidget* dialog,
+    SelectFileDialogImpl* dialog_impl) {
+  dialog_impl->FileDialogDestroyed(dialog);
+}
+
+// static
 void SelectFileDialogImpl::OnUpdatePreview(GtkFileChooser* chooser,
                                            SelectFileDialogImpl* dialog) {
   gchar* filename = gtk_file_chooser_get_preview_filename(chooser);
   if (!filename)
     return;
   // This will preserve the image's aspect ratio.
   GdkPixbuf* pixbuf = gdk_pixbuf_new_from_file_at_size(filename, kPreviewWidth,
                                                        kPreviewHeight, NULL);
   g_free(filename);
   if (pixbuf) {
     gtk_image_set_from_pixbuf(GTK_IMAGE(dialog->preview_), pixbuf);
     g_object_unref(pixbuf);
   }
   gtk_file_chooser_set_preview_widget_active(chooser, pixbuf ? TRUE : FALSE);
 }