Switch to standard integer types in content/browser/.

content/browser/indexed_db/indexed_db_backing_store_unittest.cc

 // Copyright (c) 2013 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/indexed_db/indexed_db_backing_store.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_simple_task_runner.h"
 #include "content/browser/indexed_db/indexed_db_context_impl.h"
@@ skipping 85 matching lines @@
       return scoped_refptr<TestableIndexedDBBackingStore>();
 
     return backing_store;
   }
 
   const std::vector<IndexedDBBackingStore::Transaction::WriteDescriptor>&
   writes() const {
     return writes_;
   }
   void ClearWrites() { writes_.clear(); }
-  const std::vector<int64>& removals() const { return removals_; }
+  const std::vector<int64_t>& removals() const { return removals_; }
   void ClearRemovals() { removals_.clear(); }
 
  protected:
   ~TestableIndexedDBBackingStore() override {}
 
   bool WriteBlobFile(
-      int64 database_id,
+      int64_t database_id,
       const Transaction::WriteDescriptor& descriptor,
       Transaction::ChainedBlobWriter* chained_blob_writer) override {
     if (KeyPrefix::IsValidDatabaseId(database_id_)) {
       if (database_id_ != database_id) {
         return false;
       }
     } else {
       database_id_ = database_id;
     }
     writes_.push_back(descriptor);
     task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&Transaction::ChainedBlobWriter::ReportWriteCompletion,
                    chained_blob_writer,
                    true,
                    1));
     return true;
   }
 
-  bool RemoveBlobFile(int64 database_id, int64 key) const override {
+  bool RemoveBlobFile(int64_t database_id, int64_t key) const override {
     if (database_id_ != database_id ||
         !KeyPrefix::IsValidDatabaseId(database_id)) {
       return false;
     }
     removals_.push_back(key);
     return true;
   }
 
   // Timers don't play nicely with unit tests.
   void StartJournalCleaningTimer() override {
@@ skipping 10 matching lines @@
                                 base::SequencedTaskRunner* task_runner)
       : IndexedDBBackingStore(indexed_db_factory,
                               origin_url,
                               blob_path,
                               request_context,
                               db.Pass(),
                               comparator.Pass(),
                               task_runner),
         database_id_(0) {}
 
-  int64 database_id_;
+  int64_t database_id_;
   std::vector<Transaction::WriteDescriptor> writes_;
 
   // This is modified in an overridden virtual function that is properly const
   // in the real implementation, therefore must be mutable here.
-  mutable std::vector<int64> removals_;
+  mutable std::vector<int64_t> removals_;
 
   DISALLOW_COPY_AND_ASSIGN(TestableIndexedDBBackingStore);
 };
 
 class TestIDBFactory : public IndexedDBFactoryImpl {
  public:
   explicit TestIDBFactory(IndexedDBContextImpl* idb_context)
       : IndexedDBFactoryImpl(idb_context) {}
 
   scoped_refptr<TestableIndexedDBBackingStore> OpenBackingStoreForTest(
@@ skipping 102 matching lines @@
           return false;
       }
     }
     return true;
   }
 
   bool CheckBlobReadsMatchWrites(
       const std::vector<IndexedDBBlobInfo>& reads) const {
     if (backing_store_->writes().size() != reads.size())
       return false;
-    std::set<int64> ids;
+    std::set<int64_t> ids;
     for (size_t i = 0; i < backing_store_->writes().size(); ++i)
       ids.insert(backing_store_->writes()[i].key());
     if (ids.size() != backing_store_->writes().size())
       return false;
     for (size_t i = 0; i < reads.size(); ++i) {
       if (ids.count(reads[i].key()) != 1)
         return false;
     }
     return true;
   }
