Switch to standard integer types in content/browser/.

content/browser/download/save_package.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_SAVE_PACKAGE_H_
 #define CONTENT_BROWSER_DOWNLOAD_SAVE_PACKAGE_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <deque>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "content/browser/download/save_types.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager_delegate.h"
 #include "content/public/browser/save_page_type.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/referrer.h"
@@ skipping 72 matching lines @@
   // written to disk.
   bool Init(const SavePackageDownloadCreatedCallback& cb);
 
   // Cancel all in progress request, might be called by user or internal error.
   void Cancel(bool user_action);
 
   void Finish();
 
   // Notifications sent from the file thread to the UI thread.
   void StartSave(const SaveFileCreateInfo* info);
-  bool UpdateSaveProgress(int32 save_item_id, int64 size, bool write_success);
-  void SaveFinished(int32 save_item_id, int64 size, bool is_success);
+  bool UpdateSaveProgress(int32_t save_item_id,
+                          int64_t size,
+                          bool write_success);
+  void SaveFinished(int32_t save_item_id, int64_t size, bool is_success);
   void SaveCanceled(SaveItem* save_item);
 
   // Rough percent complete, -1 means we don't know (since we didn't receive a
   // total size).
   int PercentComplete();
 
   bool canceled() const { return user_canceled_ || disk_error_occurred_; }
   bool finished() const { return finished_; }
   SavePageType save_type() const { return save_type_; }
   int id() const { return unique_id_; }
 
   void GetSaveInfo();
 
  private:
   friend class base::RefCountedThreadSafe<SavePackage>;
 
   void InitWithDownloadItem(
       const SavePackageDownloadCreatedCallback& download_created_callback,
       DownloadItemImpl* item);
 
   // Callback for WebContents::GenerateMHTML().
-  void OnMHTMLGenerated(int64 size);
+  void OnMHTMLGenerated(int64_t size);
 
   // For testing only.
   SavePackage(WebContents* web_contents,
               const base::FilePath& file_full_path,
               const base::FilePath& directory_full_path);
 
   ~SavePackage() override;
 
   // Notes from Init() above applies here as well.
   void InternalInit();
@@ skipping 13 matching lines @@
   // Update the download history of this item upon completion.
   void FinalizeDownloadEntry();
 
   // Detach from DownloadManager.
   void StopObservation();
 
   // Return max length of a path for a specific base directory.
   // This is needed on POSIX, which restrict the length of file names in
   // addition to the restriction on the length of path names.
   // |base_dir| is assumed to be a directory name with no trailing slash.
-  static uint32 GetMaxPathLengthForDirectory(const base::FilePath& base_dir);
+  static uint32_t GetMaxPathLengthForDirectory(const base::FilePath& base_dir);
 
   static bool 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);
 
   // Create a file name based on the response from the server.
   bool GenerateFileName(const std::string& disposition,
                         const GURL& url,
                         bool need_html_ext,
                         base::FilePath::StringType* generated_name);
 
   // Main routine that initiates asking all frames for their savable resources,
   // using GetSavableResourceLinksForFrame to send IPC to individual frames.
@@ skipping 61 matching lines @@
   void GetSerializedHtmlWithLocalLinksForFrame(FrameTreeNode* target_tree_node);
 
   // Routes html data (sent by renderer process in response to
   // GetSerializedHtmlWithLocalLinksForFrame above) to the associated local file
   // (and also keeps track of when all frames have been completed).
   void OnSerializedHtmlWithLocalLinksResponse(RenderFrameHostImpl* sender,
                                               const std::string& data,
                                               bool end_of_data);
 
   // Look up SaveItem by save item id from in progress map.
-  SaveItem* LookupSaveItemInProcess(int32 save_item_id);
+  SaveItem* LookupSaveItemInProcess(int32_t save_item_id);
 
   // Remove SaveItem from in progress map and put it to saved map.
   void PutInProgressItemToSavedMap(SaveItem* save_item);
 
   // Retrieves the URL to be saved from the WebContents.
   GURL GetUrlToBeSaved();
 
   void CreateDirectoryOnFileThread(const base::FilePath& website_save_dir,
                                    const base::FilePath& download_save_dir,
                                    bool skip_dir_check,
@@ skipping 23 matching lines @@
   int completed_count() const {
     return static_cast<int>(saved_success_items_.size() +
                             saved_failed_items_.size());
   }
 
   // The current speed in files per second. This is used to update the
   // DownloadItem associated to this SavePackage. The files per second is
   // presented by the DownloadItem to the UI as bytes per second, which is
   // not correct but matches the way the total and received number of files is
   // presented as the total and received bytes.
-  int64 CurrentSpeed() const;
+  int64_t CurrentSpeed() const;
 
   // Helper function for preparing suggested name for the SaveAs Dialog. The
   // suggested name is determined by the web document's title.
   base::FilePath GetSuggestedNameForSaveAs(
       bool can_save_as_complete,
       const std::string& contents_mime_type,
       const std::string& accept_langs);
 
   // Ensures that the file name has a proper extension for HTML by adding ".htm"
   // if necessary.
@@ skipping 29 matching lines @@
   // (i.e. to prevent information disclosure to oop frames).
   // Note that |frame_tree_node_id_to_contained_save_items_| does NOT own
   // SaveItems - they remain owned by waiting_item_queue_, in_progress_items_,
   // etc.
   base::hash_map<int, std::vector<SaveItem*>>
       frame_tree_node_id_to_contained_save_items_;
 
   // Number of frames that we still need to get a response from.
   int number_of_frames_pending_response_;
 
-  typedef base::hash_map<int32, SaveItem*> SavedItemMap;
+  typedef base::hash_map<int32_t, SaveItem*> SavedItemMap;
   // saved_success_items_ is map of all saving job which are successfully saved.
   SavedItemMap saved_success_items_;
 
   // Non-owning pointer for handling file writing on the file thread.
   SaveFileManager* file_manager_;
 
   // DownloadManager owns the DownloadItem and handles history and UI.
   DownloadManagerImpl* download_manager_;
   DownloadItemImpl* download_;
 
@@ skipping 26 matching lines @@
   // Number of all need to be saved resources.
   size_t all_save_items_count_;
 
   using FileNameSet =
       std::set<base::FilePath::StringType,
                bool (*)(base::FilePath::StringPieceType,
                         base::FilePath::StringPieceType)>;
   // This set is used to eliminate duplicated file names in saving directory.
   FileNameSet file_name_set_;
 
-  typedef base::hash_map<base::FilePath::StringType, uint32> FileNameCountMap;
+  typedef base::hash_map<base::FilePath::StringType, uint32_t> FileNameCountMap;
   // This map is used to track serial number for specified filename.
   FileNameCountMap file_name_count_map_;
 
   // Indicates current waiting state when SavePackage try to get something
   // from outside.
   WaitState wait_state_;
 
   // Unique ID for this SavePackage.
   const int unique_id_;
 
   // Variables to record errors that happened so we can record them via
   // UMA statistics.
   bool wrote_to_completed_file_;
   bool wrote_to_failed_file_;
 
   friend class SavePackageTest;
   FRIEND_TEST_ALL_PREFIXES(SavePackageTest, TestSuggestedSaveNames);
   FRIEND_TEST_ALL_PREFIXES(SavePackageTest, TestLongSafePureFilename);
 
   DISALLOW_COPY_AND_ASSIGN(SavePackage);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_DOWNLOAD_SAVE_PACKAGE_H_