Use base namespace for FilePath in content/browser

content/browser/download/download_item_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.
 
 // File method ordering: Methods in this file are in the same order as
 // in download_item_impl.h, with the following exception: The public
 // interface Start is placed in chronological order with the other
 // (private) routines that together define a DownloadItem's state
 // transitions as the download progresses.  See "Download progression
 // cascade" later in this file.
@@ skipping 39 matching lines @@
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_url_parameters.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/referrer.h"
 #include "net/base/net_util.h"
 
 namespace content {
 
 namespace {
 
-void DeleteDownloadedFile(const FilePath& path) {
+void DeleteDownloadedFile(const base::FilePath& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // Make sure we only delete files.
   if (!file_util::DirectoryExists(path))
     file_util::Delete(path, false);
 }
 
 // Classes to null out request handle calls (for SavePage DownloadItems, which
 // may have, e.g., Cancel() called on them without it doing anything)
 // and to DCHECK on them (for history DownloadItems, which should never have
@@ skipping 34 matching lines @@
 }  // namespace
 
 const char DownloadItem::kEmptyFileHash[] = "";
 
 // The maximum number of attempts we will make to resume automatically.
 const int DownloadItemImpl::kMaxAutoResumeAttempts = 5;
 
 // Constructor for reading from the history service.
 DownloadItemImpl::DownloadItemImpl(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 84 matching lines @@
       net::NetLog::TYPE_DOWNLOAD_URL_REQUEST,
       info.request_bound_net_log.source().ToEventParametersCallback());
 
   info.request_bound_net_log.AddEvent(
       net::NetLog::TYPE_DOWNLOAD_STARTED,
       bound_net_log_.source().ToEventParametersCallback());
 }
 
 // Constructing for the "Save Page As..." feature:
 DownloadItemImpl::DownloadItemImpl(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)
     : is_save_package_download_(true),
       request_handle_(new NullDownloadRequestHandle()),
       download_id_(download_id),
       current_path_(path),
       target_path_(path),
       target_disposition_(TARGET_DISPOSITION_OVERWRITE),
@@ skipping 313 matching lines @@
 }
 
 const std::string& DownloadItemImpl::GetETag() const {
   return etag_;
 }
 
 bool DownloadItemImpl::IsSavePackageDownload() const {
   return is_save_package_download_;
 }
 
