GTK: Allow file I/O in file dialog functions functions on the UI thread....

chrome/browser/gtk/dialogs_gtk.cc

 // Copyright (c) 2010 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/gtk_signal.h"
 #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/sys_string_conversions.h"
+#include "base/thread.h"
+#include "base/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
-#include "base/thread.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_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 61 matching lines @@
   // Check whether response_id corresponds to the user cancelling/closing the
   // dialog. Used as a helper for the below callbacks.
   bool IsCancelResponse(gint response_id);
 
   // Common function for OnSelectSingleFileDialogResponse and
   // OnSelectSingleFolderDialogResponse.
   void SelectSingleFileHelper(GtkWidget* dialog,
                               gint response_id,
                               bool allow_folder);
 
+  // Common function for CreateFileOpenDialog and CreateMultiFileOpenDialog.
+  GtkWidget* CreateFileOpenHelper(const std::string& title,
+                                  const FilePath& default_path,
+                                  gfx::NativeWindow parent);
+
+  // Wrapper for file_util::DirectoryExists() that allow access on the UI
+  // thread. Use this only in the file dialog functions, where it's ok
+  // because the file dialog has to do many stats anyway. One more won't
+  // hurt too badly and it's likely already cached.
+  bool CallDirectoryExistsOnUIThread(const FilePath& path);
+
   // Callback for when the user responds to a Save As or Open File dialog.
   CHROMEGTK_CALLBACK_1(SelectFileDialogImpl, void,
                        OnSelectSingleFileDialogResponse, gint);
 
   // Callback for when the user responds to a Select Folder dialog.
   CHROMEGTK_CALLBACK_1(SelectFileDialogImpl, void,
                        OnSelectSingleFolderDialogResponse, gint);
 
   // Callback for when the user responds to a Open Multiple Files dialog.
   CHROMEGTK_CALLBACK_1(SelectFileDialogImpl, void,
@@ skipping 213 matching lines @@
   gtk_widget_destroy(dialog);
 }
 
 void SelectFileDialogImpl::FileNotSelected(GtkWidget* dialog) {
   void* params = PopParamsForDialog(dialog);
   if (listener_)
     listener_->FileSelectionCanceled(params);
   gtk_widget_destroy(dialog);
 }
 
+bool SelectFileDialogImpl::CallDirectoryExistsOnUIThread(const FilePath& path) {
+  base::ThreadRestrictions::ScopedAllowIO allow_io;
+  return file_util::DirectoryExists(path);
+}
+
+GtkWidget* SelectFileDialogImpl::CreateFileOpenHelper(
+    const std::string& title,
+    const FilePath& default_path,
+    gfx::NativeWindow parent) {
+  GtkWidget* dialog =
+      gtk_file_chooser_dialog_new(title.c_str(), parent,
+                                  GTK_FILE_CHOOSER_ACTION_OPEN,
+                                  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
+                                  GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
+                                  NULL);
+  AddFilters(GTK_FILE_CHOOSER(dialog));
+
+  if (!default_path.empty()) {
+    if (CallDirectoryExistsOnUIThread(default_path)) {
+      gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
+                                          default_path.value().c_str());
+    } else {
+      // If the file doesn't exist, this will just switch to the correct
+      // directory. That's good enough.
+      gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
+                                    default_path.value().c_str());
+    }
+  } else if (!last_opened_path_->empty()) {
+    gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
+                                        last_opened_path_->value().c_str());
+  }
+  return 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 =
       gtk_file_chooser_dialog_new(title_string.c_str(), parent,
                                   GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
                                   GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                   GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
                                   NULL);
 
   if (!default_path.empty()) {
     gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
                                   default_path.value().c_str());
   } else if (!last_opened_path_->empty()) {
     gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
                                         last_opened_path_->value().c_str());
   }
   gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), FALSE);
   g_signal_connect(dialog, "response",
                    G_CALLBACK(OnSelectSingleFolderDialogResponseThunk), this);
   return dialog;
 }
 
