Switch to standard integer types in content/browser/.

content/browser/download/download_manager_impl.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/download_manager_impl.h"
 
 #include <iterator>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 33 matching lines @@
 #include "net/base/request_priority.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/url_request/url_request_context.h"
 #include "url/origin.h"
 
 namespace content {
 namespace {
 
 scoped_ptr<UrlDownloader, BrowserThread::DeleteOnIOThread> BeginDownload(
     scoped_ptr<DownloadUrlParameters> params,
-    uint32 download_id,
+    uint32_t download_id,
     base::WeakPtr<DownloadManagerImpl> download_manager) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // ResourceDispatcherHost{Base} is-not-a URLRequest::Delegate, and
   // DownloadUrlParameters can-not include resource_dispatcher_host_impl.h, so
   // we must down cast. RDHI is the only subclass of RDH as of 2012 May 4.
   scoped_ptr<net::URLRequest> request(
       params->resource_context()->GetRequestContext()->CreateRequest(
           params->url(), net::DEFAULT_PRIORITY, NULL));
   request->set_method(params->method());
   if (!params->post_body().empty()) {
@@ skipping 76 matching lines @@
           .release());
 }
 
 class DownloadItemFactoryImpl : public DownloadItemFactory {
  public:
   DownloadItemFactoryImpl() {}
   ~DownloadItemFactoryImpl() override {}
 
   DownloadItemImpl* CreatePersistedItem(
       DownloadItemImplDelegate* delegate,
-      uint32 download_id,
+      uint32_t download_id,
       const base::FilePath& current_path,
       const base::FilePath& target_path,
       const std::vector<GURL>& url_chain,
       const GURL& referrer_url,
       const std::string& mime_type,
       const std::string& original_mime_type,
       const base::Time& start_time,
       const base::Time& end_time,
       const std::string& etag,
       const std::string& last_modified,
-      int64 received_bytes,
-      int64 total_bytes,
+      int64_t received_bytes,
+      int64_t total_bytes,
       DownloadItem::DownloadState state,
       DownloadDangerType danger_type,
       DownloadInterruptReason interrupt_reason,
       bool opened,
       const net::BoundNetLog& bound_net_log) override {
     return new DownloadItemImpl(
         delegate,
         download_id,
         current_path,
         target_path,
         url_chain,
         referrer_url,
         mime_type,
         original_mime_type,
         start_time,
         end_time,
         etag,
         last_modified,
         received_bytes,
         total_bytes,
         state,
         danger_type,
         interrupt_reason,
         opened,
         bound_net_log);
   }
 
   DownloadItemImpl* CreateActiveItem(
       DownloadItemImplDelegate* delegate,
-      uint32 download_id,
+      uint32_t download_id,
       const DownloadCreateInfo& info,
       const net::BoundNetLog& bound_net_log) override {
     return new DownloadItemImpl(delegate, download_id, info, bound_net_log);
   }
 
   DownloadItemImpl* CreateSavePageItem(
       DownloadItemImplDelegate* delegate,
-      uint32 download_id,
+      uint32_t download_id,
       const base::FilePath& path,
       const GURL& url,
       const std::string& mime_type,
       scoped_ptr<DownloadRequestHandleInterface> request_handle,
       const net::BoundNetLog& bound_net_log) override {
     return new DownloadItemImpl(delegate, download_id, path, url,
                                 mime_type, request_handle.Pass(),
                                 bound_net_log);
   }
 };
@@ skipping 12 matching lines @@
       net_log_(net_log),
       weak_factory_(this) {
   DCHECK(browser_context);
 }
 
 DownloadManagerImpl::~DownloadManagerImpl() {
   DCHECK(!shutdown_needed_);
 }
 
 DownloadItemImpl* DownloadManagerImpl::CreateActiveItem(
-    uint32 id, const DownloadCreateInfo& info) {
+    uint32_t id,
+    const DownloadCreateInfo& info) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!ContainsKey(downloads_, id));
   net::BoundNetLog bound_net_log =
       net::BoundNetLog::Make(net_log_, net::NetLog::SOURCE_DOWNLOAD);
   DownloadItemImpl* download =
       item_factory_->CreateActiveItem(this, id, info, bound_net_log);
   downloads_[id] = download;
   return download;
 }
 
 void DownloadManagerImpl::GetNextId(const DownloadIdCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (delegate_) {
     delegate_->GetNextId(callback);
     return;
   }
-  static uint32 next_id = content::DownloadItem::kInvalidId + 1;
+  static uint32_t next_id = content::DownloadItem::kInvalidId + 1;
   callback.Run(next_id++);
 }
 
 void DownloadManagerImpl::DetermineDownloadTarget(
     DownloadItemImpl* item, const DownloadTargetCallback& callback) {
   // Note that this next call relies on
   // DownloadItemImplDelegate::DownloadTargetCallback and
   // DownloadManagerDelegate::DownloadTargetCallback having the same
   // type.  If the types ever diverge, gasket code will need to
   // be written here.
@@ skipping 74 matching lines @@
     delegate_->Shutdown();
   delegate_ = NULL;
 }
 
 void DownloadManagerImpl::StartDownload(
     scoped_ptr<DownloadCreateInfo> info,
     scoped_ptr<ByteStreamReader> stream,
     const DownloadUrlParameters::OnStartedCallback& on_started) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(info);
