ABANDONED CL: Introducing a compile-time-safe SavePackageId type.

content/browser/download/save_file_manager.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 "build/build_config.h"
 
 #include "content/browser/download/save_file_manager.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 50 matching lines @@
 // unique save ID.
 int SaveFileManager::GetNextId() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return next_id_++;
 }
 
 void SaveFileManager::RegisterStartingRequest(const GURL& save_url,
                                               SavePackage* save_package) {
   // Make sure it runs in the UI thread.
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  int save_package_id = save_package->id();
+  SavePackageId save_package_id = save_package->id();
 
   // Register this starting request.
   StartingRequestsMap& starting_requests =
       contents_starting_requests_[save_package_id];
   bool never_present = starting_requests.insert(
       StartingRequestsMap::value_type(save_url.spec(), save_package)).second;
   DCHECK(never_present);
 }
 
-SavePackage* SaveFileManager::UnregisterStartingRequest(const GURL& save_url,
-                                                        int save_package_id) {
+SavePackage* SaveFileManager::UnregisterStartingRequest(
+    const GURL& save_url,
+    SavePackageId save_package_id) {
   // Make sure it runs in UI thread.
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   ContentsToStartingRequestsMap::iterator it =
       contents_starting_requests_.find(save_package_id);
   if (it != contents_starting_requests_.end()) {
     StartingRequestsMap& requests = it->second;
     StartingRequestsMap::iterator sit = requests.find(save_url.spec());
     if (sit == requests.end())
       return NULL;
@@ skipping 167 matching lines @@
 }
 
 // The IO thread will call this when saving is completed or it got error when
 // fetching data. In the former case, we forward the message to OnSaveFinished
 // in UI thread. In the latter case, the save ID will be -1, which means the
 // saving action did not even start, so we need to call OnErrorFinished in UI
 // thread, which will use the save URL to find corresponding request record and
 // delete it.
 void SaveFileManager::SaveFinished(int save_id,
                                    const GURL& save_url,
-                                   int save_package_id,
+                                   SavePackageId save_package_id,
                                    bool is_success) {
   DVLOG(20) << " " << __FUNCTION__ << "()"
             << " save_id = " << save_id << " save_url = \"" << save_url.spec()
             << "\""
             << " save_package_id = " << save_package_id
             << " is_success = " << is_success;
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   SaveFileMap::iterator it = save_file_map_.find(save_id);
   if (it != save_file_map_.end()) {
     SaveFile* save_file = it->second;
@@ skipping 68 matching lines @@
 void SaveFileManager::OnSaveFinished(int save_id,
                                      int64 bytes_so_far,
                                      bool is_success) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   SavePackage* package = LookupPackage(save_id);
   if (package)
     package->SaveFinished(save_id, bytes_so_far, is_success);
 }
 
 void SaveFileManager::OnErrorFinished(const GURL& save_url,
-                                      int save_package_id) {
+                                      SavePackageId save_package_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   SavePackage* save_package =
       UnregisterStartingRequest(save_url, save_package_id);
   if (save_package)
     save_package->SaveFailed(save_url);
 }
 
 // Notifications sent from the UI thread and run on the IO thread.
 
 void SaveFileManager::OnSaveURL(const GURL& url,
                                 const Referrer& referrer,
-                                int save_package_id,
+                                SavePackageId save_package_id,
                                 int render_process_host_id,
                                 int render_view_routing_id,
                                 int render_frame_routing_id,
                                 ResourceContext* context) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ResourceDispatcherHostImpl::Get()->BeginSaveFile(
       url, referrer, save_package_id, render_process_host_id,
       render_view_routing_id, render_frame_routing_id, context);
 }
 
@@ skipping 51 matching lines @@
     save_file_map_.erase(it);
     delete save_file;
   }
 }
 
 // It is possible that SaveItem which has specified save_id has been canceled
 // before this function runs. So if we can not find corresponding SaveFile by
 // using specified save_id, just return.
 void SaveFileManager::SaveLocalFile(const GURL& original_file_url,
                                     int save_id,
-                                    int save_package_id) {
+                                    SavePackageId save_package_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   SaveFile* save_file = LookupSaveFile(save_id);
   if (!save_file)
     return;
   // If it has finished, just return.
   if (!save_file->InProgress())
     return;
 
   // Close the save file before the copy operation.
   save_file->Finish();
@@ skipping 20 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(!full_path.empty());
 
   base::DeleteFile(full_path, is_dir);
 }
 
 void SaveFileManager::RenameAllFiles(const FinalNameList& final_names,
                                      const base::FilePath& resource_dir,
                                      int render_process_id,
                                      int render_frame_routing_id,
-                                     int save_package_id) {
+                                     SavePackageId save_package_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   if (!resource_dir.empty() && !base::PathExists(resource_dir))
     base::CreateDirectory(resource_dir);
 
   for (FinalNameList::const_iterator i = final_names.begin();
       i != final_names.end(); ++i) {
     SaveFileMap::iterator it = save_file_map_.find(i->first);
     if (it != save_file_map_.end()) {
       SaveFile* save_file = it->second;
       DCHECK(!save_file->InProgress());
       save_file->Rename(i->second);
       delete save_file;
       save_file_map_.erase(it);
     }
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&SaveFileManager::OnFinishSavePageJob, this, render_process_id,
                  render_frame_routing_id, save_package_id));
 }
 
 void SaveFileManager::OnFinishSavePageJob(int render_process_id,
                                           int render_frame_routing_id,
-                                          int save_package_id) {
+                                          SavePackageId save_package_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   SavePackage* save_package =
       GetSavePackageFromRenderIds(render_process_id, render_frame_routing_id);
 
   if (save_package && save_package->id() == save_package_id)
     save_package->Finish();
 }
 
 void SaveFileManager::RemoveSavedFileFromFileMap(
     const SaveIDList& save_ids) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   for (SaveIDList::const_iterator i = save_ids.begin();
       i != save_ids.end(); ++i) {
     SaveFileMap::iterator it = save_file_map_.find(*i);
     if (it != save_file_map_.end()) {
       SaveFile* save_file = it->second;
       DCHECK(!save_file->InProgress());
       base::DeleteFile(save_file->FullPath(), false);
       delete save_file;
       save_file_map_.erase(it);
     }
   }
 }
 
 }  // namespace content