Switch to standard integer types in chrome/browser/, part 1 of 4.

chrome/browser/download/download_history.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.
 
 // DownloadHistory manages persisting DownloadItems to the history service by
 // observing a single DownloadManager and all its DownloadItems using an
 // AllDownloadItemNotifier.
 //
 // DownloadHistory decides whether and when to add items to, remove items from,
 // and update items in the database. DownloadHistory uses DownloadHistoryData to
@@ skipping 10 matching lines @@
 // item is still being added to the database, DownloadHistory uses
 // |removed_while_adding_| to remember to remove the item when its ItemAdded()
 // callback is called.  All callbacks are bound with a weak pointer to
 // DownloadHistory to prevent use-after-free bugs.
 // ChromeDownloadManagerDelegate owns DownloadHistory, and deletes it in
 // Shutdown(), which is called by DownloadManagerImpl::Shutdown() after all
 // DownloadItems are destroyed.
 
 #include "chrome/browser/download/download_history.h"
 
+#include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "chrome/browser/download/download_crx_util.h"
 #include "components/history/content/browser/download_constants_utils.h"
 #include "components/history/core/browser/download_database.h"
 #include "components/history/core/browser/download_row.h"
 #include "components/history/core/browser/history_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager.h"
 
@@ skipping 144 matching lines @@
     const history::HistoryService::DownloadCreateCallback& callback) {
   history_->CreateDownload(info, callback);
 }
 
 void DownloadHistory::HistoryAdapter::UpdateDownload(
     const history::DownloadRow& data) {
   history_->UpdateDownload(data);
 }
 
 void DownloadHistory::HistoryAdapter::RemoveDownloads(
-    const std::set<uint32>& ids) {
+    const std::set<uint32_t>& ids) {
   history_->RemoveDownloads(ids);
 }
 
 DownloadHistory::Observer::Observer() {}
 DownloadHistory::Observer::~Observer() {}
 
 // static
 bool DownloadHistory::IsPersisted(const content::DownloadItem* item) {
   const DownloadHistoryData* data = DownloadHistoryData::Get(item);
   return data && (data->state() == DownloadHistoryData::PERSISTED);
@@ skipping 82 matching lines @@
     DCHECK_EQ(DownloadHistoryData::PERSISTED,
               DownloadHistoryData::Get(item)->state());
     ++history_size_;
   }
   notifier_.GetManager()->CheckForHistoryFilesRemoval();
 }
 
 void DownloadHistory::MaybeAddToHistory(content::DownloadItem* item) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  uint32 download_id = item->GetId();
+  uint32_t download_id = item->GetId();
   DownloadHistoryData* data = DownloadHistoryData::Get(item);
   bool removing = removing_ids_.find(download_id) != removing_ids_.end();
 
   // TODO(benjhayden): Remove IsTemporary().
   if (download_crx_util::IsExtensionDownload(*item) ||
       item->IsTemporary() ||
       (data->state() != DownloadHistoryData::NOT_PERSISTED) ||
       removing)
     return;
 
   data->SetState(DownloadHistoryData::PERSISTING);
   if (data->info() == NULL) {
     // Keep the info here regardless of whether the item is in progress so that,
     // when ItemAdded() calls OnDownloadUpdated(), it can decide whether to
     // Update the db and/or clear the info.
     data->set_info(GetDownloadRow(item));
   }
 
   history_->CreateDownload(*data->info(), base::Bind(
       &DownloadHistory::ItemAdded, weak_ptr_factory_.GetWeakPtr(),
       download_id));
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadStored(
       item, *data->info()));
 }
 
-void DownloadHistory::ItemAdded(uint32 download_id, bool success) {
+void DownloadHistory::ItemAdded(uint32_t download_id, bool success) {
   if (removed_while_adding_.find(download_id) !=
       removed_while_adding_.end()) {
     removed_while_adding_.erase(download_id);
     if (success)
       ScheduleRemoveDownload(download_id);
     return;
   }
 
   if (!notifier_.GetManager())
     return;
@@ skipping 102 matching lines @@
   ScheduleRemoveDownload(item->GetId());
   // This is important: another OnDownloadRemoved() handler could do something
   // that synchronously fires an OnDownloadUpdated().
   data->SetState(DownloadHistoryData::NOT_PERSISTED);
   // ItemAdded increments history_size_ only if the item wasn't
   // removed_while_adding_, so the next line does not belong in
   // ScheduleRemoveDownload().
   --history_size_;
 }
 
-void DownloadHistory::ScheduleRemoveDownload(uint32 download_id) {
+void DownloadHistory::ScheduleRemoveDownload(uint32_t download_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // For database efficiency, batch removals together if they happen all at
   // once.
   if (removing_ids_.empty()) {
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
         base::Bind(&DownloadHistory::RemoveDownloadsBatch,
                    weak_ptr_factory_.GetWeakPtr()));
   }
   removing_ids_.insert(download_id);
 }
 
 void DownloadHistory::RemoveDownloadsBatch() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   IdSet remove_ids;
   removing_ids_.swap(remove_ids);
   history_->RemoveDownloads(remove_ids);
   FOR_EACH_OBSERVER(Observer, observers_, OnDownloadsRemoved(remove_ids));
 }