-GtkWidget* SelectFileDialogImpl::CreateFileOpenDialog(const std::string& title,
-    const FilePath& default_path, gfx::NativeWindow parent) {
+GtkWidget* SelectFileDialogImpl::CreateFileOpenDialog(
+    const std::string& title,
+    const FilePath& default_path,
+    gfx::NativeWindow parent) {
   std::string title_string = !title.empty() ? title :
         l10n_util::GetStringUTF8(IDS_OPEN_FILE_DIALOG_TITLE);
-
-  GtkWidget* dialog =
-      gtk_file_chooser_dialog_new(title_string.c_str(), parent,
-                                  GTK_FILE_CHOOSER_ACTION_OPEN,
-                                  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-                                  GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
-                                  NULL);
-
-  AddFilters(GTK_FILE_CHOOSER(dialog));
-  if (!default_path.empty()) {
-    if (file_util::DirectoryExists(default_path)) {
-      gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
-                                          default_path.value().c_str());
-    } else {
-      // If the file doesn't exist, this will just switch to the correct
-      // directory. That's good enough.
-      gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
-                                    default_path.value().c_str());
-    }
-  } else if (!last_opened_path_->empty()) {
-    gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
-                                        last_opened_path_->value().c_str());
-  }
+  GtkWidget* dialog = CreateFileOpenHelper(title_string, default_path, parent);
   gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), FALSE);
   g_signal_connect(dialog, "response",
                    G_CALLBACK(OnSelectSingleFileDialogResponseThunk), this);
   return dialog;
 }
 
 GtkWidget* SelectFileDialogImpl::CreateMultiFileOpenDialog(
     const std::string& title,
     const FilePath& default_path,
     gfx::NativeWindow parent) {
   std::string title_string = !title.empty() ? title :
         l10n_util::GetStringUTF8(IDS_OPEN_FILES_DIALOG_TITLE);
-
-  GtkWidget* dialog =
-      gtk_file_chooser_dialog_new(title_string.c_str(), parent,
-                                  GTK_FILE_CHOOSER_ACTION_OPEN,
-                                  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
-                                  GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
-                                  NULL);
-
-  AddFilters(GTK_FILE_CHOOSER(dialog));
-  if (!default_path.empty()) {
-    if (file_util::DirectoryExists(default_path)) {
-      gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
-                                          default_path.value().c_str());
-    } else {
-      // If the file doesn't exist, this will just switch to the correct
-      // directory. That's good enough.
-      gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
-                                    default_path.value().c_str());
-    }
-  } else if (!last_opened_path_->empty()) {
-    gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
-                                        last_opened_path_->value().c_str());
-  }
+  GtkWidget* dialog = CreateFileOpenHelper(title_string, default_path, parent);
   gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
   g_signal_connect(dialog, "response",
                    G_CALLBACK(OnSelectMultiFileDialogResponseThunk), this);
   return dialog;
 }
 
 GtkWidget* SelectFileDialogImpl::CreateSaveAsDialog(const std::string& title,
     const FilePath& default_path, gfx::NativeWindow parent) {
   std::string title_string = !title.empty() ? title :
         l10n_util::GetStringUTF8(IDS_SAVE_AS_DIALOG_TITLE);
@@ skipping 77 matching lines @@
   }
 
   FilePath path(filename);
   g_free(filename);
 
   if (allow_folder) {
     FileSelected(dialog, path);
     return;
   }
 
-  // We're accessing the disk from the UI thread here, but in this case it's
-  // ok because we may have just done lots of stats in the file selection
-  // dialog. One more won't hurt too badly.
-  if (file_util::DirectoryExists(path))
+  if (CallDirectoryExistsOnUIThread(path))
     FileNotSelected(dialog);
   else
     FileSelected(dialog, path);
 }
 
 void SelectFileDialogImpl::OnSelectSingleFileDialogResponse(
     GtkWidget* dialog, gint response_id) {
   return SelectSingleFileHelper(dialog, response_id, false);
 }
 
@@ skipping 12 matching lines @@
   GSList* filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
   if (!filenames) {
     FileNotSelected(dialog);
     return;
   }
 
   std::vector<FilePath> filenames_fp;
   for (GSList* iter = filenames; iter != NULL; iter = g_slist_next(iter)) {
     FilePath path(static_cast<char*>(iter->data));
     g_free(iter->data);
-    if (file_util::DirectoryExists(path))
+    if (CallDirectoryExistsOnUIThread(path))
       continue;
     filenames_fp.push_back(path);
   }
   g_slist_free(filenames);
 
   if (filenames_fp.empty()) {
     FileNotSelected(dialog);
     return;
   }
   MultiFilesSelected(dialog, filenames_fp);
@@ skipping 12 matching lines @@
   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(preview_), pixbuf);
     g_object_unref(pixbuf);
   }
   gtk_file_chooser_set_preview_widget_active(GTK_FILE_CHOOSER(chooser),
                                              pixbuf ? TRUE : FALSE);
 }