Use base namespace for FilePath in content/browser

content/browser/download/download_manager_impl.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/browser/download/download_manager_impl.h"
 
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 150 matching lines @@
 }
 
 class DownloadItemFactoryImpl : public DownloadItemFactory {
  public:
     DownloadItemFactoryImpl() {}
     virtual ~DownloadItemFactoryImpl() {}
 
     virtual DownloadItemImpl* CreatePersistedItem(
         DownloadItemImplDelegate* delegate,
         DownloadId download_id,
-        const FilePath& current_path,
-        const FilePath& target_path,
+        const base::FilePath& current_path,
+        const base::FilePath& target_path,
         const std::vector<GURL>& url_chain,
         const GURL& referrer_url,
         const base::Time& start_time,
         const base::Time& end_time,
         int64 received_bytes,
         int64 total_bytes,
         DownloadItem::DownloadState state,
         DownloadDangerType danger_type,
         DownloadInterruptReason interrupt_reason,
         bool opened,
@@ skipping 18 matching lines @@
 
     virtual DownloadItemImpl* CreateActiveItem(
         DownloadItemImplDelegate* delegate,
         const DownloadCreateInfo& info,
         const net::BoundNetLog& bound_net_log) OVERRIDE {
       return new DownloadItemImpl(delegate, info, bound_net_log);
     }
 
     virtual DownloadItemImpl* CreateSavePageItem(
         DownloadItemImplDelegate* delegate,
-        const FilePath& path,
+        const base::FilePath& path,
         const GURL& url,
         DownloadId download_id,
         const std::string& mime_type,
         const net::BoundNetLog& bound_net_log) OVERRIDE {
       return new DownloadItemImpl(delegate, path, url, download_id,
                                   mime_type, bound_net_log);
     }
 };
 
 }  // namespace
@@ skipping 26 matching lines @@
 }
 
 void DownloadManagerImpl::DetermineDownloadTarget(
     DownloadItemImpl* item, const DownloadTargetCallback& callback) {
   // Note that this next call relies on
   // DownloadItemImplDelegate::DownloadTargetCallback and
   // DownloadManagerDelegate::DownloadTargetCallback having the same
   // type.  If the types ever diverge, gasket code will need to
   // be written here.
   if (!delegate_ || !delegate_->DetermineDownloadTarget(item, callback)) {
-    FilePath target_path = item->GetForcedFilePath();
+    base::FilePath target_path = item->GetForcedFilePath();
     // TODO(asanka): Determine a useful path if |target_path| is empty.
     callback.Run(target_path,
                  DownloadItem::TARGET_DISPOSITION_OVERWRITE,
                  DOWNLOAD_DANGER_TYPE_NOT_DANGEROUS,
                  target_path);
   }
 }
 
 bool DownloadManagerImpl::ShouldCompleteDownload(
     DownloadItemImpl* item, const base::Closure& complete_callback) {
   if (!delegate_ ||
       delegate_->ShouldCompleteDownload(item, complete_callback)) {
     return true;
   }
   // Otherwise, the delegate has accepted responsibility to run the
   // callback when the download is ready for completion.
   return false;
 }
 
-bool DownloadManagerImpl::ShouldOpenFileBasedOnExtension(const FilePath& path) {
+bool DownloadManagerImpl::ShouldOpenFileBasedOnExtension(
+    const base::FilePath& path) {
   if (!delegate_)
     return false;
 
   return delegate_->ShouldOpenFileBasedOnExtension(path);
 }
 
 bool DownloadManagerImpl::ShouldOpenDownload(
     DownloadItemImpl* item, const ShouldOpenDownloadCallback& callback) {
   if (!delegate_)
     return true;
@@ skipping 70 matching lines @@
   browser_context_ = browser_context;
 
   return true;
 }
 
 DownloadItem* DownloadManagerImpl::StartDownload(
     scoped_ptr<DownloadCreateInfo> info,
     scoped_ptr<ByteStreamReader> stream) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  FilePath default_download_directory;
+  base::FilePath default_download_directory;
   if (delegate_) {
-    FilePath website_save_directory;      // Unused
-    bool skip_dir_check = false;          // Unused
+    base::FilePath website_save_directory;  // Unused
+    bool skip_dir_check = false;            // Unused
     delegate_->GetSaveDir(GetBrowserContext(), &website_save_directory,
                           &default_download_directory, &skip_dir_check);
   }
 
   // We create the DownloadItem before the DownloadFile because the
   // DownloadItem already needs to handle a state in which there is
   // no associated DownloadFile (history downloads, !IN_PROGRESS downloads)
   DownloadItemImpl* download = GetOrCreateDownloadItem(info.get());
   scoped_ptr<DownloadFile> download_file(
       file_factory_->CreateFile(
@@ skipping 64 matching lines @@
     net::BoundNetLog bound_net_log =
         net::BoundNetLog::Make(net_log_, net::NetLog::SOURCE_DOWNLOAD);
     download = item_factory_->CreateActiveItem(this, *info, bound_net_log);
     downloads_[download->GetId()] = download;
   }
 
   return download;
 }
 
 DownloadItemImpl* DownloadManagerImpl::CreateSavePackageDownloadItem(
-    const FilePath& main_file_path,
+    const base::FilePath& main_file_path,
     const GURL& page_url,
     const std::string& mime_type,
     DownloadItem::Observer* observer) {
   net::BoundNetLog bound_net_log =
       net::BoundNetLog::Make(net_log_, net::NetLog::SOURCE_DOWNLOAD);
   DownloadItemImpl* download_item = item_factory_->CreateSavePageItem(
       this,
       main_file_path,
       page_url,
       GetNextId(),
@@ skipping 121 matching lines @@
 
 void DownloadManagerImpl::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void DownloadManagerImpl::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 DownloadItem* DownloadManagerImpl::CreateDownloadItem(
-    const FilePath& current_path,
-    const FilePath& target_path,
+    const base::FilePath& current_path,
+    const base::FilePath& target_path,
     const std::vector<GURL>& url_chain,
     const GURL& referrer_url,
     const base::Time& start_time,
     const base::Time& end_time,
     int64 received_bytes,
     int64 total_bytes,
     DownloadItem::DownloadState state,
     DownloadDangerType danger_type,
     DownloadInterruptReason interrupt_reason,
     bool opened) {
@@ skipping 70 matching lines @@
   if (delegate_)
     delegate_->OpenDownload(download);
 }
 
 void DownloadManagerImpl::ShowDownloadInShell(DownloadItemImpl* download) {
   if (delegate_)
     delegate_->ShowDownloadInShell(download);
 }
 
 }  // namespace content