Introducing SavePackageId and SaveItemId as distinct IdType<...>-based types.

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 <utility>
 
 #include "base/bind.h"
@@ skipping 40 matching lines @@
 #include "net/base/io_buffer.h"
 #include "net/base/mime_util.h"
 #include "net/url_request/url_request_context.h"
 #include "url/url_constants.h"
 
 using base::Time;
 
 namespace content {
 namespace {
 
-// A counter for uniquely identifying each save package.
-int g_save_package_id = 0;
+// Generates unique ids for SavePackage::unique_id_ field.
+SavePackageId GetNextSavePackageId() {
+  static int g_save_package_id = 0;
+  return SavePackageId::FromUnsafeValue(g_save_package_id++);
+}
 
 // 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_t kMaxFileOrdinalNumber = 9999;
 
 // Maximum length for file path. Since Windows have MAX_PATH limitation for
@@ skipping 82 matching lines @@
       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_(&base::FilePath::CompareLessIgnoreCase),
       wait_state_(INITIALIZE),
-      unique_id_(g_save_package_id++),
+      unique_id_(GetNextSavePackageId()),
       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))
       << save_type_;
   DCHECK(!saved_main_file_path_.empty() &&
          saved_main_file_path_.value().length() <= kMaxFilePathLength);
   DCHECK(!saved_main_directory_path_.empty() &&
@@ skipping 11 matching lines @@
       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_(&base::FilePath::CompareLessIgnoreCase),
       wait_state_(INITIALIZE),
-      unique_id_(g_save_package_id++),
+      unique_id_(GetNextSavePackageId()),
       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 base::FilePath& file_full_path,
                          const base::FilePath& directory_full_path)
     : WebContentsObserver(web_contents),
       number_of_frames_pending_response_(0),
       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_(&base::FilePath::CompareLessIgnoreCase),
       wait_state_(INITIALIZE),
-      unique_id_(g_save_package_id++),
+      unique_id_(GetNextSavePackageId()),
       wrote_to_completed_file_(false),
       wrote_to_failed_file_(false) {}
 
 SavePackage::~SavePackage() {
   // Stop receiving saving job's updates
   if (!finished_ && !canceled()) {
     // Unexpected quit.
     Cancel(true);
   }
 
@@ skipping 383 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_t save_item_id) {
+SaveItem* SavePackage::LookupSaveItemInProcess(SaveItemId 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_t save_item_id,
+bool SavePackage::UpdateSaveProgress(SaveItemId 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.
   if (!write_success) {
     // Cancel job with reason of disk error.
     Cancel(false);
   }
   return true;
 }
 
 // Stop all page saving jobs that are in progress and instruct the file thread
 // to delete all saved  files.
 void SavePackage::Stop() {
   // If we haven't moved out of the initial state, there's nothing to cancel and
   // there won't be valid pointers for file_manager_ or download_.
   if (wait_state_ == INITIALIZE)
     return;
 
   // When stopping, if it still has some items in in_progress, cancel them.
   DCHECK(canceled());
   if (in_process_count()) {
-    SaveItemIdMap::iterator it = in_progress_items_.begin();
-    for (; it != in_progress_items_.end(); ++it) {
-      SaveItem* save_item = it->second;
+    for (const auto& it : in_progress_items_) {
+      SaveItem* save_item = it.second;
       DCHECK_EQ(SaveItem::IN_PROGRESS, save_item->state());
       save_item->Cancel();
     }
     // Remove all in progress item to saved map. For failed items, they will
     // be put into saved_failed_items_, for successful item, they will be put
     // into saved_success_items_.
     while (in_process_count())
       PutInProgressItemToSavedMap(in_progress_items_.begin()->second);
   }
 
   // This vector contains the save ids of the save files which SaveFileManager
   // needs to remove from its save_file_map_.
-  std::vector<int> save_item_ids;
+  std::vector<SaveItemId> save_item_ids;
   for (const auto& it : saved_success_items_)
     save_item_ids.push_back(it.first);
   for (const auto& it : saved_failed_items_)
     save_item_ids.push_back(it.first);
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&SaveFileManager::RemoveSavedFileFromFileMap, file_manager_,
                  save_item_ids));
 
@@ skipping 44 matching lines @@
 
   // Record any errors that occurred.
   if (wrote_to_completed_file_)
     RecordSavePackageEvent(SAVE_PACKAGE_WRITE_TO_COMPLETED);
 
   if (wrote_to_failed_file_)
     RecordSavePackageEvent(SAVE_PACKAGE_WRITE_TO_FAILED);
 
   // This vector contains the save ids of the save files which SaveFileManager
   // needs to remove from its save_file_map_.
-  std::vector<int> list_of_failed_save_item_ids;
+  std::vector<SaveItemId> list_of_failed_save_item_ids;
   for (const auto& it : saved_failed_items_) {
     SaveItem* save_item = it.second;
     DCHECK_EQ(it.first, save_item->id());
     list_of_failed_save_item_ids.push_back(save_item->id());
   }
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&SaveFileManager::RemoveSavedFileFromFileMap, file_manager_,
                  list_of_failed_save_item_ids));
 
   if (download_) {
     // Hack to avoid touching download_ after user cancel.
     // TODO(rdsmith/benjhayden): Integrate canceling on DownloadItem
     // with SavePackage flow.
     if (download_->GetState() == DownloadItem::IN_PROGRESS) {
       if (save_type_ != SAVE_PAGE_TYPE_AS_MHTML) {
         download_->DestinationUpdate(
             all_save_items_count_, CurrentSpeed(), std::string());
         download_->OnAllDataSaved(DownloadItem::kEmptyFileHash);
       }
       download_->MarkAsComplete();
     }
     FinalizeDownloadEntry();
   }
 }
 
 // Called for updating end state.
-void SavePackage::SaveFinished(int32_t save_item_id,
+void SavePackage::SaveFinished(SaveItemId 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);
@@ skipping 227 matching lines @@
   if (it == frame_tree_node_id_to_save_item_.end()) {
     // Sanitization of renderer IPC - we will have no save item only if
     // the renderer misbehaves and sends OnSerializedHtmlFragment IPC without
     // being asked to.
     NOTREACHED();
     return;
   }
   SaveItem* save_item = it->second;
   DCHECK_EQ(SaveFileCreateInfo::SAVE_FILE_FROM_DOM, save_item->save_source());
   if (save_item->state() != SaveItem::IN_PROGRESS) {
-    for (SavedItemMap::iterator saved_it = saved_success_items_.begin();
-      saved_it != saved_success_items_.end(); ++saved_it) {
-      if (saved_it->second->url() == save_item->url()) {
+    for (const auto& saved_it : saved_success_items_) {
+      if (saved_it.second->url() == save_item->url()) {
         wrote_to_completed_file_ = true;
         break;
       }
     }
 
     auto it2 = saved_failed_items_.find(save_item->id());
     if (it2 != saved_failed_items_.end())
       wrote_to_failed_file_ = true;
 
     return;
@@ skipping 434 matching lines @@
 
 void SavePackage::FinalizeDownloadEntry() {
   DCHECK(download_);
   DCHECK(download_manager_);
 
   download_manager_->OnSavePackageSuccessfullyFinished(download_);
   StopObservation();
 }
 
 }  // namespace content