Use base namespace for FilePath in content/browser

content/browser/download/download_item_impl.h

 // 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.
 
 #ifndef CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_IMPL_H_
 #define CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_IMPL_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 35 matching lines @@
   static const int kMaxAutoResumeAttempts;
 
   // Note that it is the responsibility of the caller to ensure that a
   // DownloadItemImplDelegate passed to a DownloadItemImpl constructor
   // outlives the DownloadItemImpl.
 
   // Constructing from persistent store:
   // |bound_net_log| is constructed externally for our use.
   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,
                    const net::BoundNetLog& bound_net_log);
 
   // Constructing for a regular download.
   // |bound_net_log| is constructed externally for our use.
   DownloadItemImpl(DownloadItemImplDelegate* delegate,
                    const DownloadCreateInfo& info,
                    const net::BoundNetLog& bound_net_log);
 
   // Constructing for the "Save Page As..." feature:
   // |bound_net_log| is constructed externally for our use.
   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);
 
   virtual ~DownloadItemImpl();
 
   // DownloadItem
   virtual void AddObserver(DownloadItem::Observer* observer) OVERRIDE;
   virtual void RemoveObserver(DownloadItem::Observer* observer) OVERRIDE;
@@ skipping 25 matching lines @@
   virtual std::string GetSuggestedFilename() const OVERRIDE;
   virtual std::string GetContentDisposition() const OVERRIDE;
   virtual std::string GetMimeType() const OVERRIDE;
   virtual std::string GetOriginalMimeType() const OVERRIDE;
   virtual std::string GetRemoteAddress() const OVERRIDE;
   virtual bool HasUserGesture() const OVERRIDE;
   virtual PageTransition GetTransitionType() const OVERRIDE;
   virtual const std::string& GetLastModifiedTime() const OVERRIDE;
   virtual const std::string& GetETag() const OVERRIDE;
   virtual bool IsSavePackageDownload() const OVERRIDE;
-  virtual const FilePath& GetFullPath() const OVERRIDE;
-  virtual const FilePath& GetTargetFilePath() const OVERRIDE;
-  virtual const FilePath& GetForcedFilePath() const OVERRIDE;
-  virtual FilePath GetUserVerifiedFilePath() const OVERRIDE;
-  virtual FilePath GetFileNameToReportUser() const OVERRIDE;
+  virtual const base::FilePath& GetFullPath() const OVERRIDE;
+  virtual const base::FilePath& GetTargetFilePath() const OVERRIDE;
+  virtual const base::FilePath& GetForcedFilePath() const OVERRIDE;
+  virtual base::FilePath GetUserVerifiedFilePath() const OVERRIDE;
+  virtual base::FilePath GetFileNameToReportUser() const OVERRIDE;
   virtual TargetDisposition GetTargetDisposition() const OVERRIDE;
   virtual const std::string& GetHash() const OVERRIDE;
   virtual const std::string& GetHashState() const OVERRIDE;
   virtual bool GetFileExternallyRemoved() const OVERRIDE;
   virtual bool IsDangerous() const OVERRIDE;
   virtual DownloadDangerType GetDangerType() const OVERRIDE;
   virtual bool TimeRemaining(base::TimeDelta* remaining) const OVERRIDE;
   virtual int64 CurrentSpeed() const OVERRIDE;
   virtual int PercentComplete() const OVERRIDE;
   virtual bool AllDataSaved() const OVERRIDE;
   virtual int64 GetTotalBytes() const OVERRIDE;
   virtual int64 GetReceivedBytes() const OVERRIDE;
   virtual base::Time GetStartTime() const OVERRIDE;
   virtual base::Time GetEndTime() const OVERRIDE;
   virtual bool CanShowInFolder() OVERRIDE;
   virtual bool CanOpenDownload() OVERRIDE;
   virtual bool ShouldOpenFileBasedOnExtension() OVERRIDE;
   virtual bool GetOpenWhenComplete() const OVERRIDE;
   virtual bool GetAutoOpened() OVERRIDE;
   virtual bool GetOpened() const OVERRIDE;
   virtual BrowserContext* GetBrowserContext() const OVERRIDE;
   virtual WebContents* GetWebContents() const OVERRIDE;
   virtual void OnContentCheckCompleted(DownloadDangerType danger_type) OVERRIDE;
   virtual void SetOpenWhenComplete(bool open) OVERRIDE;
   virtual void SetIsTemporary(bool temporary) OVERRIDE;
   virtual void SetOpened(bool opened) OVERRIDE;
-  virtual void SetDisplayName(const FilePath& name) OVERRIDE;
+  virtual void SetDisplayName(const base::FilePath& name) OVERRIDE;
   virtual std::string DebugString(bool verbose) const OVERRIDE;
 
   // All remaining public interfaces virtual to allow for DownloadItemImpl
   // mocks.
 
   virtual ResumeMode GetResumeMode() const;
 
   // State transition operations on regular downloads --------------------------
 
   // Start the download.