-const FilePath& DownloadItemImpl::GetFullPath() const {
+const base::FilePath& DownloadItemImpl::GetFullPath() const {
   return current_path_;
 }
 
-const FilePath& DownloadItemImpl::GetTargetFilePath() const {
+const base::FilePath& DownloadItemImpl::GetTargetFilePath() const {
   return target_path_;
 }
 
-const FilePath& DownloadItemImpl::GetForcedFilePath() const {
+const base::FilePath& DownloadItemImpl::GetForcedFilePath() const {
   // TODO(asanka): Get rid of GetForcedFilePath(). We should instead just
   // require that clients respect GetTargetFilePath() if it is already set.
   return forced_file_path_;
 }
 
 // TODO(asanka): Get rid of GetUserVerifiedFilePath().  http://crbug.com/134237.
-FilePath DownloadItemImpl::GetUserVerifiedFilePath() const {
+base::FilePath DownloadItemImpl::GetUserVerifiedFilePath() const {
   return (IsDangerous() ||
           danger_type_ == DOWNLOAD_DANGER_TYPE_USER_VALIDATED) ?
       GetFullPath() : GetTargetFilePath();
 }
 
-FilePath DownloadItemImpl::GetFileNameToReportUser() const {
+base::FilePath DownloadItemImpl::GetFileNameToReportUser() const {
   if (!display_name_.empty())
     return display_name_;
   return target_path_.BaseName();
 }
 
 DownloadItem::TargetDisposition DownloadItemImpl::GetTargetDisposition() const {
   return target_disposition_;
 }
 
 const std::string& DownloadItemImpl::GetHash() const {
@@ skipping 133 matching lines @@
 }
 
 void DownloadItemImpl::SetIsTemporary(bool temporary) {
   is_temporary_ = temporary;
 }
 
 void DownloadItemImpl::SetOpened(bool opened) {
   opened_ = opened;
 }
 
-void DownloadItemImpl::SetDisplayName(const FilePath& name) {
+void DownloadItemImpl::SetDisplayName(const base::FilePath& name) {
   display_name_ = name;
 }
 
 std::string DownloadItemImpl::DebugString(bool verbose) const {
   std::string description =
       base::StringPrintf("{ id = %d"
                          " state = %s",
                          download_id_.local(),
                          DebugDownloadStateString(state_));
 
@@ skipping 384 matching lines @@
   // the download target so we can skip target name determination.
   if (!GetTargetFilePath().empty() && !GetFullPath().empty()) {
     delegate_->ShowDownloadInBrowser(this);
     MaybeCompleteDownload();
     return;
   }
 
   // The target path might be set and the full path empty if we failed
   // the intermediate rename--re-do file name determination in this case.
   // TODO(rdsmith,asanka): Clean up this logic.
-  target_path_ = FilePath();
+  target_path_ = base::FilePath();
 
   delegate_->DetermineDownloadTarget(
       this, base::Bind(&DownloadItemImpl::OnDownloadTargetDetermined,
                        weak_ptr_factory_.GetWeakPtr()));
 }
 
 // Called by delegate_ when the download target path has been
 // determined.
 void DownloadItemImpl::OnDownloadTargetDetermined(
-    const FilePath& target_path,
+    const base::FilePath& target_path,
     TargetDisposition disposition,
     DownloadDangerType danger_type,
-    const FilePath& intermediate_path) {
+    const base::FilePath& intermediate_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If the |target_path| is empty, then we consider this download to be
   // canceled.
   if (target_path.empty()) {
     Cancel(true);
     return;
   }
 
   // TODO(rdsmith,asanka): We are ignoring the possibility that the download
@@ skipping 30 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&DownloadFile::RenameAndUniquify,
                  // Safe because we control download file lifetime.
                  base::Unretained(download_file_.get()),
                  intermediate_path, callback));
 }
 
 void DownloadItemImpl::OnDownloadRenamedToIntermediateName(
     DownloadInterruptReason reason,
-    const FilePath& full_path) {
+    const base::FilePath& full_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(20) << __FUNCTION__ << " download=" << DebugString(true);
   if (DOWNLOAD_INTERRUPT_REASON_NONE != reason)
     Interrupt(reason);
   else
     SetFullPath(full_path);
   delegate_->ShowDownloadInBrowser(this);
 
   MaybeCompleteDownload();
 }
@@ skipping 61 matching lines @@
                  weak_ptr_factory_.GetWeakPtr());
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&DownloadFile::RenameAndAnnotate,
                  base::Unretained(download_file_.get()),
                  GetTargetFilePath(), callback));
 }
 
 void DownloadItemImpl::OnDownloadRenamedToFinalName(
     DownloadInterruptReason reason,
-    const FilePath& full_path) {
+    const base::FilePath& full_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!is_save_package_download_);
 
   // If a cancel or interrupt hit, we'll cancel the DownloadFile, which
   // will result in deleting the file on the file thread.  So we don't
   // care about the name having been changed.
   if (state_ != IN_PROGRESS_INTERNAL)
     return;
 
   VLOG(20) << __FUNCTION__ << "()"
@@ skipping 232 matching lines @@
 
 void DownloadItemImpl::SetDangerType(DownloadDangerType danger_type) {
   if (danger_type != danger_type_) {
     bound_net_log_.AddEvent(
         net::NetLog::TYPE_DOWNLOAD_ITEM_SAFETY_STATE_UPDATED,
         base::Bind(&ItemCheckedNetLogCallback, danger_type));
   }
   danger_type_ = danger_type;
 }
 
-void DownloadItemImpl::SetFullPath(const FilePath& new_path) {
+void DownloadItemImpl::SetFullPath(const base::FilePath& new_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(20) << __FUNCTION__ << "()"
            << " new_path = \"" << new_path.value() << "\""
            << " " << DebugString(true);
   DCHECK(!new_path.empty());
 
   bound_net_log_.AddEvent(
       net::NetLog::TYPE_DOWNLOAD_ITEM_RENAMED,
       base::Bind(&ItemRenamedNetLogCallback, &current_path_, &new_path));
 
@@ skipping 85 matching lines @@
     case RESUME_MODE_USER_CONTINUE:
       return "USER_CONTINUE";
     case RESUME_MODE_USER_RESTART:
       return "USER_RESTART";
   }
   NOTREACHED() << "Unknown resume mode " << mode;
   return "unknown";
 }
 
 }  // namespace content