Use base namespace for FilePath in content/browser

content/browser/download/save_package.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/save_package.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/file_path.h"
@@ skipping 61 matching lines @@
 #endif
 
 // Maximum length for file ordinal number part. Since we only support the
 // maximum 9999 for ordinal number, which means maximum file ordinal number part
 // should be "(9998)", so the value is 6.
 const uint32 kMaxFileOrdinalNumberPartLength = 6;
 
 // Strip current ordinal number, if any. Should only be used on pure
 // file names, i.e. those stripped of their extensions.
 // TODO(estade): improve this to not choke on alternate encodings.
-FilePath::StringType StripOrdinalNumber(
-    const FilePath::StringType& pure_file_name) {
-  FilePath::StringType::size_type r_paren_index =
+base::FilePath::StringType StripOrdinalNumber(
+    const base::FilePath::StringType& pure_file_name) {
+  base::FilePath::StringType::size_type r_paren_index =
       pure_file_name.rfind(FILE_PATH_LITERAL(')'));
-  FilePath::StringType::size_type l_paren_index =
+  base::FilePath::StringType::size_type l_paren_index =
       pure_file_name.rfind(FILE_PATH_LITERAL('('));
   if (l_paren_index >= r_paren_index)
     return pure_file_name;
 
-  for (FilePath::StringType::size_type i = l_paren_index + 1;
+  for (base::FilePath::StringType::size_type i = l_paren_index + 1;
        i != r_paren_index; ++i) {
     if (!IsAsciiDigit(pure_file_name[i]))
       return pure_file_name;
   }
 
   return pure_file_name.substr(0, l_paren_index);
 }
 
 // Check whether we can save page as complete-HTML for the contents which
 // have specified a MIME type. Now only contents which have the MIME type
 // "text/html" can be saved as complete-HTML.
 bool CanSaveAsComplete(const std::string& contents_mime_type) {
   return contents_mime_type == "text/html" ||
          contents_mime_type == "application/xhtml+xml";
 }
 
 }  // namespace
 
-const FilePath::CharType SavePackage::kDefaultHtmlExtension[] =
+const base::FilePath::CharType SavePackage::kDefaultHtmlExtension[] =
 #if defined(OS_WIN)
     FILE_PATH_LITERAL("htm");
 #else
     FILE_PATH_LITERAL("html");
 #endif
 
 SavePackage::SavePackage(WebContents* web_contents,
                          SavePageType save_type,
-                         const FilePath& file_full_path,
-                         const FilePath& directory_full_path)
+                         const base::FilePath& file_full_path,
+                         const base::FilePath& directory_full_path)
     : WebContentsObserver(web_contents),
       file_manager_(NULL),
       download_manager_(NULL),
       download_(NULL),
       page_url_(GetUrlToBeSaved()),
       saved_main_file_path_(file_full_path),
       saved_main_directory_path_(directory_full_path),
       title_(web_contents->GetTitle()),
       start_tick_(base::TimeTicks::Now()),
       finished_(false),
       mhtml_finishing_(false),
       user_canceled_(false),
       disk_error_occurred_(false),
       save_type_(save_type),
       all_save_items_count_(0),
