Switch to standard integer types in content/browser/.

content/browser/indexed_db/indexed_db_active_blob_registry.cc

 // Copyright 2014 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 "base/bind.h"
 #include "base/location.h"
 #include "base/stl_util.h"
 #include "base/task_runner.h"
 #include "content/browser/indexed_db/indexed_db_active_blob_registry.h"
 #include "content/browser/indexed_db/indexed_db_backing_store.h"
 #include "content/browser/indexed_db/indexed_db_factory.h"
 #include "content/browser/indexed_db/indexed_db_leveldb_coding.h"
 
 namespace content {
 
 IndexedDBActiveBlobRegistry::IndexedDBActiveBlobRegistry(
     IndexedDBBackingStore* backing_store)
     : backing_store_(backing_store), weak_factory_(this) {}
 
 IndexedDBActiveBlobRegistry::~IndexedDBActiveBlobRegistry() {
 }
 
-void IndexedDBActiveBlobRegistry::AddBlobRef(int64 database_id,
-                                             int64 blob_key) {
+void IndexedDBActiveBlobRegistry::AddBlobRef(int64_t database_id,
+                                             int64_t blob_key) {
   DCHECK(backing_store_);
   DCHECK(backing_store_->task_runner()->RunsTasksOnCurrentThread());
   DCHECK(KeyPrefix::IsValidDatabaseId(database_id));
   DCHECK(DatabaseMetaDataKey::IsValidBlobKey(blob_key));
   DCHECK(!ContainsKey(deleted_dbs_, database_id));
   bool need_ref = use_tracker_.empty();
   SingleDBMap& single_db_map = use_tracker_[database_id];
   SingleDBMap::iterator iter = single_db_map.find(blob_key);
   if (iter == single_db_map.end()) {
     single_db_map[blob_key] = false;
     if (need_ref) {
       backing_store_->factory()->ReportOutstandingBlobs(
           backing_store_->origin_url(), true);
     }
   } else {
     DCHECK(!need_ref);
     DCHECK(!iter->second);  // You can't add a reference once it's been deleted.
   }
 }
 
-void IndexedDBActiveBlobRegistry::ReleaseBlobRef(int64 database_id,
-                                                 int64 blob_key) {
+void IndexedDBActiveBlobRegistry::ReleaseBlobRef(int64_t database_id,
+                                                 int64_t blob_key) {
   DCHECK(backing_store_);
   DCHECK(backing_store_->task_runner()->RunsTasksOnCurrentThread());
   DCHECK(KeyPrefix::IsValidDatabaseId(database_id));
   DCHECK(DatabaseMetaDataKey::IsValidBlobKey(blob_key));
   AllDBsMap::iterator db_pair = use_tracker_.find(database_id);
   if (db_pair == use_tracker_.end()) {
     NOTREACHED();
     return;
   }
   SingleDBMap& single_db = db_pair->second;
@@ skipping 18 matching lines @@
     }
   }
   if (delete_in_backend)
     backing_store_->ReportBlobUnused(database_id, blob_key);
   if (use_tracker_.empty()) {
     backing_store_->factory()->ReportOutstandingBlobs(
         backing_store_->origin_url(), false);
   }
 }
 
-bool IndexedDBActiveBlobRegistry::MarkDeletedCheckIfUsed(int64 database_id,
-                                                         int64 blob_key) {
+bool IndexedDBActiveBlobRegistry::MarkDeletedCheckIfUsed(int64_t database_id,
+                                                         int64_t blob_key) {
   DCHECK(backing_store_);
   DCHECK(backing_store_->task_runner()->RunsTasksOnCurrentThread());
   DCHECK(KeyPrefix::IsValidDatabaseId(database_id));
   AllDBsMap::iterator db_pair = use_tracker_.find(database_id);
   if (db_pair == use_tracker_.end())
     return false;
 
   if (blob_key == DatabaseMetaDataKey::kAllBlobsKey) {
     deleted_dbs_.insert(database_id);
     return true;
   }
 
   SingleDBMap& single_db = db_pair->second;
   SingleDBMap::iterator iter = single_db.find(blob_key);
   if (iter == single_db.end())
     return false;
 
   iter->second = true;
   return true;
 }
 
 void IndexedDBActiveBlobRegistry::ReleaseBlobRefThreadSafe(
     scoped_refptr<base::TaskRunner> task_runner,
     base::WeakPtr<IndexedDBActiveBlobRegistry> weak_ptr,
-    int64 database_id,
-    int64 blob_key,
+    int64_t database_id,
+    int64_t blob_key,
     const base::FilePath& unused) {
   task_runner->PostTask(FROM_HERE,
                         base::Bind(&IndexedDBActiveBlobRegistry::ReleaseBlobRef,
                                    weak_ptr,
                                    database_id,
                                    blob_key));
 }
 
 storage::ShareableFileReference::FinalReleaseCallback
-IndexedDBActiveBlobRegistry::GetFinalReleaseCallback(int64 database_id,
-                                                     int64 blob_key) {
+IndexedDBActiveBlobRegistry::GetFinalReleaseCallback(int64_t database_id,
+                                                     int64_t blob_key) {
   return base::Bind(
       &IndexedDBActiveBlobRegistry::ReleaseBlobRefThreadSafe,
       scoped_refptr<base::TaskRunner>(backing_store_->task_runner()),
       weak_factory_.GetWeakPtr(),
       database_id,
       blob_key);
 }
 
 base::Closure IndexedDBActiveBlobRegistry::GetAddBlobRefCallback(
-    int64 database_id,
-    int64 blob_key) {
+    int64_t database_id,
+    int64_t blob_key) {
   return base::Bind(&IndexedDBActiveBlobRegistry::AddBlobRef,
                     weak_factory_.GetWeakPtr(),
                     database_id,
                     blob_key);
 }
 
 void IndexedDBActiveBlobRegistry::ForceShutdown() {
   weak_factory_.InvalidateWeakPtrs();
   use_tracker_.clear();
   backing_store_ = NULL;
 }
 
 }  // namespace content