Replace FilePath with base::FilePath.

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 367 matching lines @@
 // The parameter |dir_path| specifies directory part of the specified
 // file path. The parameter |file_name_ext| specifies file extension
 // name part of the specified file path (including start dot). The parameter
 // |max_file_path_len| specifies maximum length of the specified file path.
 // The parameter |pure_file_name| input pure file name part of the specified
 // file path. If the length of specified file path is great than
 // |max_file_path_len|, the |pure_file_name| will output new pure file name
 // part for making sure the length of specified file path is less than
 // specified maximum length of file path. Return false if the function can
 // not get a safe pure file name, otherwise it returns true.
-bool SavePackage::GetSafePureFileName(const FilePath& dir_path,
-                                      const FilePath::StringType& file_name_ext,
-                                      uint32 max_file_path_len,
-                                      FilePath::StringType* pure_file_name) {
+bool SavePackage::GetSafePureFileName(
+    const base::FilePath& dir_path,
+    const base::FilePath::StringType& file_name_ext,
+    uint32 max_file_path_len,
+    base::FilePath::StringType* pure_file_name) {
   DCHECK(!pure_file_name->empty());
   int available_length = static_cast<int>(max_file_path_len -
                                           dir_path.value().length() -
                                           file_name_ext.length());
   // Need an extra space for the separator.
   if (!file_util::EndsWithSeparator(dir_path))
     --available_length;
 
   // Plenty of room.
   if (static_cast<int>(pure_file_name->length()) <= available_length)
     return true;
 
   // Limited room. Truncate |pure_file_name| to fit.
   if (available_length > 0) {
     *pure_file_name = pure_file_name->substr(0, available_length);
     return true;
   }
 
   // Not enough room to even use a shortened |pure_file_name|.
   pure_file_name->clear();
   return false;
 }
 
 // Generate name for saving resource.
 bool SavePackage::GenerateFileName(const std::string& disposition,
                                    const GURL& url,
                                    bool need_html_ext,
-                                   FilePath::StringType* generated_name) {
+                                   base::FilePath::StringType* generated_name) {
   // TODO(jungshik): Figure out the referrer charset when having one
   // makes sense and pass it to GenerateFileName.
-  FilePath file_path = net::GenerateFileName(url, disposition, "", "", "",
-                                             kDefaultSaveName);
+  base::FilePath file_path = net::GenerateFileName(url, disposition, "", "", "",
+                                                   kDefaultSaveName);
 
   DCHECK(!file_path.empty());
-  FilePath::StringType pure_file_name =
+  base::FilePath::StringType pure_file_name =
       file_path.RemoveExtension().BaseName().value();
-  FilePath::StringType file_name_ext = file_path.Extension();
+  base::FilePath::StringType file_name_ext = file_path.Extension();
 
   // If it is HTML resource, use ".htm{l,}" as its extension.
   if (need_html_ext) {
     file_name_ext = FILE_PATH_LITERAL(".");
     file_name_ext.append(kDefaultHtmlExtension);
   }
 
   // Need to make sure the suggested file name is not too long.
   uint32 max_path = GetMaxPathLengthForDirectory(saved_main_directory_path_);
 
   // Get safe pure file name.
   if (!GetSafePureFileName(saved_main_directory_path_, file_name_ext,
                            max_path, &pure_file_name))
     return false;
 
-  FilePath::StringType file_name = pure_file_name + file_name_ext;
+  base::FilePath::StringType file_name = pure_file_name + file_name_ext;
 
   // Check whether we already have same name in a case insensitive manner.
   FileNameSet::const_iterator iter = file_name_set_.find(file_name);
   if (iter == file_name_set_.end()) {
     file_name_set_.insert(file_name);
   } else {
     // Found same name, increase the ordinal number for the file name.
     pure_file_name =
-        FilePath(*iter).RemoveExtension().BaseName().value();
-    FilePath::StringType base_file_name = StripOrdinalNumber(pure_file_name);
+        base::FilePath(*iter).RemoveExtension().BaseName().value();
+    base::FilePath::StringType base_file_name =
+        StripOrdinalNumber(pure_file_name);
 
     // We need to make sure the length of base file name plus maximum ordinal
     // number path will be less than or equal to kMaxFilePathLength.
     if (!GetSafePureFileName(saved_main_directory_path_, file_name_ext,
         max_path - kMaxFileOrdinalNumberPartLength, &base_file_name))
       return false;
 
     // Prepare the new ordinal number.
     uint32 ordinal_number;
     FileNameCountMap::iterator it = file_name_count_map_.find(base_file_name);
     if (it == file_name_count_map_.end()) {
       // First base-name-conflict resolving, use 1 as initial ordinal number.
       file_name_count_map_[base_file_name] = 1;
       ordinal_number = 1;
     } else {
       // We have met same base-name conflict, use latest ordinal number.
       ordinal_number = it->second;
     }
 
     if (ordinal_number > (kMaxFileOrdinalNumber - 1)) {
       // Use a random file from temporary file.
-      FilePath temp_file;
+      base::FilePath temp_file;
       file_util::CreateTemporaryFile(&temp_file);
       file_name = temp_file.RemoveExtension().BaseName().value();
       // Get safe pure file name.
       if (!GetSafePureFileName(saved_main_directory_path_,
-                               FilePath::StringType(),
+                               base::FilePath::StringType(),
                                max_path, &file_name))
         return false;
     } else {
       for (int i = ordinal_number; i < kMaxFileOrdinalNumber; ++i) {
-        FilePath::StringType new_name = base_file_name +
+        base::FilePath::StringType new_name = base_file_name +
             StringPrintf(FILE_PATH_LITERAL("(%d)"), i) + file_name_ext;
         if (file_name_set_.find(new_name) == file_name_set_.end()) {
           // Resolved name conflict.
           file_name = new_name;
           file_name_count_map_[base_file_name] = ++i;
           break;
         }
       }
     }
 
@@ skipping 21 matching lines @@
 
   DCHECK(!saved_main_file_path_.empty());
 
   save_item->SetSaveId(info->save_id);
   save_item->SetTotalBytes(info->total_bytes);
 
   // Determine the proper path for a saving job, by choosing either the default
   // save directory, or prompting the user.
   DCHECK(!save_item->has_final_name());
   if (info->url != page_url_) {
-    FilePath::StringType generated_name;
+    base::FilePath::StringType generated_name;
     // For HTML resource file, make sure it will have .htm as extension name,
     // otherwise, when you open the saved page in Chrome again, download
     // file manager will treat it as downloadable resource, and download it
     // instead of opening it as HTML.
     bool need_html_ext =
         info->save_source == SaveFileCreateInfo::SAVE_FILE_FROM_DOM;
     if (!GenerateFileName(info->content_disposition,
                           GURL(info->url),
                           need_html_ext,
                           &generated_name)) {
@@ skipping 10 matching lines @@
       return;
     }
 
     // When saving page as only-HTML, we only have a SaveItem whose url
     // must be page_url_.
     DCHECK(save_type_ == SAVE_PAGE_TYPE_AS_COMPLETE_HTML);
     DCHECK(!saved_main_directory_path_.empty());
 
     // Now we get final name retrieved from GenerateFileName, we will use it
     // rename the SaveItem.
-    FilePath final_name = saved_main_directory_path_.Append(generated_name);
+    base::FilePath final_name =
+        saved_main_directory_path_.Append(generated_name);
     save_item->Rename(final_name);
   } else {
     // It is the main HTML file, use the name chosen by the user.
     save_item->Rename(saved_main_file_path_);
   }
 
   // If the save source is from file system, inform SaveFileManager to copy
   // corresponding file to the file path which this SaveItem specifies.
   if (info->save_source == SaveFileCreateInfo::SAVE_FILE_FROM_FILE) {
     BrowserThread::PostTask(
@@ skipping 115 matching lines @@
   if (download_) {
     download_->Cancel(false);
     FinalizeDownloadEntry();
   }
 }
 
 void SavePackage::CheckFinish() {
   if (in_process_count() || finished_)
     return;
 
-  FilePath dir = (save_type_ == SAVE_PAGE_TYPE_AS_COMPLETE_HTML &&
-                  saved_success_items_.size() > 1) ?
-                  saved_main_directory_path_ : FilePath();
+  base::FilePath dir = (save_type_ == SAVE_PAGE_TYPE_AS_COMPLETE_HTML &&
+                        saved_success_items_.size() > 1) ?
+                        saved_main_directory_path_ : base::FilePath();
 
   // This vector contains the final names of all the successfully saved files
   // along with their save ids. It will be passed to SaveFileManager to do the
   // renaming job.
   FinalNameList final_names;
   for (SavedItemMap::iterator it = saved_success_items_.begin();
       it != saved_success_items_.end(); ++it)
     final_names.push_back(std::make_pair(it->first,
                                          it->second->full_path()));
 
@@ skipping 257 matching lines @@
 }
 
 // After finishing all SaveItems which need to get data from net.
 // We collect all URLs which have local storage and send the
 // map:(originalURL:currentLocalPath) to render process (backend).
 // Then render process will serialize DOM and send data to us.
 void SavePackage::GetSerializedHtmlDataForCurrentPageWithLocalLinks() {
   if (wait_state_ != HTML_DATA)
     return;
   std::vector<GURL> saved_links;
-  std::vector<FilePath> saved_file_paths;
+  std::vector<base::FilePath> saved_file_paths;
   int successful_started_items_count = 0;
 
   // Collect all saved items which have local storage.
   // First collect the status of all the resource files and check whether they
   // have created local files although they have not been completely saved.
   // If yes, the file can be saved. Otherwise, there is a disk error, so we
   // need to cancel the page saving job.
   for (SaveUrlItemMap::iterator it = in_progress_items_.begin();
        it != in_progress_items_.end(); ++it) {
     DCHECK(it->second->save_source() ==
@@ skipping 10 matching lines @@
 
   // Collect all saved success items.
   for (SavedItemMap::iterator it = saved_success_items_.begin();
        it != saved_success_items_.end(); ++it) {
     DCHECK(it->second->has_final_name());
     saved_links.push_back(it->second->url());
     saved_file_paths.push_back(it->second->file_name());
   }
 
   // Get the relative directory name.
-  FilePath relative_dir_name = saved_main_directory_path_.BaseName();
+  base::FilePath relative_dir_name = saved_main_directory_path_.BaseName();
 
   Send(new ViewMsg_GetSerializedHtmlDataForCurrentPageWithLocalLinks(
       routing_id(), saved_links, saved_file_paths, relative_dir_name));
 }
 
 // Process the serialized HTML content data of a specified web page
 // retrieved from render process.
 void SavePackage::OnReceivedSerializedHtmlData(const GURL& frame_url,
                                                const std::string& data,
                                                int32 status) {
@@ skipping 130 matching lines @@
       waiting_item_queue_.push(save_item);
     }
     wait_state_ = NET_FILES;
     DoSavingProcess();
   } else {
     // No resource files need to be saved, treat it as user cancel.
     Cancel(true);
   }
 }
 
-FilePath SavePackage::GetSuggestedNameForSaveAs(
+base::FilePath SavePackage::GetSuggestedNameForSaveAs(
     bool can_save_as_complete,
     const std::string& contents_mime_type,
     const std::string& accept_langs) {
-  FilePath name_with_proper_ext =
-      FilePath::FromWStringHack(UTF16ToWideHack(title_));
+  base::FilePath name_with_proper_ext =
+      base::FilePath::FromWStringHack(UTF16ToWideHack(title_));
 
   // If the page's title matches its URL, use the URL. Try to use the last path
   // component or if there is none, the domain as the file name.
   // Normally we want to base the filename on the page title, or if it doesn't
   // exist, on the URL. It's not easy to tell if the page has no title, because
   // if the page has no title, WebContents::GetTitle() will return the page's
   // URL (adjusted for display purposes). Therefore, we convert the "title"
   // back to a URL, and if it matches the original page URL, we know the page
   // had no title (or had a title equal to its URL, which is fine to treat
   // similarly).
   if (title_ == net::FormatUrl(page_url_, accept_langs)) {
     std::string url_path;
     if (!page_url_.SchemeIs(chrome::kDataScheme)) {
       std::vector<std::string> url_parts;
       base::SplitString(page_url_.path(), '/', &url_parts);
       if (!url_parts.empty()) {
         for (int i = static_cast<int>(url_parts.size()) - 1; i >= 0; --i) {
           url_path = url_parts[i];
           if (!url_path.empty())
             break;
         }
       }
       if (url_path.empty())
         url_path = page_url_.host();
     } else {
       url_path = "dataurl";
     }
-    name_with_proper_ext = FilePath::FromWStringHack(UTF8ToWide(url_path));
+    name_with_proper_ext =
+        base::FilePath::FromWStringHack(UTF8ToWide(url_path));
   }
 
   // Ask user for getting final saving name.
   name_with_proper_ext = EnsureMimeExtension(name_with_proper_ext,
                                              contents_mime_type);
   // Adjust extension for complete types.
   if (can_save_as_complete)
     name_with_proper_ext = EnsureHtmlExtension(name_with_proper_ext);
 
-  FilePath::StringType file_name = name_with_proper_ext.value();
+  base::FilePath::StringType file_name = name_with_proper_ext.value();
   file_util::ReplaceIllegalCharactersInPath(&file_name, ' ');
-  return FilePath(file_name);
+  return base::FilePath(file_name);
 }
 
-FilePath SavePackage::EnsureHtmlExtension(const FilePath& name) {
+base::FilePath SavePackage::EnsureHtmlExtension(const base::FilePath& name) {
   // If the file name doesn't have an extension suitable for HTML files,
   // append one.
-  FilePath::StringType ext = name.Extension();
+  base::FilePath::StringType ext = name.Extension();
   if (!ext.empty())
     ext.erase(ext.begin());  // Erase preceding '.'.
   std::string mime_type;
   if (!net::GetMimeTypeFromExtension(ext, &mime_type) ||
       !CanSaveAsComplete(mime_type)) {
-    return FilePath(name.value() + FILE_PATH_LITERAL(".") +
-                    kDefaultHtmlExtension);
+    return base::FilePath(name.value() + FILE_PATH_LITERAL(".") +
+                          kDefaultHtmlExtension);
   }
   return name;
 }
 
-FilePath SavePackage::EnsureMimeExtension(const FilePath& name,
+base::FilePath SavePackage::EnsureMimeExtension(const base::FilePath& name,
     const std::string& contents_mime_type) {
   // Start extension at 1 to skip over period if non-empty.
-  FilePath::StringType ext = name.Extension().length() ?
+  base::FilePath::StringType ext = name.Extension().length() ?
       name.Extension().substr(1) : name.Extension();
-  FilePath::StringType suggested_extension =
+  base::FilePath::StringType suggested_extension =
       ExtensionForMimeType(contents_mime_type);
   std::string mime_type;
   if (!suggested_extension.empty() &&
       !net::GetMimeTypeFromExtension(ext, &mime_type)) {
     // Extension is absent or needs to be updated.
-    return FilePath(name.value() + FILE_PATH_LITERAL(".") +
+    return base::FilePath(name.value() + FILE_PATH_LITERAL(".") +
                     suggested_extension);
   }
   return name;
 }
 
-const FilePath::CharType* SavePackage::ExtensionForMimeType(
+const base::FilePath::CharType* SavePackage::ExtensionForMimeType(
     const std::string& contents_mime_type) {
   static const struct {
-    const FilePath::CharType *mime_type;
-    const FilePath::CharType *suggested_extension;
+    const base::FilePath::CharType *mime_type;
+    const base::FilePath::CharType *suggested_extension;
   } extensions[] = {
     { FILE_PATH_LITERAL("text/html"), kDefaultHtmlExtension },
     { FILE_PATH_LITERAL("text/xml"), FILE_PATH_LITERAL("xml") },
     { FILE_PATH_LITERAL("application/xhtml+xml"), FILE_PATH_LITERAL("xhtml") },
     { FILE_PATH_LITERAL("text/plain"), FILE_PATH_LITERAL("txt") },
     { FILE_PATH_LITERAL("text/css"), FILE_PATH_LITERAL("css") },
   };
 #if defined(OS_POSIX)
-  FilePath::StringType mime_type(contents_mime_type);
+  base::FilePath::StringType mime_type(contents_mime_type);
 #elif defined(OS_WIN)
-  FilePath::StringType mime_type(UTF8ToWide(contents_mime_type));
+  base::FilePath::StringType mime_type(UTF8ToWide(contents_mime_type));
 #endif  // OS_WIN
   for (uint32 i = 0; i < ARRAYSIZE_UNSAFE(extensions); ++i) {
     if (mime_type == extensions[i].mime_type)
       return extensions[i].suggested_extension;
   }
   return FILE_PATH_LITERAL("");
 }
 
 WebContents* SavePackage::web_contents() const {
   return WebContentsObserver::web_contents();
 }
 
 void SavePackage::GetSaveInfo() {
   // Can't use web_contents_ in the file thread, so get the data that we need
   // before calling to it.
-  FilePath website_save_dir, download_save_dir;
+  base::FilePath website_save_dir, download_save_dir;
   bool skip_dir_check;
   DCHECK(download_manager_);
   if (download_manager_->GetDelegate()) {
     download_manager_->GetDelegate()->GetSaveDir(
         web_contents()->GetBrowserContext(), &website_save_dir,
         &download_save_dir, &skip_dir_check);
   }
   std::string mime_type = web_contents()->GetContentsMimeType();
   std::string accept_languages =
       GetContentClient()->browser()->GetAcceptLangs(
           web_contents()->GetBrowserContext());
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&SavePackage::CreateDirectoryOnFileThread, this,
           website_save_dir, download_save_dir, skip_dir_check,
           mime_type, accept_languages));
 }
 
 void SavePackage::CreateDirectoryOnFileThread(
-    const FilePath& website_save_dir,
-    const FilePath& download_save_dir,
+    const base::FilePath& website_save_dir,
+    const base::FilePath& download_save_dir,
     bool skip_dir_check,
     const std::string& mime_type,
     const std::string& accept_langs) {
-  FilePath save_dir;
+  base::FilePath save_dir;
   // If the default html/websites save folder doesn't exist...
   // We skip the directory check for gdata directories on ChromeOS.
   if (!skip_dir_check && !file_util::DirectoryExists(website_save_dir)) {
     // If the default download dir doesn't exist, create it.
     if (!file_util::DirectoryExists(download_save_dir)) {
       bool res = file_util::CreateDirectory(download_save_dir);
       DCHECK(res);
     }
     save_dir = download_save_dir;
   } else {
     // If it does exist, use the default save dir param.
     save_dir = website_save_dir;
   }
 
   bool can_save_as_complete = CanSaveAsComplete(mime_type);
-  FilePath suggested_filename = GetSuggestedNameForSaveAs(
+  base::FilePath suggested_filename = GetSuggestedNameForSaveAs(
       can_save_as_complete, mime_type, accept_langs);
-  FilePath::StringType pure_file_name =
+  base::FilePath::StringType pure_file_name =
       suggested_filename.RemoveExtension().BaseName().value();
-  FilePath::StringType file_name_ext = suggested_filename.Extension();
+  base::FilePath::StringType file_name_ext = suggested_filename.Extension();
 
   // Need to make sure the suggested file name is not too long.
   uint32 max_path = GetMaxPathLengthForDirectory(save_dir);
 
   if (GetSafePureFileName(save_dir, file_name_ext, max_path, &pure_file_name)) {
     save_dir = save_dir.Append(pure_file_name + file_name_ext);
   } else {
     // Cannot create a shorter filename. This will cause the save as operation
     // to fail unless the user pick a shorter name. Continuing even though it
     // will fail because returning means no save as popup for the user, which
     // is even more confusing. This case should be rare though.
     save_dir = save_dir.Append(suggested_filename);
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&SavePackage::ContinueGetSaveInfo, this, save_dir,
                  can_save_as_complete));
 }
 
-void SavePackage::ContinueGetSaveInfo(const FilePath& suggested_path,
+void SavePackage::ContinueGetSaveInfo(const base::FilePath& suggested_path,
                                       bool can_save_as_complete) {
 
   // The WebContents which owns this SavePackage may have disappeared during
   // the UI->FILE->UI thread hop of
   // GetSaveInfo->CreateDirectoryOnFileThread->ContinueGetSaveInfo.
   if (!web_contents() || !download_manager_->GetDelegate())
     return;
 
-  FilePath::StringType default_extension;
+  base::FilePath::StringType default_extension;
   if (can_save_as_complete)
     default_extension = kDefaultHtmlExtension;
 
   download_manager_->GetDelegate()->ChooseSavePath(
       web_contents(),
       suggested_path,
       default_extension,
       can_save_as_complete,
       base::Bind(&SavePackage::OnPathPicked, AsWeakPtr()));
 }
 
 void SavePackage::OnPathPicked(
-    const FilePath& final_name,
+    const base::FilePath& final_name,
     SavePageType type,
     const SavePackageDownloadCreatedCallback& download_created_callback) {
   // Ensure the filename is safe.
   saved_main_file_path_ = final_name;
   // TODO(asanka): This call may block on IO and shouldn't be made
   // from the UI thread.  See http://crbug.com/61827.
   net::GenerateSafeFileName(web_contents()->GetContentsMimeType(), false,
                             &saved_main_file_path_);
 
   saved_main_directory_path_ = saved_main_file_path_.DirName();
@@ skipping 23 matching lines @@
 
 void SavePackage::FinalizeDownloadEntry() {
   DCHECK(download_);
   DCHECK(download_manager_);
 
   download_manager_->OnSavePackageSuccessfullyFinished(download_);
   StopObservation();
 }
 
 }  // namespace content