Indexed DB: Rename "int version" to "version"

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 <utility>
 
@@ skipping 923 matching lines @@
                                             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_t database_id;
-  const base::string16 version(ASCIIToUTF16("old_string_version"));
-  const int64_t int_version = 9;
+  const int64_t version = 9;
 
   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_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, int_version, &database_id);
+        database_name, version, &database_id);
     EXPECT_TRUE(s.ok());
     EXPECT_GT(database_id, 0);
 
     IndexedDBBackingStore::Transaction transaction(backing_store_.get());
     transaction.Begin();
 
     s = backing_store_->CreateObjectStore(&transaction,
                                           database_id,
                                           object_store_id,
                                           object_store_name,
@@ skipping 22 matching lines @@
 
   {
     IndexedDBDatabaseMetadata database;
     bool found;
     leveldb::Status s = backing_store_->GetIDBDatabaseMetaData(
         database_name, &database, &found);
     EXPECT_TRUE(s.ok());
     EXPECT_TRUE(found);
 
     // database.name is not filled in by the implementation.
-    EXPECT_EQ(int_version, database.int_version);
+    EXPECT_EQ(version, database.version);
     EXPECT_EQ(database_id, database.id);
 
     s = backing_store_->GetObjectStores(database.id, &database.object_stores);
     EXPECT_TRUE(s.ok());
 
     EXPECT_EQ(1UL, database.object_stores.size());
     IndexedDBObjectStoreMetadata object_store =
         database.object_stores[object_store_id];
     EXPECT_EQ(object_store_name, object_store.name);
     EXPECT_EQ(object_store_key_path, object_store.key_path);
     EXPECT_EQ(auto_increment, object_store.auto_increment);
 
     EXPECT_EQ(1UL, object_store.indexes.size());
     IndexedDBIndexMetadata index = object_store.indexes[index_id];
     EXPECT_EQ(index_name, index.name);
     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 db1_name(ASCIIToUTF16("db1"));
   const int64_t db1_version = 1LL;
   int64_t db1_id;
 
-  // Database records with DEFAULT_INT_VERSION represent stale data,
+  // Database records with DEFAULT_VERSION represent stale data,
   // and should not be enumerated.
   const base::string16 db2_name(ASCIIToUTF16("db2"));
-  const int64_t db2_version = IndexedDBDatabaseMetadata::DEFAULT_INT_VERSION;
+  const int64_t db2_version = IndexedDBDatabaseMetadata::DEFAULT_VERSION;
   int64_t db2_id;
 
   leveldb::Status s =
       backing_store_->CreateIDBDatabaseMetaData(db1_name, db1_version, &db1_id);
   EXPECT_TRUE(s.ok());
   EXPECT_GT(db1_id, 0LL);
 
   s = backing_store_->CreateIDBDatabaseMetaData(db2_name, 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