Convert to new WebIDBTypes enums and accessors

content/browser/indexed_db/indexed_db_leveldb_coding.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 <iterator>
 #include <limits>
 
 #include "base/logging.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_byteorder.h"
 #include "content/common/indexed_db/indexed_db_key.h"
 #include "content/common/indexed_db/indexed_db_key_path.h"
-#include "third_party/WebKit/public/platform/WebIDBKeyPath.h"
 
 // LevelDB stores key/value pairs. Keys and values are strings of bytes,
 // normally of type std::string.
 //
 // The keys in the backing store are variable-length tuples with different types
 // of fields. Each key in the backing store starts with a ternary prefix:
 // (database id, object store id, index id). For each, 0 is reserved for
 // meta-data.
 // The prefix makes sure that data for a specific database, object store, and
 // index are grouped together. The locality is important for performance: common
@@ skipping 116 matching lines @@
 // stale
 //     index data. Whenever new object store data is inserted, it gets a new
 //     "version" number, and new index data is written with this number. When
 //     the index is used for look-ups, entries are validated against the
 //     "exists" entries, and records with old "version" numbers are deleted
 //     when they are encountered in get_primary_key_via_index,
 //     IndexCursorImpl::load_current_row, and
 // IndexKeyCursorImpl::load_current_row).
 
 using base::StringPiece;
-using WebKit::WebIDBKey;
+using WebKit::WebIDBKeyType;
+using WebKit::WebIDBKeyTypeArray;
+using WebKit::WebIDBKeyTypeDate;
+using WebKit::WebIDBKeyTypeInvalid;
+using WebKit::WebIDBKeyTypeMin;
+using WebKit::WebIDBKeyTypeNull;
+using WebKit::WebIDBKeyTypeNumber;
+using WebKit::WebIDBKeyTypeString;
 using WebKit::WebIDBKeyPath;