-  uint32 download_id = info->download_id;
+  uint32_t download_id = info->download_id;
   const bool new_download = (download_id == content::DownloadItem::kInvalidId);
-  base::Callback<void(uint32)> got_id(base::Bind(
-      &DownloadManagerImpl::StartDownloadWithId,
-      weak_factory_.GetWeakPtr(),
-      base::Passed(&info),
-      base::Passed(&stream),
-      on_started,
-      new_download));
+  base::Callback<void(uint32_t)> got_id(base::Bind(
+      &DownloadManagerImpl::StartDownloadWithId, weak_factory_.GetWeakPtr(),
+      base::Passed(&info), base::Passed(&stream), on_started, new_download));
   if (new_download) {
     GetNextId(got_id);
   } else {
     got_id.Run(download_id);
   }
 }
 
 void DownloadManagerImpl::StartDownloadWithId(
     scoped_ptr<DownloadCreateInfo> info,
     scoped_ptr<ByteStreamReader> stream,
     const DownloadUrlParameters::OnStartedCallback& on_started,
     bool new_download,
-    uint32 id) {
+    uint32_t id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_NE(content::DownloadItem::kInvalidId, id);
   DownloadItemImpl* download = NULL;
   if (new_download) {
     download = CreateActiveItem(id, *info);
   } else {
     DownloadMap::iterator item_iterator = downloads_.find(id);
     // Trying to resume an interrupted download.
     if (item_iterator == downloads_.end() ||
         (item_iterator->second->GetState() == DownloadItem::CANCELLED)) {
@@ skipping 59 matching lines @@
   if ((download_item->GetState() == DownloadItem::COMPLETE) &&
       !download_item->GetFileExternallyRemoved() &&
       delegate_) {
     delegate_->CheckForFileExistence(
         download_item,
         base::Bind(&DownloadManagerImpl::OnFileExistenceChecked,
                    weak_factory_.GetWeakPtr(), download_item->GetId()));
   }
 }
 
-void DownloadManagerImpl::OnFileExistenceChecked(uint32 download_id,
+void DownloadManagerImpl::OnFileExistenceChecked(uint32_t download_id,
                                                  bool result) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!result) {  // File does not exist.
     if (ContainsKey(downloads_, download_id))
       downloads_[download_id]->OnDownloadedFileRemoved();
   }
 }
 
 BrowserContext* DownloadManagerImpl::GetBrowserContext() const {
   return browser_context_;
@@ skipping 15 matching lines @@
       base::Passed(request_handle.Pass()),
       item_created));
 }
 
 void DownloadManagerImpl::CreateSavePackageDownloadItemWithId(
     const base::FilePath& main_file_path,
     const GURL& page_url,
     const std::string& mime_type,
     scoped_ptr<DownloadRequestHandleInterface> request_handle,
     const DownloadItemImplCreated& item_created,
-    uint32 id) {
+    uint32_t id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_NE(content::DownloadItem::kInvalidId, id);
   DCHECK(!ContainsKey(downloads_, id));
   net::BoundNetLog bound_net_log =
       net::BoundNetLog::Make(net_log_, net::NetLog::SOURCE_DOWNLOAD);
   DownloadItemImpl* download_item = item_factory_->CreateSavePageItem(
       this,
       id,
       main_file_path,
       page_url,
@@ skipping 11 matching lines @@
     DownloadItem* download_item) {
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnSavePackageSuccessfullyFinished(this, download_item));
 }
 
 // Resume a download of a specific URL. We send the request to the
 // ResourceDispatcherHost, and let it send us responses like a regular
 // download.
 void DownloadManagerImpl::ResumeInterruptedDownload(
     scoped_ptr<content::DownloadUrlParameters> params,
-    uint32 id) {
+    uint32_t id) {
   RecordDownloadSource(INITIATED_BY_RESUMPTION);
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&BeginDownload, base::Passed(&params), id,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&DownloadManagerImpl::AddUrlDownloader,
                  weak_factory_.GetWeakPtr()));
 }
 
 void DownloadManagerImpl::SetDownloadItemFactoryForTesting(
     scoped_ptr<DownloadItemFactory> item_factory) {
   item_factory_ = item_factory.Pass();
 }
 
 void DownloadManagerImpl::SetDownloadFileFactoryForTesting(
     scoped_ptr<DownloadFileFactory> file_factory) {
   file_factory_ = file_factory.Pass();
 }
 
 DownloadFileFactory* DownloadManagerImpl::GetDownloadFileFactoryForTesting() {
   return file_factory_.get();
 }
 
 void DownloadManagerImpl::DownloadRemoved(DownloadItemImpl* download) {
   if (!download)
     return;
 
-  uint32 download_id = download->GetId();
+  uint32_t download_id = download->GetId();
   if (downloads_.erase(download_id) == 0)
     return;
   delete download;
 }
 
 void DownloadManagerImpl::AddUrlDownloader(
     scoped_ptr<UrlDownloader, BrowserThread::DeleteOnIOThread> downloader) {
   if (downloader)
     url_downloaders_.push_back(downloader.Pass());
 }