@@ skipping 87 matching lines @@
   // |download_type| indicates to the net log system what kind of download
   // this is.
   void Init(bool active, DownloadType download_type);
 
   // Called when the target path has been determined. |target_path| is the
   // suggested target path. |disposition| indicates how the target path should
   // be used (see TargetDisposition). |danger_type| is the danger level of
   // |target_path| as determined by the caller. |intermediate_path| is the path
   // to use to store the download until OnDownloadCompleting() is called.
   virtual void OnDownloadTargetDetermined(
-      const FilePath& target_path,
+      const base::FilePath& target_path,
       TargetDisposition disposition,
       DownloadDangerType danger_type,
-      const FilePath& intermediate_path);
+      const base::FilePath& intermediate_path);
 
   // Callback from file thread when we initialize the DownloadFile.
   void OnDownloadFileInitialized(DownloadInterruptReason result);
 
   void OnDownloadRenamedToIntermediateName(
-      DownloadInterruptReason reason, const FilePath& full_path);
+      DownloadInterruptReason reason, const base::FilePath& full_path);
 
   // If all pre-requisites have been met, complete download processing, i.e. do
   // internal cleanup, file rename, and potentially auto-open.  (Dangerous
   // downloads still may block on user acceptance after this point.)
   void MaybeCompleteDownload();
 
   // Called when the download is ready to complete.
   // This may perform final rename if necessary and will eventually call
   // DownloadItem::Completed().
   void OnDownloadCompleting();
 
   void OnDownloadRenamedToFinalName(DownloadInterruptReason reason,
-                                    const FilePath& full_path);
+                                    const base::FilePath& full_path);
 
   // Called if the embedder took over opening a download, to indicate that
   // the download has been opened.
   void DelayedDownloadOpened(bool auto_opened);
 
   // Called when the entire download operation (including renaming etc)
   // is completed.
   void Completed();
 
   // Helper routines -----------------------------------------------------------
 
   // Indicate that an error has occurred on the download.
   void Interrupt(DownloadInterruptReason reason);
 
   // Cancel the DownloadFile if we have it.
   void CancelDownloadFile();
 
   // Check if a download is ready for completion.  The callback provided
   // may be called at some point in the future if an external entity
   // state has change s.t. this routine should be checked again.
   bool IsDownloadReadyForCompletion(const base::Closure& state_change_notify);
 
   // Call to transition state; all state transitions should go through this.
   void TransitionTo(DownloadInternalState new_state);
 
   // Set the |danger_type_| and invoke obserers if necessary.
   void SetDangerType(DownloadDangerType danger_type);
 
-  void SetFullPath(const FilePath& new_path);
+  void SetFullPath(const base::FilePath& new_path);
 
   void AutoResumeIfValid();
 
   static DownloadState InternalToExternalState(
       DownloadInternalState internal_state);
   static DownloadInternalState ExternalToInternalState(
       DownloadState external_state);
 
   // Debugging routines --------------------------------------------------------
   static const char* DebugDownloadStateString(DownloadInternalState state);
   static const char* DebugResumeModeString(ResumeMode mode);
 
   // Will be false for save package downloads retrieved from the history.
   // TODO(rdsmith): Replace with a generalized enum for "download source".
   const bool is_save_package_download_;
 
   // The handle to the request information.  Used for operations outside the
   // download system.
   scoped_ptr<DownloadRequestHandleInterface> request_handle_;
 
   // Download ID assigned by DownloadResourceHandler.
   DownloadId download_id_;
 
   // Display name for the download. If this is empty, then the display name is
   // considered to be |target_path_.BaseName()|.
-  FilePath display_name_;
+  base::FilePath display_name_;
 
   // Full path to the downloaded or downloading file. This is the path to the
   // physical file, if one exists. The final target path is specified by
   // |target_path_|. |current_path_| can be empty if the in-progress path hasn't
   // been determined.
-  FilePath current_path_;
+  base::FilePath current_path_;
 
   // Target path of an in-progress download. We may be downloading to a
   // temporary or intermediate file (specified by |current_path_|.  Once the
   // download completes, we will rename the file to |target_path_|.
-  FilePath target_path_;
+  base::FilePath target_path_;
 
   // Whether the target should be overwritten, uniquified or prompted for.
   TargetDisposition target_disposition_;
 
   // The chain of redirects that leading up to and including the final URL.
   std::vector<GURL> url_chain_;
 
   // The URL of the page that initiated the download.
   GURL referrer_url_;
 
   // Filename suggestion from DownloadSaveInfo. It could, among others, be the
   // suggested filename in 'download' attribute of an anchor. Details:
   // http://www.whatwg.org/specs/web-apps/current-work/#downloading-hyperlinks
   std::string suggested_filename_;
 
   // If non-empty, contains an externally supplied path that should be used as
   // the target path.
-  FilePath forced_file_path_;
+  base::FilePath forced_file_path_;
 
   // Page transition that triggerred the download.
   PageTransition transition_type_;
 
   // Whether the download was triggered with a user gesture.
   bool has_user_gesture_;
 
   // Information from the request.
   // Content-disposition field from the header.
   std::string content_disposition_;
@@ skipping 100 matching lines @@
   const net::BoundNetLog bound_net_log_;
 
   base::WeakPtrFactory<DownloadItemImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadItemImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_ITEM_IMPL_H_