Convert to new WebIDBTypes enums and accessors

content/browser/indexed_db/indexed_db_leveldb_coding_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_leveldb_coding.h"
 
 #include <limits>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/common/indexed_db/indexed_db_key.h"
 #include "content/common/indexed_db/indexed_db_key_path.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
-using WebKit::WebIDBKey;
-using WebKit::WebIDBKeyPath;
+using WebKit::WebIDBKeyTypeDate;
+using WebKit::WebIDBKeyTypeNumber;
 
 namespace content {
 
 namespace {
 
 static IndexedDBKey CreateArrayIDBKey() {
   return IndexedDBKey(IndexedDBKey::KeyArray());
 }
 
 static IndexedDBKey CreateArrayIDBKey(const IndexedDBKey& key1) {
@@ skipping 88 matching lines @@
 
 TEST(IndexedDBLevelDBCodingTest, MaxIDBKey) {
   std::string max_key = MaxIDBKey();
 
   std::string min_key = MinIDBKey();
   std::string array_key;
   EncodeIDBKey(IndexedDBKey(IndexedDBKey::KeyArray()), &array_key);
   std::string string_key;
   EncodeIDBKey(IndexedDBKey(ASCIIToUTF16("Hello world")), &string_key);
   std::string number_key;
-  EncodeIDBKey(IndexedDBKey(3.14, WebIDBKey::NumberType), &number_key);
+  EncodeIDBKey(IndexedDBKey(3.14, WebIDBKeyTypeNumber), &number_key);
   std::string date_key;
-  EncodeIDBKey(IndexedDBKey(1000000, WebIDBKey::DateType), &date_key);
+  EncodeIDBKey(IndexedDBKey(1000000, WebIDBKeyTypeDate), &date_key);
 
   EXPECT_GT(CompareKeys(max_key, min_key), 0);
   EXPECT_GT(CompareKeys(max_key, array_key), 0);
   EXPECT_GT(CompareKeys(max_key, string_key), 0);
   EXPECT_GT(CompareKeys(max_key, number_key), 0);
   EXPECT_GT(CompareKeys(max_key, date_key), 0);
 }
 
 TEST(IndexedDBLevelDBCodingTest, MinIDBKey) {
   std::string min_key = MinIDBKey();
 
   std::string max_key = MaxIDBKey();
   std::string array_key;
   EncodeIDBKey(IndexedDBKey(IndexedDBKey::KeyArray()), &array_key);
   std::string string_key;
   EncodeIDBKey(IndexedDBKey(ASCIIToUTF16("Hello world")), &string_key);
   std::string number_key;
-  EncodeIDBKey(IndexedDBKey(3.14, WebIDBKey::NumberType), &number_key);
+  EncodeIDBKey(IndexedDBKey(3.14, WebIDBKeyTypeNumber), &number_key);
   std::string date_key;
-  EncodeIDBKey(IndexedDBKey(1000000, WebIDBKey::DateType), &date_key);
+  EncodeIDBKey(IndexedDBKey(1000000, WebIDBKeyTypeDate), &date_key);
 
   EXPECT_LT(CompareKeys(min_key, max_key), 0);
   EXPECT_LT(CompareKeys(min_key, array_key), 0);
   EXPECT_LT(CompareKeys(min_key, string_key), 0);
   EXPECT_LT(CompareKeys(min_key, number_key), 0);
   EXPECT_LT(CompareKeys(min_key, date_key), 0);
 }
 
 static std::string WrappedEncodeInt(int64 value) {
   std::string buffer;
@@ skipping 352 matching lines @@
   }
 }
 
 TEST(IndexedDBLevelDBCodingTest, EncodeDecodeIDBKey) {
   IndexedDBKey expected_key;
   scoped_ptr<IndexedDBKey> decoded_key;
   std::string v;
   StringPiece slice;
 
   std::vector<IndexedDBKey> test_cases;
-  test_cases.push_back(IndexedDBKey(1234, WebIDBKey::NumberType));
-  test_cases.push_back(IndexedDBKey(7890, WebIDBKey::DateType));
+  test_cases.push_back(IndexedDBKey(1234, WebIDBKeyTypeNumber));
+  test_cases.push_back(IndexedDBKey(7890, WebIDBKeyTypeDate));
   test_cases.push_back(IndexedDBKey(ASCIIToUTF16("Hello World!")));
   test_cases.push_back(IndexedDBKey(IndexedDBKey::KeyArray()));
 
   IndexedDBKey::KeyArray array;
-  array.push_back(IndexedDBKey(1234, WebIDBKey::NumberType));
-  array.push_back(IndexedDBKey(7890, WebIDBKey::DateType));
+  array.push_back(IndexedDBKey(1234, WebIDBKeyTypeNumber));
+  array.push_back(IndexedDBKey(7890, WebIDBKeyTypeDate));
   array.push_back(IndexedDBKey(ASCIIToUTF16("Hello World!")));
   array.push_back(IndexedDBKey(IndexedDBKey::KeyArray()));
   test_cases.push_back(IndexedDBKey(array));
 
   for (size_t i = 0; i < test_cases.size(); ++i) {
     expected_key = test_cases[i];
     v.clear();
     EncodeIDBKey(expected_key, &v);
     slice = StringPiece(&*v.begin(), v.size());
     EXPECT_TRUE(DecodeIDBKey(&slice, &decoded_key));
@@ skipping 121 matching lines @@
     IndexedDBKeyPath decoded;
     EXPECT_TRUE(DecodeIDBKeyPath(&slice, &decoded));
     EXPECT_EQ(key_path, decoded);
     EXPECT_TRUE(slice.empty());
   }
 }
 
 TEST(IndexedDBLevelDBCodingTest, ExtractAndCompareIDBKeys) {
   std::vector<IndexedDBKey> keys;
 
-  keys.push_back(IndexedDBKey(-10, WebIDBKey::NumberType));
-  keys.push_back(IndexedDBKey(0, WebIDBKey::NumberType));
-  keys.push_back(IndexedDBKey(3.14, WebIDBKey::NumberType));
+  keys.push_back(IndexedDBKey(-10, WebIDBKeyTypeNumber));
+  keys.push_back(IndexedDBKey(0, WebIDBKeyTypeNumber));
+  keys.push_back(IndexedDBKey(3.14, WebIDBKeyTypeNumber));
 
-  keys.push_back(IndexedDBKey(0, WebIDBKey::DateType));
-  keys.push_back(IndexedDBKey(100, WebIDBKey::DateType));
-  keys.push_back(IndexedDBKey(100000, WebIDBKey::DateType));
+  keys.push_back(IndexedDBKey(0, WebIDBKeyTypeDate));
+  keys.push_back(IndexedDBKey(100, WebIDBKeyTypeDate));
+  keys.push_back(IndexedDBKey(100000, WebIDBKeyTypeDate));
 
   keys.push_back(IndexedDBKey(ASCIIToUTF16("")));
   keys.push_back(IndexedDBKey(ASCIIToUTF16("a")));
   keys.push_back(IndexedDBKey(ASCIIToUTF16("b")));
   keys.push_back(IndexedDBKey(ASCIIToUTF16("baaa")));
   keys.push_back(IndexedDBKey(ASCIIToUTF16("baab")));
   keys.push_back(IndexedDBKey(ASCIIToUTF16("c")));
 
   keys.push_back(CreateArrayIDBKey());
-  keys.push_back(CreateArrayIDBKey(IndexedDBKey(0, WebIDBKey::NumberType)));
-  keys.push_back(CreateArrayIDBKey(IndexedDBKey(0, WebIDBKey::NumberType),
-                                   IndexedDBKey(3.14, WebIDBKey::NumberType)));
-  keys.push_back(CreateArrayIDBKey(IndexedDBKey(0, WebIDBKey::DateType)));
-  keys.push_back(CreateArrayIDBKey(IndexedDBKey(0, WebIDBKey::DateType),
-                                   IndexedDBKey(0, WebIDBKey::DateType)));
+  keys.push_back(CreateArrayIDBKey(IndexedDBKey(0, WebIDBKeyTypeNumber)));
+  keys.push_back(CreateArrayIDBKey(IndexedDBKey(0, WebIDBKeyTypeNumber),
+                                   IndexedDBKey(3.14, WebIDBKeyTypeNumber)));
+  keys.push_back(CreateArrayIDBKey(IndexedDBKey(0, WebIDBKeyTypeDate)));
+  keys.push_back(CreateArrayIDBKey(IndexedDBKey(0, WebIDBKeyTypeDate),
+                                   IndexedDBKey(0, WebIDBKeyTypeDate)));
   keys.push_back(CreateArrayIDBKey(IndexedDBKey(ASCIIToUTF16(""))));
   keys.push_back(CreateArrayIDBKey(IndexedDBKey(ASCIIToUTF16("")),
                                    IndexedDBKey(ASCIIToUTF16("a"))));
   keys.push_back(CreateArrayIDBKey(CreateArrayIDBKey()));
   keys.push_back(CreateArrayIDBKey(CreateArrayIDBKey(), CreateArrayIDBKey()));
   keys.push_back(CreateArrayIDBKey(CreateArrayIDBKey(CreateArrayIDBKey())));
   keys.push_back(CreateArrayIDBKey(
       CreateArrayIDBKey(CreateArrayIDBKey(CreateArrayIDBKey()))));
 
   for (size_t i = 0; i < keys.size() - 1; ++i) {
@@ skipping 134 matching lines @@
     std::string vB = WrappedEncodeVarInt(static_cast<int64>(n));
 
     EXPECT_EQ(vA.size(), vB.size());
     EXPECT_EQ(*vA.begin(), *vB.begin());
   }
 }
 
 }  // namespace
 
 }  // namespace content