@@ skipping 437 matching lines @@
     }
     task_runner_->RunUntilIdle();
     EXPECT_NE(0U, backing_store_->removals().size());
     EXPECT_TRUE(CheckBlobRemovals());
   }
 }
 
 // Make sure that using very high ( more than 32 bit ) values for database_id
 // and object_store_id still work.
 TEST_F(IndexedDBBackingStoreTest, HighIds) {
-  const int64 high_database_id = 1ULL << 35;
-  const int64 high_object_store_id = 1ULL << 39;
+  const int64_t high_database_id = 1ULL << 35;
+  const int64_t high_object_store_id = 1ULL << 39;
   // index_ids are capped at 32 bits for storage purposes.
-  const int64 high_index_id = 1ULL << 29;
+  const int64_t high_index_id = 1ULL << 29;
 
-  const int64 invalid_high_index_id = 1ULL << 37;
+  const int64_t invalid_high_index_id = 1ULL << 37;
 
   const IndexedDBKey& index_key = m_key2;
   std::string index_key_raw;
   EncodeIDBKey(index_key, &index_key_raw);
   {
     IndexedDBBackingStore::Transaction transaction1(backing_store_.get());
     transaction1.Begin();
     ScopedVector<storage::BlobDataHandle> handles;
     IndexedDBBackingStore::RecordIdentifier record;
     leveldb::Status s = backing_store_->PutRecord(&transaction1,
@@ skipping 66 matching lines @@
     EXPECT_TRUE(callback->called);
     EXPECT_TRUE(callback->succeeded);
     s = transaction2.CommitPhaseTwo();
     EXPECT_TRUE(s.ok());
   }
 }
 
 // Make sure that other invalid ids do not crash.
 TEST_F(IndexedDBBackingStoreTest, InvalidIds) {
   // valid ids for use when testing invalid ids
-  const int64 database_id = 1;
-  const int64 object_store_id = 1;
-  const int64 index_id = kMinimumIndexId;
-  const int64 invalid_low_index_id = 19;  // index_ids must be > kMinimumIndexId
+  const int64_t database_id = 1;
+  const int64_t object_store_id = 1;
+  const int64_t index_id = kMinimumIndexId;
+  const int64_t invalid_low_index_id =
+      19;  // index_ids must be > kMinimumIndexId
 
   IndexedDBValue result_value;
 
   IndexedDBBackingStore::Transaction transaction1(backing_store_.get());
   transaction1.Begin();
 
   ScopedVector<storage::BlobDataHandle> handles;
   IndexedDBBackingStore::RecordIdentifier record;
   leveldb::Status s = backing_store_->PutRecord(&transaction1,
                                                 database_id,
@@ skipping 64 matching lines @@
                                             database_id,
                                             KeyPrefix::kInvalidId,
                                             index_id,
                                             m_key1,
                                             &new_primary_key);
   EXPECT_FALSE(s.ok());
 }
 
 TEST_F(IndexedDBBackingStoreTest, CreateDatabase) {
   const base::string16 database_name(ASCIIToUTF16("db1"));
-  int64 database_id;
+  int64_t database_id;
   const base::string16 version(ASCIIToUTF16("old_string_version"));
-  const int64 int_version = 9;
+  const int64_t int_version = 9;
 
-  const int64 object_store_id = 99;
+  const int64_t object_store_id = 99;
   const base::string16 object_store_name(ASCIIToUTF16("object_store1"));
   const bool auto_increment = true;
   const IndexedDBKeyPath object_store_key_path(
       ASCIIToUTF16("object_store_key"));
 
-  const int64 index_id = 999;
+  const int64_t index_id = 999;
   const base::string16 index_name(ASCIIToUTF16("index1"));
   const bool unique = true;
   const bool multi_entry = true;
   const IndexedDBKeyPath index_key_path(ASCIIToUTF16("index_key"));
 
   {
     leveldb::Status s = backing_store_->CreateIDBDatabaseMetaData(
         database_name, version, int_version, &database_id);
     EXPECT_TRUE(s.ok());
     EXPECT_GT(database_id, 0);
@@ skipping 57 matching lines @@
     EXPECT_EQ(index_key_path, index.key_path);
     EXPECT_EQ(unique, index.unique);
     EXPECT_EQ(multi_entry, index.multi_entry);
   }
 }
 
 TEST_F(IndexedDBBackingStoreTest, GetDatabaseNames) {
   const base::string16 string_version(ASCIIToUTF16("string_version"));
 
   const base::string16 db1_name(ASCIIToUTF16("db1"));
-  const int64 db1_version = 1LL;
-  int64 db1_id;
+  const int64_t db1_version = 1LL;
+  int64_t db1_id;
 
   // Database records with DEFAULT_INT_VERSION represent stale data,
   // and should not be enumerated.
   const base::string16 db2_name(ASCIIToUTF16("db2"));
-  const int64 db2_version = IndexedDBDatabaseMetadata::DEFAULT_INT_VERSION;
-  int64 db2_id;
+  const int64_t db2_version = IndexedDBDatabaseMetadata::DEFAULT_INT_VERSION;
+  int64_t db2_id;
 
   leveldb::Status s = backing_store_->CreateIDBDatabaseMetaData(
       db1_name, string_version, db1_version, &db1_id);
   EXPECT_TRUE(s.ok());
   EXPECT_GT(db1_id, 0LL);
 
   s = backing_store_->CreateIDBDatabaseMetaData(
       db2_name, string_version, db2_version, &db2_id);
   EXPECT_TRUE(s.ok());
   EXPECT_GT(db2_id, db1_id);
 
   std::vector<base::string16> names = backing_store_->GetDatabaseNames(&s);
   EXPECT_TRUE(s.ok());
   EXPECT_EQ(names.size(), 1ULL);
   EXPECT_EQ(names[0], db1_name);
 }
 
 }  // namespace
 
 }  // namespace content