Switch to standard integer types 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/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
+#include "build/build_config.h"
 #include "components/url_formatter/url_formatter.h"
 #include "content/browser/download/download_item_impl.h"
 #include "content/browser/download/download_manager_impl.h"
 #include "content/browser/download/download_stats.h"
 #include "content/browser/download/save_file.h"
 #include "content/browser/download/save_file_manager.h"
 #include "content/browser/download/save_item.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
@@ skipping 26 matching lines @@
 
 // A counter for uniquely identifying each save package.
 int g_save_package_id = 0;
 
 // Default name which will be used when we can not get proper name from
 // resource URL.
 const char kDefaultSaveName[] = "saved_resource";
 
 // Maximum number of file ordinal number. I think it's big enough for resolving
 // name-conflict files which has same base file name.
-const int32 kMaxFileOrdinalNumber = 9999;
+const int32_t kMaxFileOrdinalNumber = 9999;
 
 // Maximum length for file path. Since Windows have MAX_PATH limitation for
 // file path, we need to make sure length of file path of every saved file
 // is less than MAX_PATH
 #if defined(OS_WIN)
-const uint32 kMaxFilePathLength = MAX_PATH - 1;
+const uint32_t kMaxFilePathLength = MAX_PATH - 1;
 #elif defined(OS_POSIX)
-const uint32 kMaxFilePathLength = PATH_MAX - 1;
+const uint32_t kMaxFilePathLength = PATH_MAX - 1;
 #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;
+const uint32_t 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.
 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(')'));
   base::FilePath::StringType::size_type l_paren_index =
       pure_file_name.rfind(FILE_PATH_LITERAL('('));
@@ skipping 262 matching lines @@
                                        save_source);
     // Add this item to waiting list.
     waiting_item_queue_.push_back(save_item);
     all_save_items_count_ = 1;
     download_->SetTotalBytes(1);
 
     DoSavingProcess();
   }
 }
 
-void SavePackage::OnMHTMLGenerated(int64 size) {
+void SavePackage::OnMHTMLGenerated(int64_t 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_->GetState() == DownloadItem::IN_PROGRESS) {
@@ 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(
+uint32_t 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);
+  return std::min(
+      kMaxFilePathLength,
+      static_cast<uint32_t>(base_dir.value().length()) + NAME_MAX + 1);
 #else
   return kMaxFilePathLength;
 #endif
 }
 
 // File name is considered being consist of pure file name, dot and file
 // extension name. File name might has no dot and file extension, or has
 // multiple dot inside file name. The dot, which separates the pure file
 // name and file extension name, is last dot in the whole file name.
 // This function is for making sure the length of specified file path is not
 // great than the specified maximum length of file path and getting safe pure
 // file name part if the input pure file name is too long.
 // 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 base::FilePath& dir_path,
     const base::FilePath::StringType& file_name_ext,
-    uint32 max_file_path_len,
+    uint32_t 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 (!dir_path.EndsWithSeparator())
     --available_length;
 
   // Plenty of room.
@@ skipping 30 matching lines @@
       file_path.RemoveExtension().BaseName().value();
   base::FilePath::StringType file_name_ext = file_path.Extension();
 
   // If it is HTML resource, use ".html" 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_);
+  uint32_t 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;
 
   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 =
         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;
+    uint32_t 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;
     }
 
@@ skipping 101 matching lines @@
 
   // Check whether we begin to require serialized HTML data.
   if (save_type_ == SAVE_PAGE_TYPE_AS_COMPLETE_HTML &&
       wait_state_ == HTML_DATA) {
     // Inform backend to serialize the all frames' DOM and send serialized
     // HTML data back.
     GetSerializedHtmlWithLocalLinks();
   }
 }
 
