Add explicit base to FilePath.

content/shell/shell_download_manager_delegate.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 "content/shell/shell_download_manager_delegate.h"
 
 #if defined(TOOLKIT_GTK)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 48 matching lines @@
   }
 
   if (!download->GetForcedFilePath().empty()) {
     callback.Run(download->GetForcedFilePath(),
                  DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                  DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
                  download->GetForcedFilePath());
     return true;
   }
 
-  FilePath generated_name = net::GenerateFileName(
+  base::FilePath generated_name = net::GenerateFileName(
       download->GetURL(),
       download->GetContentDisposition(),
       EmptyString(),
       download->GetSuggestedFilename(),
       download->GetMimeType(),
       "download");
 
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(
           &ShellDownloadManagerDelegate::GenerateFilename,
           this, download->GetId(), callback, generated_name,
           default_download_path_));
   return true;
 }
 
 void ShellDownloadManagerDelegate::GenerateFilename(
     int32 download_id,
     const DownloadTargetCallback& callback,
-    const FilePath& generated_name,
-    const FilePath& suggested_directory) {
+    const base::FilePath& generated_name,
+    const base::FilePath& suggested_directory) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (!file_util::PathExists(suggested_directory))
     file_util::CreateDirectory(suggested_directory);
 
-  FilePath suggested_path(suggested_directory.Append(generated_name));
+  base::FilePath suggested_path(suggested_directory.Append(generated_name));
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(
           &ShellDownloadManagerDelegate::OnDownloadPathGenerated,
           this, download_id, callback, suggested_path));
 }
 
 void ShellDownloadManagerDelegate::OnDownloadPathGenerated(
     int32 download_id,
     const DownloadTargetCallback& callback,
-    const FilePath& suggested_path) {
+    const base::FilePath& suggested_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (suppress_prompting_) {
     // Testing exit.
     callback.Run(suggested_path, DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                  DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
                  suggested_path.AddExtension(FILE_PATH_LITERAL(".crdownload")));
     return;
   }
 
   ChooseDownloadPath(download_id, callback, suggested_path);
 }
 
 void ShellDownloadManagerDelegate::ChooseDownloadPath(
     int32 download_id,
     const DownloadTargetCallback& callback,
-    const FilePath& suggested_path) {
+    const base::FilePath& suggested_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DownloadItem* item = download_manager_->GetDownload(download_id);
   if (!item || (item->GetState() != DownloadItem::IN_PROGRESS))
     return;
 
-  FilePath result;
+  base::FilePath result;
 #if defined(OS_WIN) && !defined(USE_AURA)
-  std::wstring file_part = FilePath(suggested_path).BaseName().value();
+  std::wstring file_part = base::FilePath(suggested_path).BaseName().value();
   wchar_t file_name[MAX_PATH];
   base::wcslcpy(file_name, file_part.c_str(), arraysize(file_name));
   OPENFILENAME save_as;
   ZeroMemory(&save_as, sizeof(save_as));
   save_as.lStructSize = sizeof(OPENFILENAME);
   save_as.hwndOwner = item->GetWebContents()->GetNativeView();
   save_as.lpstrFile = file_name;
   save_as.nMaxFile = arraysize(file_name);
 
   std::wstring directory;
   if (!suggested_path.empty())
     directory = suggested_path.DirName().value();
 
   save_as.lpstrInitialDir = directory.c_str();
   save_as.Flags = OFN_OVERWRITEPROMPT | OFN_EXPLORER | OFN_ENABLESIZING |
                   OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST;
 
   if (GetSaveFileName(&save_as))
-    result = FilePath(std::wstring(save_as.lpstrFile));
+    result = base::FilePath(std::wstring(save_as.lpstrFile));
 #elif defined(TOOLKIT_GTK)
   GtkWidget *dialog;
   gfx::NativeWindow parent_window;
-  std::string base_name = FilePath(suggested_path).BaseName().value();
+  std::string base_name = base::FilePath(suggested_path).BaseName().value();
 
   parent_window = item->GetWebContents()->GetView()->GetTopLevelNativeWindow();
   dialog = gtk_file_chooser_dialog_new("Save File",
                                        parent_window,
                                        GTK_FILE_CHOOSER_ACTION_SAVE,
                                        GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                                        GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
                                        NULL);
   gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog),
                                                  TRUE);
   gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),
                                     base_name.c_str());
 
   if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
     char *filename;
     filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
-    result = FilePath(filename);
+    result = base::FilePath(filename);
   }
   gtk_widget_destroy(dialog);
 #else
   NOTIMPLEMENTED();
 #endif
 
   callback.Run(result, DownloadItem::TARGET_DISPOSITION_PROMPT,
                DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS, result);
 }
 
 void ShellDownloadManagerDelegate::SetDownloadBehaviorForTesting(
-    const FilePath& default_download_path) {
+    const base::FilePath& default_download_path) {
   default_download_path_ = default_download_path;
   suppress_prompting_ = true;
 }
 
 }  // namespace content