@@ skipping 88 matching lines @@
 
 void DownloadManagerImpl::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void DownloadManagerImpl::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 DownloadItem* DownloadManagerImpl::CreateDownloadItem(
-    uint32 id,
+    uint32_t id,
     const base::FilePath& current_path,
     const base::FilePath& target_path,
     const std::vector<GURL>& url_chain,
     const GURL& referrer_url,
     const std::string& mime_type,
     const std::string& original_mime_type,
     const base::Time& start_time,
     const base::Time& end_time,
     const std::string& etag,
     const std::string& last_modified,
-    int64 received_bytes,
-    int64 total_bytes,
+    int64_t received_bytes,
+    int64_t total_bytes,
     DownloadItem::DownloadState state,
     DownloadDangerType danger_type,
     DownloadInterruptReason interrupt_reason,
     bool opened) {
   if (ContainsKey(downloads_, id)) {
     NOTREACHED();
     return NULL;
   }
   DownloadItemImpl* item = item_factory_->CreatePersistedItem(
       this,
@@ skipping 40 matching lines @@
         it->second->GetDangerType() != DOWNLOAD_DANGER_TYPE_DANGEROUS_CONTENT &&
         it->second->GetDangerType() != DOWNLOAD_DANGER_TYPE_DANGEROUS_HOST &&
         it->second->GetDangerType() !=
             DOWNLOAD_DANGER_TYPE_POTENTIALLY_UNWANTED) {
       ++count;
     }
   }
   return count;
 }
 
-DownloadItem* DownloadManagerImpl::GetDownload(uint32 download_id) {
+DownloadItem* DownloadManagerImpl::GetDownload(uint32_t download_id) {
   return ContainsKey(downloads_, download_id) ? downloads_[download_id] : NULL;
 }
 
 void DownloadManagerImpl::GetAllDownloads(DownloadVector* downloads) {
   for (DownloadMap::iterator it = downloads_.begin();
        it != downloads_.end(); ++it) {
     downloads->push_back(it->second);
   }
 }
 
@@ skipping 11 matching lines @@
   if (delegate_)
     delegate_->OpenDownload(download);
 }
 
 void DownloadManagerImpl::ShowDownloadInShell(DownloadItemImpl* download) {
   if (delegate_)
     delegate_->ShowDownloadInShell(download);
 }
 
 }  // namespace content