-SaveItem* SavePackage::LookupSaveItemInProcess(int32 save_item_id) {
+SaveItem* SavePackage::LookupSaveItemInProcess(int32_t save_item_id) {
   auto it = in_progress_items_.find(save_item_id);
   if (it != in_progress_items_.end()) {
     SaveItem* save_item = it->second;
     DCHECK_EQ(SaveItem::IN_PROGRESS, save_item->state());
     return save_item;
   }
   return nullptr;
 }
 
 void SavePackage::PutInProgressItemToSavedMap(SaveItem* save_item) {
   SaveItemIdMap::iterator it = in_progress_items_.find(save_item->id());
   DCHECK(it != in_progress_items_.end());
   DCHECK(save_item == it->second);
   in_progress_items_.erase(it);
 
   if (save_item->success()) {
     // Add it to saved_success_items_.
     DCHECK(saved_success_items_.find(save_item->id()) ==
            saved_success_items_.end());
     saved_success_items_[save_item->id()] = save_item;
   } else {
     // Add it to saved_failed_items_.
     DCHECK(saved_failed_items_.find(save_item->id()) ==
            saved_failed_items_.end());
     saved_failed_items_[save_item->id()] = save_item;
   }
 }
 
 // Called for updating saving state.
-bool SavePackage::UpdateSaveProgress(int32 save_item_id,
-                                     int64 size,
+bool SavePackage::UpdateSaveProgress(int32_t save_item_id,
+                                     int64_t size,
                                      bool write_success) {
   // Because we might have canceled this saving job before,
   // so we might not find corresponding SaveItem.
   SaveItem* save_item = LookupSaveItemInProcess(save_item_id);
   if (!save_item)
     return false;
 
   save_item->Update(size);
 
   // If we got disk error, cancel whole save page job.
@@ skipping 117 matching lines @@
             all_save_items_count_, CurrentSpeed(), std::string());
         download_->OnAllDataSaved(DownloadItem::kEmptyFileHash);
       }
       download_->MarkAsComplete();
     }
     FinalizeDownloadEntry();
   }
 }
 
 // Called for updating end state.
-void SavePackage::SaveFinished(int32 save_item_id,
-                               int64 size,
+void SavePackage::SaveFinished(int32_t save_item_id,
+                               int64_t size,
                                bool is_success) {
   // Because we might have canceled this saving job before,
   // so we might not find corresponding SaveItem. Just ignore it.
   SaveItem* save_item = LookupSaveItemInProcess(save_item_id);
   if (!save_item)
     return;
 
   // Let SaveItem set end state.
   save_item->Finish(size, is_success);
   // Remove the associated save id and SavePackage.
@@ skipping 68 matching lines @@
 // Calculate the percentage of whole save page job.
 int SavePackage::PercentComplete() {
   if (!all_save_items_count_)
     return 0;
   else if (!in_process_count())
     return 100;
   else
     return completed_count() / all_save_items_count_;
 }
 
-int64 SavePackage::CurrentSpeed() const {
+int64_t SavePackage::CurrentSpeed() const {
   base::TimeDelta diff = base::TimeTicks::Now() - start_tick_;
-  int64 diff_ms = diff.InMilliseconds();
+  int64_t diff_ms = diff.InMilliseconds();
   return diff_ms == 0 ? 0 : completed_count() * 1000 / diff_ms;
 }
 
 // Continue processing the save page job after one SaveItem has been
 // finished.
 void SavePackage::DoSavingProcess() {
   if (save_type_ == SAVE_PAGE_TYPE_AS_COMPLETE_HTML) {
     // We guarantee that images and JavaScripts must be downloaded first.
     // So when finishing all those sub-resources, we will know which
     // sub-resource's link can be replaced with local file path, which
@@ skipping 446 matching lines @@
     { 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)
   base::FilePath::StringType mime_type(contents_mime_type);
 #elif defined(OS_WIN)
   base::FilePath::StringType mime_type(base::UTF8ToWide(contents_mime_type));
 #endif  // OS_WIN
-  for (uint32 i = 0; i < arraysize(extensions); ++i) {
+  for (uint32_t i = 0; i < arraysize(extensions); ++i) {
     if (mime_type == extensions[i].mime_type)
       return extensions[i].suggested_extension;
   }
   return FILE_PATH_LITERAL("");
 }
 
 void SavePackage::GetSaveInfo() {
   // Can't use web_contents_ in the file thread, so get the data that we need
   // before calling to it.
   base::FilePath website_save_dir, download_save_dir;
@@ skipping 38 matching lines @@
   }
 
   bool can_save_as_complete = CanSaveAsComplete(mime_type);
   base::FilePath suggested_filename = GetSuggestedNameForSaveAs(
       can_save_as_complete, mime_type, accept_langs);
   base::FilePath::StringType pure_file_name =
       suggested_filename.RemoveExtension().BaseName().value();
   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);
+  uint32_t 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);
   }
@@ skipping 66 matching lines @@
 
 void SavePackage::FinalizeDownloadEntry() {
   DCHECK(download_);
   DCHECK(download_manager_);
 
   download_manager_->OnSavePackageSuccessfullyFinished(download_);
   StopObservation();
 }
 
 }  // namespace content