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

ui/shell_dialogs/select_file_dialog_win.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 "ui/shell_dialogs/select_file_dialog_win.h"
 
 #include <windows.h>
 #include <commdlg.h>
 #include <shlobj.h>
 
@@ skipping 65 matching lines @@
       return false;
     }
 
     return metro_get_save_file_name(ofn) == TRUE;
   } else {
     return GetSaveFileName(ofn) == TRUE;
   }
 }
 
 // Distinguish directories from regular files.
-bool IsDirectory(const FilePath& path) {
+bool IsDirectory(const base::FilePath& path) {
   base::PlatformFileInfo file_info;
   return file_util::GetFileInfo(path, &file_info) ?
       file_info.is_directory : file_util::EndsWithSeparator(path);
 }
 
 // Get the file type description from the registry. This will be "Text Document"
 // for .txt files, "JPEG Image" for .jpg files, etc. If the registry doesn't
 // have an entry for the file type, we return false, true if the description was
 // found. 'file_ext' must be in form ".txt".
 static bool GetRegistryDescriptionFromExtension(const std::wstring& file_ext,
@@ skipping 162 matching lines @@
                           const std::wstring& suggested_name,
                           const std::wstring& filter,
                           const std::wstring& def_ext,
                           bool ignore_suggested_ext,
                           unsigned* index,
                           std::wstring* final_name) {
   DCHECK(final_name);
   // Having an empty filter makes for a bad user experience. We should always
   // specify a filter when saving.
   DCHECK(!filter.empty());
-  const FilePath suggested_path(suggested_name);
+  const base::FilePath suggested_path(suggested_name);
   std::wstring file_part = suggested_path.BaseName().value();
   // If the suggested_name is a root directory, file_part will be '\', and the
   // call to GetSaveFileName below will fail.
   if (file_part.size() == 1 && file_part[0] == L'\\')
     file_part.clear();
 
   // The size of the in/out buffer in number of characters we pass to win32
   // GetSaveFileName.  From MSDN "The buffer must be large enough to store the
   // path and file name string or strings, including the terminating NULL
   // character.  ... The buffer should be at least 256 characters long.".
@@ skipping 102 matching lines @@
 // will start the dialog in the "C:\Documents and Settings\jojo\My Documents\"
 // directory, and filter for .png file types.
 // 'owner' is the window to which the dialog box is modal, NULL for a modeless
 // dialog box.
 // On success,  returns true and 'final_name' contains the full path of the file
 // that the user chose. On error, returns false, and 'final_name' is not
 // modified.
 bool SaveFileAs(HWND owner,
                 const std::wstring& suggested_name,
                 std::wstring* final_name) {
-  std::wstring file_ext = FilePath(suggested_name).Extension().insert(0, L"*");
+  std::wstring file_ext =
+      base::FilePath(suggested_name).Extension().insert(0, L"*");
   std::wstring filter = FormatFilterForExtensions(
       std::vector<std::wstring>(1, file_ext),
       std::vector<std::wstring>(),
       true);
   unsigned index = 1;
   return SaveFileAsWithFilter(owner,
                               suggested_name,
                               filter,
                               L"",
                               false,
                               &index,
                               final_name);
 }
 
 // Implementation of SelectFileDialog that shows a Windows common dialog for
 // choosing a file or folder.
 class SelectFileDialogImpl : public ui::SelectFileDialog,
                              public ui::BaseShellDialogImpl {
  public:
   explicit SelectFileDialogImpl(Listener* listener,
                                 ui::SelectFilePolicy* policy);
 
   // BaseShellDialog implementation:
   virtual bool IsRunning(gfx::NativeWindow owning_hwnd) const OVERRIDE;
   virtual void ListenerDestroyed() OVERRIDE;
 
  protected:
   // SelectFileDialog implementation:
-  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 ~SelectFileDialogImpl();
 
   // A struct for holding all the state necessary for displaying a Save dialog.
   struct ExecuteSelectParams {
     ExecuteSelectParams(Type type,
                         const std::wstring& title,
-                        const FilePath& default_path,
+                        const base::FilePath& default_path,
                         const FileTypeInfo* file_types,
                         int file_type_index,
                         const std::wstring& default_extension,
                         RunState run_state,
                         HWND owner,
                         void* params)
         : type(type),
           title(title),
           default_path(default_path),
           file_type_index(file_type_index),
           default_extension(default_extension),
           run_state(run_state),
           ui_proxy(MessageLoopForUI::current()->message_loop_proxy()),
           owner(owner),
           params(params) {
       if (file_types)
         this->file_types = *file_types;
     }
     SelectFileDialog::Type type;
     std::wstring title;
-    FilePath default_path;
+    base::FilePath default_path;
     FileTypeInfo file_types;
     int file_type_index;
     std::wstring default_extension;
     RunState run_state;
     scoped_refptr<base::MessageLoopProxy> ui_proxy;
     HWND owner;
     void* params;
   };
 
   // Shows the file selection dialog modal to |owner| and calls the result
   // back on the ui thread. Run on the dialog thread.
   void ExecuteSelectFile(const ExecuteSelectParams& params);
 
   // Notifies the listener that a folder was chosen. Run on the ui thread.
-  void FileSelected(const FilePath& path, int index,
+  void FileSelected(const base::FilePath& path, int index,
                     void* params, RunState run_state);
 
   // Notifies listener that multiple files were chosen. Run on the ui thread.
-  void MultiFilesSelected(const std::vector<FilePath>& paths, void* params,
+  void MultiFilesSelected(const std::vector<base::FilePath>& paths,
+                         void* params,
                          RunState run_state);
 
   // Notifies the listener that no file was chosen (the action was canceled).
   // Run on the ui thread.
   void FileNotSelected(void* params, RunState run_state);
 
   // Runs a Folder selection dialog box, passes back the selected folder in
   // |path| and returns true if the user clicks OK. If the user cancels the
   // dialog box the value in |path| is not modified and returns false. |title|
   // is the user-supplied title text to show for the dialog box. Run on the
   // dialog thread.
   bool RunSelectFolderDialog(const std::wstring& title,
                              HWND owner,
-                             FilePath* path);
+                             base::FilePath* path);
 
   // Runs an Open file dialog box, with similar semantics for input paramaters
   // as RunSelectFolderDialog.
   bool RunOpenFileDialog(const std::wstring& title,
                          const std::wstring& filters,
                          HWND owner,
-                         FilePath* path);
+                         base::FilePath* path);
 
   // Runs an Open file dialog box that supports multi-select, with similar
   // semantics for input paramaters as RunOpenFileDialog.
   bool RunOpenMultiFileDialog(const std::wstring& title,
                               const std::wstring& filter,
                               HWND owner,
-                              std::vector<FilePath>* paths);
+                              std::vector<base::FilePath>* paths);
 
   // The callback function for when the select folder dialog is opened.
   static int CALLBACK BrowseCallbackProc(HWND window, UINT message,
                                          LPARAM parameter,
                                          LPARAM data);
 
   virtual bool HasMultipleFileTypeChoicesImpl() OVERRIDE;
 
   // Returns the filter to be used while displaying the open/save file dialog.
   // This is computed from the extensions for the file types being opened.
@@ skipping 10 matching lines @@
       BaseShellDialogImpl(),
       has_multiple_file_type_choices_(false) {
 }
 
 SelectFileDialogImpl::~SelectFileDialogImpl() {
 }
 
 void SelectFileDialogImpl::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) {
   has_multiple_file_type_choices_ =
       file_types ? file_types->extensions.size() > 1 : true;
 #if defined(USE_AURA)
   // If the owning_window passed in is in metro then we need to forward the
   // file open/save operations to metro.
   if (GetShellDialogsDelegate() &&
       GetShellDialogsDelegate()->IsWindowInMetro(owning_window)) {
     if (type == SELECT_SAVEAS_FILE) {
@@ skipping 54 matching lines @@
 void SelectFileDialogImpl::ListenerDestroyed() {
   // Our associated listener has gone away, so we shouldn't call back to it if
   // our worker thread returns after the listener is dead.
   listener_ = NULL;
 }
 
 void SelectFileDialogImpl::ExecuteSelectFile(
     const ExecuteSelectParams& params) {
   string16 filter = GetFilterForFileTypes(params.file_types);
 
-  FilePath path = params.default_path;
+  base::FilePath path = params.default_path;
   bool success = false;
   unsigned filter_index = params.file_type_index;
   if (params.type == SELECT_FOLDER) {
     success = RunSelectFolderDialog(params.title,
                                     params.run_state.owner,
                                     &path);
   } else if (params.type == SELECT_SAVEAS_FILE) {
     std::wstring path_as_wstring = path.value();
     success = SaveFileAsWithFilter(params.run_state.owner,
         params.default_path.value(), filter,
         params.default_extension, false, &filter_index, &path_as_wstring);
     if (success)
-      path = FilePath(path_as_wstring);
+      path = base::FilePath(path_as_wstring);
     DisableOwner(params.run_state.owner);
   } else if (params.type == SELECT_OPEN_FILE) {
     success = RunOpenFileDialog(params.title, filter,
                                 params.run_state.owner, &path);
   } else if (params.type == SELECT_OPEN_MULTI_FILE) {
-    std::vector<FilePath> paths;
+    std::vector<base::FilePath> paths;
     if (RunOpenMultiFileDialog(params.title, filter,
                                params.run_state.owner, &paths)) {
       params.ui_proxy->PostTask(
           FROM_HERE,
           base::Bind(&SelectFileDialogImpl::MultiFilesSelected, this, paths,
                      params.params, params.run_state));
       return;
     }
   }
 
   if (success) {
       params.ui_proxy->PostTask(
         FROM_HERE,
         base::Bind(&SelectFileDialogImpl::FileSelected, this, path,
                    filter_index, params.params, params.run_state));
   } else {
       params.ui_proxy->PostTask(
         FROM_HERE,
         base::Bind(&SelectFileDialogImpl::FileNotSelected, this, params.params,
                    params.run_state));
   }
 }
 
-void SelectFileDialogImpl::FileSelected(const FilePath& selected_folder,
+void SelectFileDialogImpl::FileSelected(const base::FilePath& selected_folder,
                                         int index,
                                         void* params,
                                         RunState run_state) {
   if (listener_)
     listener_->FileSelected(selected_folder, index, params);
   EndRun(run_state);
 }
 
 void SelectFileDialogImpl::MultiFilesSelected(
-    const std::vector<FilePath>& selected_files,
+    const std::vector<base::FilePath>& selected_files,
     void* params,
     RunState run_state) {
   if (listener_)
     listener_->MultiFilesSelected(selected_files, params);
   EndRun(run_state);
 }
 
 void SelectFileDialogImpl::FileNotSelected(void* params, RunState run_state) {
   if (listener_)
     listener_->FileSelectionCanceled(params);
   EndRun(run_state);
 }
 
 int CALLBACK SelectFileDialogImpl::BrowseCallbackProc(HWND window,
                                                       UINT message,
                                                       LPARAM parameter,
                                                       LPARAM data) {
   if (message == BFFM_INITIALIZED) {
     // WParam is TRUE since passing a path.
     // data lParam member of the BROWSEINFO structure.
     SendMessage(window, BFFM_SETSELECTION, TRUE, (LPARAM)data);
   }
   return 0;
 }
 
 bool SelectFileDialogImpl::RunSelectFolderDialog(const std::wstring& title,
                                                  HWND owner,
-                                                 FilePath* path) {
+                                                 base::FilePath* path) {
   DCHECK(path);
 
   wchar_t dir_buffer[MAX_PATH + 1];
 
   bool result = false;
   BROWSEINFO browse_info = {0};
   browse_info.hwndOwner = owner;
   browse_info.lpszTitle = title.c_str();
   browse_info.pszDisplayName = dir_buffer;
   browse_info.ulFlags = BIF_USENEWUI | BIF_RETURNONLYFSDIRS;
 
   if (path->value().length()) {
     // Highlight the current value.
     browse_info.lParam = (LPARAM)path->value().c_str();
     browse_info.lpfn = &BrowseCallbackProc;
   }
 
   LPITEMIDLIST list = SHBrowseForFolder(&browse_info);
   DisableOwner(owner);
   if (list) {
     STRRET out_dir_buffer;
     ZeroMemory(&out_dir_buffer, sizeof(out_dir_buffer));
     out_dir_buffer.uType = STRRET_WSTR;
     base::win::ScopedComPtr<IShellFolder> shell_folder;
     if (SHGetDesktopFolder(shell_folder.Receive()) == NOERROR) {
       HRESULT hr = shell_folder->GetDisplayNameOf(list, SHGDN_FORPARSING,
                                                   &out_dir_buffer);
       if (SUCCEEDED(hr) && out_dir_buffer.uType == STRRET_WSTR) {
-        *path = FilePath(out_dir_buffer.pOleStr);
+        *path = base::FilePath(out_dir_buffer.pOleStr);
         CoTaskMemFree(out_dir_buffer.pOleStr);
         result = true;
       } else {
         // Use old way if we don't get what we want.
         wchar_t old_out_dir_buffer[MAX_PATH + 1];
         if (SHGetPathFromIDList(list, old_out_dir_buffer)) {
-          *path = FilePath(old_out_dir_buffer);
+          *path = base::FilePath(old_out_dir_buffer);
           result = true;
         }
       }
 
       // According to MSDN, win2000 will not resolve shortcuts, so we do it
       // ourself.
       base::win::ResolveShortcut(*path, path, NULL);
     }
     CoTaskMemFree(list);
   }
   return result;
 }
 
 bool SelectFileDialogImpl::RunOpenFileDialog(
     const std::wstring& title,
     const std::wstring& filter,
     HWND owner,
-    FilePath* path) {
+    base::FilePath* path) {
   OPENFILENAME ofn;
   // We must do this otherwise the ofn's FlagsEx may be initialized to random
   // junk in release builds which can cause the Places Bar not to show up!
   ZeroMemory(&ofn, sizeof(ofn));
   ofn.lStructSize = sizeof(ofn);
   ofn.hwndOwner = owner;
 
   wchar_t filename[MAX_PATH];
   // According to http://support.microsoft.com/?scid=kb;en-us;222003&x=8&y=12,
   // The lpstrFile Buffer MUST be NULL Terminated.
   filename[0] = 0;
   // Define the dir in here to keep the string buffer pointer pointed to
   // ofn.lpstrInitialDir available during the period of running the
   // GetOpenFileName.
-  FilePath dir;
+  base::FilePath dir;
   // Use lpstrInitialDir to specify the initial directory
   if (!path->empty()) {
     if (IsDirectory(*path)) {
       ofn.lpstrInitialDir = path->value().c_str();
     } else {
       dir = path->DirName();
       ofn.lpstrInitialDir = dir.value().c_str();
       // Only pure filename can be put in lpstrFile field.
       base::wcslcpy(filename, path->BaseName().value().c_str(),
                     arraysize(filename));
     }
   }
 
   ofn.lpstrFile = filename;
   ofn.nMaxFile = MAX_PATH;
 
   // We use OFN_NOCHANGEDIR so that the user can rename or delete the directory
   // without having to close Chrome first.
   ofn.Flags = OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR;
 
   if (!filter.empty())
     ofn.lpstrFilter = filter.c_str();
   bool success = CallGetOpenFileName(&ofn);
   DisableOwner(owner);
   if (success)
-    *path = FilePath(filename);
+    *path = base::FilePath(filename);
   return success;
 }
 
 bool SelectFileDialogImpl::RunOpenMultiFileDialog(
     const std::wstring& title,
     const std::wstring& filter,
     HWND owner,
-    std::vector<FilePath>* paths) {
+    std::vector<base::FilePath>* paths) {
   OPENFILENAME ofn;
   // We must do this otherwise the ofn's FlagsEx may be initialized to random
   // junk in release builds which can cause the Places Bar not to show up!
   ZeroMemory(&ofn, sizeof(ofn));
   ofn.lStructSize = sizeof(ofn);
   ofn.hwndOwner = owner;
 
   scoped_array<wchar_t> filename(new wchar_t[UNICODE_STRING_MAX_CHARS]);
   filename[0] = 0;
 
   ofn.lpstrFile = filename.get();
   ofn.nMaxFile = UNICODE_STRING_MAX_CHARS;
   // We use OFN_NOCHANGEDIR so that the user can rename or delete the directory
   // without having to close Chrome first.
   ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_EXPLORER
                | OFN_HIDEREADONLY | OFN_ALLOWMULTISELECT;
 
   if (!filter.empty()) {
     ofn.lpstrFilter = filter.c_str();
   }
 
   bool success = CallGetOpenFileName(&ofn);
   DisableOwner(owner);
   if (success) {
-    std::vector<FilePath> files;
+    std::vector<base::FilePath> files;
     const wchar_t* selection = ofn.lpstrFile;
     while (*selection) {  // Empty string indicates end of list.
-      files.push_back(FilePath(selection));
+      files.push_back(base::FilePath(selection));
       // Skip over filename and null-terminator.
       selection += files.back().value().length() + 1;
     }
     if (files.empty()) {
       success = false;
     } else if (files.size() == 1) {
       // When there is one file, it contains the path and filename.
       paths->swap(files);
     } else {
       // Otherwise, the first string is the path, and the remainder are
       // filenames.
-      std::vector<FilePath>::iterator path = files.begin();
-      for (std::vector<FilePath>::iterator file = path + 1;
+      std::vector<base::FilePath>::iterator path = files.begin();
+      for (std::vector<base::FilePath>::iterator file = path + 1;
            file != files.end(); ++file) {
         paths->push_back(path->Append(*file));
       }
     }
   }
   return success;
 }
 
 string16 SelectFileDialogImpl::GetFilterForFileTypes(
     const FileTypeInfo& file_types) {
@@ skipping 35 matching lines @@
     const std::wstring& suggested_ext) {
   DCHECK(!filename.empty());
   std::wstring return_value = filename;
 
   // If we wanted a specific extension, but the user's filename deleted it or
   // changed it to something that the system doesn't understand, re-append.
   // Careful: Checking net::GetMimeTypeFromExtension() will only find
   // extensions with a known MIME type, which many "known" extensions on Windows
   // don't have.  So we check directly for the "known extension" registry key.
   std::wstring file_extension(
-      GetExtensionWithoutLeadingDot(FilePath(filename).Extension()));
+      GetExtensionWithoutLeadingDot(base::FilePath(filename).Extension()));
   std::wstring key(L"." + file_extension);
   if (!(filter_selected.empty() || filter_selected == L"*.*") &&
       !base::win::RegKey(HKEY_CLASSES_ROOT, key.c_str(), KEY_READ).Valid() &&
       file_extension != suggested_ext) {
     if (return_value[return_value.length() - 1] != L'.')
       return_value.append(L".");
     return_value.append(suggested_ext);
   }
 
   // Strip any trailing dots, which Windows doesn't allow.
   size_t index = return_value.find_last_not_of(L'.');
   if (index < return_value.size() - 1)
     return_value.resize(index + 1);
 
   return return_value;
 }
 
 SelectFileDialog* CreateWinSelectFileDialog(
     SelectFileDialog::Listener* listener,
     SelectFilePolicy* policy) {
   return new SelectFileDialogImpl(listener, policy);
 }
 
 }  // namespace ui