+using WebKit::WebIDBKeyPathType;
+using WebKit::WebIDBKeyPathTypeArray;
+using WebKit::WebIDBKeyPathTypeNull;
+using WebKit::WebIDBKeyPathTypeString;
 
 namespace content {
 
 // As most of the IndexedDBKeys and encoded values are short, we
 // initialize some Vectors with a default inline buffer size to reduce
 // the memory re-allocations when the Vectors are appended.
 static const size_t kDefaultInlineBufferSize = 32;
 
 static const unsigned char kIndexedDBKeyNullTypeByte = 0;
 static const unsigned char kIndexedDBKeyStringTypeByte = 1;
@@ skipping 105 matching lines @@
 void EncodeDouble(double value, std::string* into) {
   // This always has host endianness.
   const char* p = reinterpret_cast<char*>(&value);
   into->insert(into->end(), p, p + sizeof(value));
 }
 
 void EncodeIDBKey(const IndexedDBKey& value, std::string* into) {
   size_t previous_size = into->size();
   DCHECK(value.IsValid());
   switch (value.type()) {
-    case WebIDBKey::NullType:
-    case WebIDBKey::InvalidType:
-    case WebIDBKey::MinType: {
+    case WebIDBKeyTypeNull:
+    case WebIDBKeyTypeInvalid:
+    case WebIDBKeyTypeMin: {
       NOTREACHED();
       EncodeByte(kIndexedDBKeyNullTypeByte, into);
       return;
     }
-    case WebIDBKey::ArrayType: {
+    case WebIDBKeyTypeArray: {
       EncodeByte(kIndexedDBKeyArrayTypeByte, into);
       size_t length = value.array().size();
       EncodeVarInt(length, into);
       for (size_t i = 0; i < length; ++i)
         EncodeIDBKey(value.array()[i], into);
       DCHECK_GT(into->size(), previous_size);
       return;
     }
-    case WebIDBKey::StringType: {
+    case WebIDBKeyTypeString: {
       EncodeByte(kIndexedDBKeyStringTypeByte, into);
       EncodeStringWithLength(value.string(), into);
       DCHECK_GT(into->size(), previous_size);
       return;
     }
-    case WebIDBKey::DateType: {
+    case WebIDBKeyTypeDate: {
       EncodeByte(kIndexedDBKeyDateTypeByte, into);
       EncodeDouble(value.date(), into);
       DCHECK_EQ(static_cast<size_t>(9),
                 static_cast<size_t>(into->size() - previous_size));
       return;
     }
-    case WebIDBKey::NumberType: {
+    case WebIDBKeyTypeNumber: {
       EncodeByte(kIndexedDBKeyNumberTypeByte, into);
       EncodeDouble(value.number(), into);
       DCHECK_EQ(static_cast<size_t>(9),
                 static_cast<size_t>(into->size() - previous_size));
       return;
     }
   }
 
   NOTREACHED();
 }
 
 void EncodeIDBKeyPath(const IndexedDBKeyPath& value, std::string* into) {
   // May be typed, or may be a raw string. An invalid leading
   // byte is used to identify typed coding. New records are
   // always written as typed.
   EncodeByte(kIndexedDBKeyPathTypeCodedByte1, into);
   EncodeByte(kIndexedDBKeyPathTypeCodedByte2, into);
   EncodeByte(static_cast<char>(value.type()), into);
   switch (value.type()) {
-    case WebIDBKeyPath::NullType:
+    case WebIDBKeyPathTypeNull:
       break;
-    case WebIDBKeyPath::StringType: {
+    case WebIDBKeyPathTypeString: {
       EncodeStringWithLength(value.string(), into);
       break;
     }
-    case WebIDBKeyPath::ArrayType: {
+    case WebIDBKeyPathTypeArray: {
       const std::vector<string16>& array = value.array();
       size_t count = array.size();
       EncodeVarInt(count, into);
       for (size_t i = 0; i < count; ++i) {
         EncodeStringWithLength(array[i], into);
       }
       break;
     }
   }
 }
@@ skipping 122 matching lines @@
       string16 s;
       if (!DecodeStringWithLength(slice, &s))
         return false;
       *value = make_scoped_ptr(new IndexedDBKey(s));
       return true;
     }
     case kIndexedDBKeyDateTypeByte: {
       double d;
       if (!DecodeDouble(slice, &d))
         return false;
-      *value = make_scoped_ptr(new IndexedDBKey(d, WebIDBKey::DateType));
+      *value = make_scoped_ptr(new IndexedDBKey(d, WebIDBKeyTypeDate));
       return true;
     }
     case kIndexedDBKeyNumberTypeByte: {
       double d;
       if (!DecodeDouble(slice, &d))
         return false;
-      *value = make_scoped_ptr(new IndexedDBKey(d, WebIDBKey::NumberType));
+      *value = make_scoped_ptr(new IndexedDBKey(d, WebIDBKeyTypeNumber));
       return true;
     }
   }
 
   NOTREACHED();
   return false;
 }
 
 bool DecodeDouble(StringPiece* slice, double* value) {
   if (slice->size() < sizeof(*value))
@@ skipping 12 matching lines @@
       (*slice)[1] != kIndexedDBKeyPathTypeCodedByte2) {
     string16 s;
     if (!DecodeString(slice, &s))
       return false;
     *value = IndexedDBKeyPath(s);
     return true;
   }
 
   slice->remove_prefix(2);
   DCHECK(!slice->empty());
-  WebIDBKeyPath::Type type = static_cast<WebIDBKeyPath::Type>((*slice)[0]);
+  WebIDBKeyPathType type = static_cast<WebIDBKeyPathType>((*slice)[0]);
   slice->remove_prefix(1);
 
   switch (type) {
-    case WebIDBKeyPath::NullType:
+    case WebIDBKeyPathTypeNull:
       DCHECK(slice->empty());
       *value = IndexedDBKeyPath();
       return true;
-    case WebIDBKeyPath::StringType: {
+    case WebIDBKeyPathTypeString: {
       string16 string;
       if (!DecodeStringWithLength(slice, &string))
         return false;
       DCHECK(slice->empty());
       *value = IndexedDBKeyPath(string);
       return true;
     }
-    case WebIDBKeyPath::ArrayType: {
+    case WebIDBKeyPathTypeArray: {
       std::vector<string16> array;
       int64 count;
       if (!DecodeVarInt(slice, &count))
         return false;
       DCHECK_GE(count, 0);
       while (count--) {
         string16 string;
         if (!DecodeStringWithLength(slice, &string))
           return false;
         array.push_back(string);
@@ skipping 48 matching lines @@
 bool ExtractEncodedIDBKey(StringPiece* slice, std::string* result) {
   const char* start = slice->begin();
   if (!ExtractEncodedIDBKey(slice))
     return 0;
 
   if (result)
     result->assign(start, slice->begin());
   return true;
 }
 
-static WebIDBKey::Type KeyTypeByteToKeyType(unsigned char type) {
+static WebIDBKeyType KeyTypeByteToKeyType(unsigned char type) {
   switch (type) {
     case kIndexedDBKeyNullTypeByte:
-      return WebIDBKey::InvalidType;
+      return WebIDBKeyTypeInvalid;
     case kIndexedDBKeyArrayTypeByte:
-      return WebIDBKey::ArrayType;
+      return WebIDBKeyTypeArray;
     case kIndexedDBKeyStringTypeByte:
-      return WebIDBKey::StringType;
+      return WebIDBKeyTypeString;
     case kIndexedDBKeyDateTypeByte:
-      return WebIDBKey::DateType;
+      return WebIDBKeyTypeDate;
     case kIndexedDBKeyNumberTypeByte:
-      return WebIDBKey::NumberType;
+      return WebIDBKeyTypeNumber;
     case kIndexedDBKeyMinKeyTypeByte:
-      return WebIDBKey::MinType;
+      return WebIDBKeyTypeMin;
   }
 
   NOTREACHED();
-  return WebIDBKey::InvalidType;
+  return WebIDBKeyTypeInvalid;
 }
 
 int CompareEncodedStringsWithLength(StringPiece* slice1,
                                     StringPiece* slice2,
                                     bool* ok) {
   int64 len1, len2;
   if (!DecodeVarInt(slice1, &len1) || !DecodeVarInt(slice2, &len2)) {
     *ok = false;
     return 0;
   }
@@ skipping 28 matching lines @@
   DCHECK_GE(b, 0);
 #endif
   int64 diff = a - b;
   if (diff < 0)
     return -1;
   if (diff > 0)
     return 1;
   return 0;
 }
 
-static int CompareTypes(WebIDBKey::Type a, WebIDBKey::Type b) { return b - a; }
+static int CompareTypes(WebIDBKeyType a, WebIDBKeyType b) { return b - a; }
 
 int CompareEncodedIDBKeys(StringPiece* slice_a,
                           StringPiece* slice_b,
                           bool* ok) {
   *ok = true;
   unsigned char type_a = (*slice_a)[0];
   unsigned char type_b = (*slice_b)[0];
   slice_a->remove_prefix(1);
   slice_b->remove_prefix(1);
 
@@ skipping 1205 matching lines @@
 scoped_ptr<IndexedDBKey> IndexDataKey::primary_key() const {
   scoped_ptr<IndexedDBKey> key;
   StringPiece slice(encoded_primary_key_);
   if (!DecodeIDBKey(&slice, &key)) {
     // TODO(jsbell): Return error.
   }
   return key.Pass();
 }
 
 }  // namespace content