Replace FilePath with base::FilePath in some more top level directories.

ui/shell_dialogs/gtk/select_file_dialog_impl_gtk.cc

 // Copyright (c) 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 <gtk/gtk.h>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 29 matching lines @@
 class SelectFileDialogImplGTK : public ui::SelectFileDialogImpl {
  public:
   explicit SelectFileDialogImplGTK(Listener* listener,
                                    ui::SelectFilePolicy* policy);
 
  protected:
   virtual ~SelectFileDialogImplGTK();
 
   // SelectFileDialog implementation.
   // |params| is user data we pass back via the Listener interface.
-  virtual void SelectFileImpl(Type type,
-                              const string16& title,
-                              const FilePath& default_path,
-                              const FileTypeInfo* file_types,
-                              int file_type_index,
-                              const FilePath::StringType& default_extension,
-                              gfx::NativeWindow owning_window,
-                              void* params) OVERRIDE;
+  virtual void SelectFileImpl(
+      Type type,
+      const string16& title,
+      const base::FilePath& default_path,
+      const FileTypeInfo* file_types,
+      int file_type_index,
+      const base::FilePath::StringType& default_extension,
+      gfx::NativeWindow owning_window,
+      void* params) OVERRIDE;
 
  private:
   virtual bool HasMultipleFileTypeChoicesImpl() OVERRIDE;
 
   // Add the filters from |file_types_| to |chooser|.
   void AddFilters(GtkFileChooser* chooser);
 
   // Notifies the listener that a single file was chosen.
-  void FileSelected(GtkWidget* dialog, const FilePath& path);
+  void FileSelected(GtkWidget* dialog, const base::FilePath& path);
 
   // Notifies the listener that multiple files were chosen.
   void MultiFilesSelected(GtkWidget* dialog,
-                          const std::vector<FilePath>& files);
+                          const std::vector<base::FilePath>& files);
 
   // Notifies the listener that no file was chosen (the action was canceled).
   // Dialog is passed so we can find that |params| pointer that was passed to
   // us when we were told to show the dialog.
   void FileNotSelected(GtkWidget* dialog);
 
   GtkWidget* CreateSelectFolderDialog(const std::string& title,
-      const FilePath& default_path, gfx::NativeWindow parent);
+      const base::FilePath& default_path, gfx::NativeWindow parent);
 
   GtkWidget* CreateFileOpenDialog(const std::string& title,
-      const FilePath& default_path, gfx::NativeWindow parent);
+      const base::FilePath& default_path, gfx::NativeWindow parent);
 
   GtkWidget* CreateMultiFileOpenDialog(const std::string& title,
-      const FilePath& default_path, gfx::NativeWindow parent);
+      const base::FilePath& default_path, gfx::NativeWindow parent);
 
   GtkWidget* CreateSaveAsDialog(const std::string& title,
-      const FilePath& default_path, gfx::NativeWindow parent);
+      const base::FilePath& default_path, gfx::NativeWindow parent);
 
   // Removes and returns the |params| associated with |dialog| from
   // |params_map_|.
   void* PopParamsForDialog(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.
   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,
+                                  const base::FilePath& default_path,
                                   gfx::NativeWindow parent);
 
   // Callback for when the user responds to a Save As or Open File dialog.
   CHROMEGTK_CALLBACK_1(SelectFileDialogImplGTK, void,
                        OnSelectSingleFileDialogResponse, int);
 
   // Callback for when the user responds to a Select Folder dialog.
   CHROMEGTK_CALLBACK_1(SelectFileDialogImplGTK, void,
                        OnSelectSingleFolderDialogResponse, int);
 