-      file_name_set_(&FilePath::CompareLessIgnoreCase),
+      file_name_set_(&base::FilePath::CompareLessIgnoreCase),
       wait_state_(INITIALIZE),
       contents_id_(web_contents->GetRenderProcessHost()->GetID()),
       unique_id_(g_save_package_id++),
       wrote_to_completed_file_(false),
       wrote_to_failed_file_(false) {
   DCHECK(page_url_.is_valid());
   DCHECK((save_type_ == SAVE_PAGE_TYPE_AS_ONLY_HTML) ||
          (save_type_ == SAVE_PAGE_TYPE_AS_MHTML) ||
          (save_type_ == SAVE_PAGE_TYPE_AS_COMPLETE_HTML));
   DCHECK(!saved_main_file_path_.empty() &&
@@ skipping 10 matching lines @@
       download_(NULL),
       page_url_(GetUrlToBeSaved()),
       title_(web_contents->GetTitle()),
       start_tick_(base::TimeTicks::Now()),
       finished_(false),
       mhtml_finishing_(false),
       user_canceled_(false),
       disk_error_occurred_(false),
       save_type_(SAVE_PAGE_TYPE_UNKNOWN),
       all_save_items_count_(0),
-      file_name_set_(&FilePath::CompareLessIgnoreCase),
+      file_name_set_(&base::FilePath::CompareLessIgnoreCase),
       wait_state_(INITIALIZE),
       contents_id_(web_contents->GetRenderProcessHost()->GetID()),
       unique_id_(g_save_package_id++),
       wrote_to_completed_file_(false),
       wrote_to_failed_file_(false) {
   DCHECK(page_url_.is_valid());
   InternalInit();
 }
 
 // This is for testing use. Set |finished_| as true because we don't want
 // method Cancel to be be called in destructor in test mode.
 // We also don't call InternalInit().
 SavePackage::SavePackage(WebContents* web_contents,
-                         const FilePath& file_full_path,
-                         const FilePath& directory_full_path)
+                         const base::FilePath& file_full_path,
+                         const base::FilePath& directory_full_path)
     : WebContentsObserver(web_contents),
       file_manager_(NULL),
       download_manager_(NULL),
       download_(NULL),
       saved_main_file_path_(file_full_path),
       saved_main_directory_path_(directory_full_path),
       start_tick_(base::TimeTicks::Now()),
       finished_(true),
       mhtml_finishing_(false),
       user_canceled_(false),
       disk_error_occurred_(false),
       save_type_(SAVE_PAGE_TYPE_UNKNOWN),
       all_save_items_count_(0),
-      file_name_set_(&FilePath::CompareLessIgnoreCase),
+      file_name_set_(&base::FilePath::CompareLessIgnoreCase),
       wait_state_(INITIALIZE),
       contents_id_(0),
       unique_id_(g_save_package_id++),
       wrote_to_completed_file_(false),
       wrote_to_failed_file_(false) {
 }
 
 SavePackage::~SavePackage() {
   // Stop receiving saving job's updates
   if (!finished_ && !canceled()) {
@@ skipping 110 matching lines @@
     waiting_item_queue_.push(save_item);
     all_save_items_count_ = 1;
     download_->SetTotalBytes(1);
 
     DoSavingProcess();
   }
 
   return true;
 }
 
-void SavePackage::OnMHTMLGenerated(const FilePath& path, int64 size) {
+void SavePackage::OnMHTMLGenerated(const base::FilePath& path, int64 size) {
   if (size <= 0) {
     Cancel(false);
     return;
   }
   wrote_to_completed_file_ = true;
 
   // Hack to avoid touching download_ after user cancel.
   // TODO(rdsmith/benjhayden): Integrate canceling on DownloadItem
   // with SavePackage flow.
   if (download_->IsInProgress()) {
@@ skipping 12 matching lines @@
 
   if (download_manager_->GetDelegate()->ShouldCompleteDownload(
           download_, base::Bind(&SavePackage::Finish, this))) {
     Finish();
   }
 }
 
 // On POSIX, the length of |pure_file_name| + |file_name_ext| is further
 // restricted by NAME_MAX. The maximum allowed path looks like:
 // '/path/to/save_dir' + '/' + NAME_MAX.
-uint32 SavePackage::GetMaxPathLengthForDirectory(const FilePath& base_dir) {
+uint32 SavePackage::GetMaxPathLengthForDirectory(
+    const base::FilePath& base_dir) {
 #if defined(OS_POSIX)
   return std::min(kMaxFilePathLength,
                   static_cast<uint32>(base_dir.value().length()) +
                   NAME_MAX + 1);
 #else
   return kMaxFilePathLength;
 #endif
 }
 
 // File name is considered being consist of pure file name, dot and file
@@ skipping 1019 matching lines @@
 
 void SavePackage::FinalizeDownloadEntry() {
   DCHECK(download_);
   DCHECK(download_manager_);
 
   download_manager_->OnSavePackageSuccessfullyFinished(download_);
   StopObservation();
 }
 
 }  // namespace content