@@ skipping 40 matching lines @@
 }
 
 bool SelectFileDialogImplGTK::HasMultipleFileTypeChoicesImpl() {
   return file_types_.extensions.size() > 1;
 }
 
 // We ignore |default_extension|.
 void SelectFileDialogImplGTK::SelectFileImpl(
     Type type,
     const string16& title,
-    const FilePath& default_path,
+    const base::FilePath& default_path,
     const FileTypeInfo* file_types,
     int file_type_index,
-    const FilePath::StringType& default_extension,
+    const base::FilePath::StringType& default_extension,
     gfx::NativeWindow owning_window,
     void* params) {
   type_ = type;
   // |owning_window| can be null when user right-clicks on a downloadable item
   // and chooses 'Open Link in New Tab' when 'Ask where to save each file
   // before downloading.' preference is turned on. (http://crbug.com/29213)
   if (owning_window)
     parents_.insert(owning_window);
 
   std::string title_string = UTF16ToUTF8(title);
@@ skipping 95 matching lines @@
   if (file_types_.include_all_files && !file_types_.extensions.empty()) {
     GtkFileFilter* filter = gtk_file_filter_new();
     gtk_file_filter_add_pattern(filter, "*");
     gtk_file_filter_set_name(filter,
         l10n_util::GetStringUTF8(IDS_SAVEAS_ALL_FILES).c_str());
     gtk_file_chooser_add_filter(chooser, filter);
   }
 }
 
 void SelectFileDialogImplGTK::FileSelected(GtkWidget* dialog,
-                                           const FilePath& path) {
+                                           const base::FilePath& path) {
   if (type_ == SELECT_SAVEAS_FILE)
     *last_saved_path_ = path.DirName();
   else if (type_ == SELECT_OPEN_FILE || type_ == SELECT_FOLDER)
     *last_opened_path_ = path.DirName();
   else
     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));
   }
   gtk_widget_destroy(dialog);
 }
 
 void SelectFileDialogImplGTK::MultiFilesSelected(GtkWidget* dialog,
-    const std::vector<FilePath>& files) {
+    const std::vector<base::FilePath>& files) {
     *last_opened_path_ = files[0].DirName();
 
   if (listener_)
     listener_->MultiFilesSelected(files, PopParamsForDialog(dialog));
   gtk_widget_destroy(dialog);
 }
 
 void SelectFileDialogImplGTK::FileNotSelected(GtkWidget* dialog) {
   void* params = PopParamsForDialog(dialog);
   if (listener_)
     listener_->FileSelectionCanceled(params);
   gtk_widget_destroy(dialog);
 }
 
 GtkWidget* SelectFileDialogImplGTK::CreateFileOpenHelper(
     const std::string& title,
-    const FilePath& default_path,
+    const base::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* SelectFileDialogImplGTK::CreateSelectFolderDialog(
     const std::string& title,
-    const FilePath& default_path,
+    const base::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* SelectFileDialogImplGTK::CreateFileOpenDialog(
     const std::string& title,
-    const FilePath& default_path,
+    const base::FilePath& default_path,
     gfx::NativeWindow parent) {
   std::string title_string = !title.empty() ? title :
         l10n_util::GetStringUTF8(IDS_OPEN_FILE_DIALOG_TITLE);
 
   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* SelectFileDialogImplGTK::CreateMultiFileOpenDialog(
     const std::string& title,
-    const FilePath& default_path,
+    const base::FilePath& default_path,
     gfx::NativeWindow parent) {
   std::string title_string = !title.empty() ? title :
         l10n_util::GetStringUTF8(IDS_OPEN_FILES_DIALOG_TITLE);
 
   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* SelectFileDialogImplGTK::CreateSaveAsDialog(const std::string& title,
-    const FilePath& default_path, gfx::NativeWindow parent) {
+    const base::FilePath& default_path, gfx::NativeWindow parent) {
   std::string title_string = !title.empty() ? title :
         l10n_util::GetStringUTF8(IDS_SAVE_AS_DIALOG_TITLE);
 
   GtkWidget* dialog =
       gtk_file_chooser_dialog_new(title_string.c_str(), parent,
                                   GTK_FILE_CHOOSER_ACTION_SAVE,
                                   GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                   GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
                                   NULL);
 
@@ skipping 67 matching lines @@
     FileNotSelected(dialog);
     return;
   }
 
   gchar* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
   if (!filename) {
     FileNotSelected(dialog);
     return;
   }
 
-  FilePath path(filename);
+  base::FilePath path(filename);
   g_free(filename);
 
   if (allow_folder) {
     FileSelected(dialog, path);
     return;
   }
 
   if (CallDirectoryExistsOnUIThread(path))
     FileNotSelected(dialog);
   else
@@ skipping 16 matching lines @@
     FileNotSelected(dialog);
     return;
   }
 
   GSList* filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
   if (!filenames) {
     FileNotSelected(dialog);
     return;
   }
 
-  std::vector<FilePath> filenames_fp;
+  std::vector<base::FilePath> filenames_fp;
   for (GSList* iter = filenames; iter != NULL; iter = g_slist_next(iter)) {
-    FilePath path(static_cast<char*>(iter->data));
+    base::FilePath path(static_cast<char*>(iter->data));
     g_free(iter->data);
     if (CallDirectoryExistsOnUIThread(path))
       continue;
     filenames_fp.push_back(path);
   }
   g_slist_free(filenames);
 
   if (filenames_fp.empty()) {
     FileNotSelected(dialog);
     return;
@@ skipping 25 matching lines @@
 }  // namespace
 
 namespace ui {
 
 SelectFileDialogImpl* SelectFileDialogImpl::NewSelectFileDialogImplGTK(
     Listener* listener, ui::SelectFilePolicy* policy) {
   return new SelectFileDialogImplGTK(listener, policy);
 }
 
 }  // namespace ui