Migrate the IndexedDB backend from Blink to Chromium

content/browser/indexed_db/indexed_db_leveldb_coding.h

+// 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.
+
+#ifndef CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_LEVELDB_CODING_H_
+#define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_LEVELDB_CODING_H_
+
+#include <vector>
+
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/string16.h"
+#include "content/common/indexed_db/indexed_db_key.h"
+#include "content/common/indexed_db/indexed_db_key_path.h"
+
+namespace content {
+
+class LevelDBSlice;
+
+namespace IndexedDBLevelDBCoding {
+
+const unsigned char MinimumIndexId = 30;
+
+// 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 DefaultInlineBufferSize = 32;
+
+CONTENT_EXPORT std::vector<char> EncodeByte(unsigned char);
+CONTENT_EXPORT const char* DecodeByte(const char* p,
+                                      const char* limit,
+                                      unsigned char& found_char);
+CONTENT_EXPORT std::vector<char> MaxIDBKey();
+CONTENT_EXPORT std::vector<char> MinIDBKey();
+CONTENT_EXPORT std::vector<char> EncodeBool(bool value);
+CONTENT_EXPORT bool DecodeBool(const char* begin, const char* end);
+CONTENT_EXPORT std::vector<char> EncodeInt(int64_t);
+inline std::vector<char> EncodeIntSafely(int64_t nParam, int64_t max) {
+  DCHECK(nParam <= max);
+  return EncodeInt(nParam);
+}
+
+template <class T> int64_t DecodeInt(T begin, T end) {
+  DCHECK(begin <= end);
+  int64_t ret = 0;
+
+  int shift = 0;
+  while (begin < end) {
+    unsigned char c = *begin++;
+    ret |= static_cast<int64_t>(c) << shift;
+    shift += 8;
+  }
+
+  return ret;
+}
+
+CONTENT_EXPORT std::vector<char> EncodeVarInt(int64_t);
+
+CONTENT_EXPORT const char* DecodeVarInt(const char* p,
+                                        const char* limit,
+                                        int64_t& found_int);
+CONTENT_EXPORT std::vector<char>::iterator DecodeVarInt(
+    std::vector<char>::iterator start,
+    std::vector<char>::iterator limit,
+    int64_t& found_int);
+
+CONTENT_EXPORT std::vector<char> EncodeString(const string16&);
+CONTENT_EXPORT string16 DecodeString(const char* p, const char* end);
+CONTENT_EXPORT std::vector<char> EncodeStringWithLength(const string16&);
+CONTENT_EXPORT const char* DecodeStringWithLength(const char* p,
+                                                  const char* limit,
+                                                  string16& found_string);
+CONTENT_EXPORT int CompareEncodedStringsWithLength(const char*& p,
+                                                   const char* limit_p,
+                                                   const char*& q,
+                                                   const char* limit_q,
+                                                   bool& ok);
+CONTENT_EXPORT std::vector<char> EncodeDouble(double value);
+CONTENT_EXPORT const char* DecodeDouble(const char* p,
+                                        const char* limit,
+                                        double*);
+void EncodeIDBKey(const IndexedDBKey& key, std::vector<char>& into);
+CONTENT_EXPORT std::vector<char> EncodeIDBKey(const IndexedDBKey&);
+CONTENT_EXPORT const char* DecodeIDBKey(const char* p,
+                                        const char* limit,
+                                        scoped_ptr<IndexedDBKey>* found_key);
+CONTENT_EXPORT const char* ExtractEncodedIDBKey(const char* start,
+                                                const char* limit,
+                                                std::vector<char>* result);
+CONTENT_EXPORT int CompareEncodedIDBKeys(const std::vector<char>&,
+                                         const std::vector<char>&,
+                                         bool& ok);
+CONTENT_EXPORT std::vector<char> EncodeIDBKeyPath(const IndexedDBKeyPath&);
+CONTENT_EXPORT IndexedDBKeyPath DecodeIDBKeyPath(const char*, const char*);
+
+CONTENT_EXPORT int Compare(const LevelDBSlice&,
+                           const LevelDBSlice&,
+                           bool index_keys = false);
+
+class KeyPrefix {
+ public:
+  KeyPrefix();
+  explicit KeyPrefix(int64_t database_id);
+  KeyPrefix(int64_t database_id, int64_t object_store_id);
+  KeyPrefix(int64_t database_id, int64_t object_store_id, int64_t index_id);
+  static KeyPrefix CreateWithSpecialIndex(int64_t database_id,
+                                          int64_t object_store_id,
+                                          int64_t index_id);
+
+  static const char* Decode(const char* start,
+                            const char* limit,
+                            KeyPrefix* result);
+  std::vector<char> Encode() const;
+  static std::vector<char> EncodeEmpty();
+  int Compare(const KeyPrefix& other) const;
+
+  enum Type {
+    GlobalMetaData,
+    DatabaseMetaData,
+    ObjectStoreData,
+    ExistsEntry,
+    IndexData,
+    InvalidType
+  };
+
+  static const size_t kMaxDatabaseIdSizeBits = 3;
+  static const size_t kMaxObjectStoreIdSizeBits = 3;
+  static const size_t kMaxIndexIdSizeBits = 2;
+
+  static const size_t kMaxDatabaseIdSizeBytes =
+      1ULL << kMaxDatabaseIdSizeBits;                                      // 8
+  static const size_t kMaxObjectStoreIdSizeBytes =
+      1ULL << kMaxObjectStoreIdSizeBits;                                   // 8
+  static const size_t kMaxIndexIdSizeBytes = 1ULL << kMaxIndexIdSizeBits;  // 4
+
+  static const size_t kMaxDatabaseIdBits =
+      kMaxDatabaseIdSizeBytes * 8 - 1;                                 // 63
+  static const size_t kMaxObjectStoreIdBits =
+      kMaxObjectStoreIdSizeBytes * 8 - 1;                              // 63
+  static const size_t kMaxIndexIdBits = kMaxIndexIdSizeBytes * 8 - 1;  // 31
+
+  static const int64_t kMaxDatabaseId =
+      (1ULL << kMaxDatabaseIdBits) - 1;     // max signed int64_t
+  static const int64_t kMaxObjectStoreId =
+      (1ULL << kMaxObjectStoreIdBits) - 1;  // max signed int64_t
+  static const int64_t kMaxIndexId =
+      (1ULL << kMaxIndexIdBits) - 1;        // max signed int32_t
+
+  static bool IsValidDatabaseId(int64_t database_id);
+  static bool IsValidObjectStoreId(int64_t index_id);
+  static bool IsValidIndexId(int64_t index_id);
+  static bool ValidIds(int64_t database_id,
+                       int64_t object_store_id,
+                       int64_t index_id) {
+    return IsValidDatabaseId(database_id) &&
+           IsValidObjectStoreId(object_store_id) && IsValidIndexId(index_id);
+  }
+  static bool ValidIds(int64_t database_id, int64_t object_store_id) {
+    return IsValidDatabaseId(database_id) &&
+           IsValidObjectStoreId(object_store_id);
+  }
+
+  Type type() const;
+
+  int64_t database_id_;
+  int64_t object_store_id_;
+  int64_t index_id_;
+
+  static const int64_t InvalidId = -1;
+
+ private:
+  static std::vector<char> EncodeInternal(int64_t database_id,
+                                          int64_t object_store_id,
+                                          int64_t index_id);
+  // Special constructor for CreateWithSpecialIndex()
+  KeyPrefix(enum Type,
+            int64_t database_id,
+            int64_t object_store_id,
+            int64_t index_id);
+};
+
+class SchemaVersionKey {
+ public:
+  CONTENT_EXPORT static std::vector<char> Encode();
+};
+
+class MaxDatabaseIdKey {
+ public:
+  CONTENT_EXPORT static std::vector<char> Encode();
+};
+
+class DataVersionKey {
+ public:
+  static std::vector<char> Encode();
+};
+
+class DatabaseFreeListKey {
+ public:
+  DatabaseFreeListKey();
+  static const char* Decode(const char* start,
+                            const char* limit,
+                            DatabaseFreeListKey* result);
+  CONTENT_EXPORT static std::vector<char> Encode(int64_t database_id);
+  static CONTENT_EXPORT std::vector<char> EncodeMaxKey();
+  int64_t DatabaseId() const;
+  int Compare(const DatabaseFreeListKey& other) const;
+
+ private:
+  int64_t database_id_;
+};
+
+class DatabaseNameKey {
+ public:
+  static const char* Decode(const char* start,
+                            const char* limit,
+                            DatabaseNameKey* result);
+  CONTENT_EXPORT static std::vector<char> Encode(const string16& origin,
+                                                 const string16& database_name);
+  static std::vector<char> EncodeMinKeyForOrigin(const string16& origin);
+  static std::vector<char> EncodeStopKeyForOrigin(const string16& origin);
+  string16 origin() const { return origin_; }
+  string16 database_name() const { return database_name_; }
+  int Compare(const DatabaseNameKey& other);
+
+ private:
+  string16 origin_;  // TODO: Store encoded strings, or just pointers.
+  string16 database_name_;
+};
+
+class DatabaseMetaDataKey {
+ public:
+  enum MetaDataType {
+    OriginName = 0,
+    DatabaseName = 1,
+    UserVersion = 2,
+    MaxObjectStoreId = 3,
+    UserIntVersion = 4,
+    MaxSimpleMetaDataType = 5
+  };
+
+  CONTENT_EXPORT static std::vector<char> Encode(int64_t database_id,
+                                                 MetaDataType);
+};
+
+class ObjectStoreMetaDataKey {
+ public:
+  enum MetaDataType {
+    Name = 0,
+    KeyPath = 1,
+    AutoIncrement = 2,
+    Evictable = 3,
+    LastVersion = 4,
+    MaxIndexId = 5,
+    HasKeyPath = 6,
+    KeyGeneratorCurrentNumber = 7
+  };
+
+  ObjectStoreMetaDataKey();
+  static const char* Decode(const char* start,
+                            const char* limit,
+                            ObjectStoreMetaDataKey* result);
+  CONTENT_EXPORT static std::vector<char> Encode(int64_t database_id,
+                                                 int64_t object_store_id,
+                                                 unsigned char meta_data_type);
+  CONTENT_EXPORT static std::vector<char> EncodeMaxKey(int64_t database_id);
+  CONTENT_EXPORT static std::vector<char> EncodeMaxKey(int64_t database_id,
+                                                       int64_t object_store_id);
+  int64_t ObjectStoreId() const;
+  unsigned char MetaDataType() const;
+  int Compare(const ObjectStoreMetaDataKey& other);
+
+ private:
+  int64_t object_store_id_;
+  unsigned char meta_data_type_;
+};
+
+class IndexMetaDataKey {
+ public:
+  enum MetaDataType {
+    Name = 0,
+    Unique = 1,
+    KeyPath = 2,
+    MultiEntry = 3
+  };
+
+  IndexMetaDataKey();
+  static const char* Decode(const char* start,
+                            const char* limit,
+                            IndexMetaDataKey* result);
+  CONTENT_EXPORT static std::vector<char> Encode(int64_t database_id,
+                                                 int64_t object_store_id,
+                                                 int64_t index_id,
+                                                 unsigned char meta_data_type);
+  CONTENT_EXPORT static std::vector<char> EncodeMaxKey(int64_t database_id,
+                                                       int64_t object_store_id);
+  CONTENT_EXPORT static std::vector<char> EncodeMaxKey(int64_t database_id,
+                                                       int64_t object_store_id,
+                                                       int64_t index_id);
+  int Compare(const IndexMetaDataKey& other);
+  int64_t IndexId() const;
+  unsigned char meta_data_type() const { return meta_data_type_; }
+
+ private:
+  int64_t object_store_id_;
+  int64_t index_id_;
+  unsigned char meta_data_type_;
+};
+
+class ObjectStoreFreeListKey {
+ public:
+  ObjectStoreFreeListKey();
+  static const char* Decode(const char* start,
+                            const char* limit,
+                            ObjectStoreFreeListKey* result);
+  CONTENT_EXPORT static std::vector<char> Encode(int64_t database_id,
+                                                 int64_t object_store_id);
+  CONTENT_EXPORT static std::vector<char> EncodeMaxKey(int64_t database_id);
+  int64_t ObjectStoreId() const;
+  int Compare(const ObjectStoreFreeListKey& other);
+
+ private:
+  int64_t object_store_id_;
+};
+
+class IndexFreeListKey {
+ public:
+  IndexFreeListKey();
+  static const char* Decode(const char* start,
+                            const char* limit,
+                            IndexFreeListKey* result);
+  CONTENT_EXPORT static std::vector<char> Encode(int64_t database_id,
+                                                 int64_t object_store_id,
+                                                 int64_t index_id);
+  CONTENT_EXPORT static std::vector<char> EncodeMaxKey(int64_t database_id,
+                                                       int64_t object_store_id);
+  int Compare(const IndexFreeListKey& other);
+  int64_t ObjectStoreId() const;
+  int64_t IndexId() const;
+
+ private:
+  int64_t object_store_id_;
+  int64_t index_id_;
+};
+
+class ObjectStoreNamesKey {
+ public:
+  // TODO: We never use this to look up object store ids, because a mapping
+  // is kept in the IndexedDBDatabaseImpl. Can the mapping become unreliable?
+  // Can we remove this?
+  static const char* Decode(const char* start,
+                            const char* limit,
+                            ObjectStoreNamesKey* result);
+  CONTENT_EXPORT static std::vector<char> Encode(
+      int64_t database_id,
+      const string16& object_store_name);
+  int Compare(const ObjectStoreNamesKey& other);
+  string16 object_store_name() const { return object_store_name_; }
+
+ private:
+  string16 object_store_name_;  // TODO: Store the encoded string, or just
+                                // pointers to it.
+};
+
+class IndexNamesKey {
+ public:
+  IndexNamesKey();
+  // TODO: We never use this to look up index ids, because a mapping
+  // is kept at a higher level.
+  static const char* Decode(const char* start,
+                            const char* limit,
+                            IndexNamesKey* result);
+  CONTENT_EXPORT static std::vector<char> Encode(int64_t database_id,
+                                                 int64_t object_store_id,
+                                                 const string16& index_name);
+  int Compare(const IndexNamesKey& other);
+  string16 index_name() const { return index_name_; }
+
+ private:
+  int64_t object_store_id_;
+  string16 index_name_;
+};
+
+class ObjectStoreDataKey {
+ public:
+  static const char* Decode(const char* start,
+                            const char* end,
+                            ObjectStoreDataKey* result);
+  CONTENT_EXPORT static std::vector<char> Encode(
+      int64_t database_id,
+      int64_t object_store_id,
+      const std::vector<char> encoded_user_key);
+  static std::vector<char> Encode(int64_t database_id,
+                                  int64_t object_store_id,
+                                  const IndexedDBKey& user_key);
+  int Compare(const ObjectStoreDataKey& other, bool& ok);
+  scoped_ptr<IndexedDBKey> user_key() const;
+  static const int64_t SpecialIndexNumber;
+  ObjectStoreDataKey();
+  ~ObjectStoreDataKey();
+
+ private:
+  std::vector<char> encoded_user_key_;
+};
+
+class ExistsEntryKey {
+ public:
+  ExistsEntryKey();
+  ~ExistsEntryKey();
+
+  static const char* Decode(const char* start,
+                            const char* end,
+                            ExistsEntryKey* result);
+  CONTENT_EXPORT static std::vector<char> Encode(
+      int64_t database_id,
+      int64_t object_store_id,
+      const std::vector<char>& encoded_key);
+  static std::vector<char> Encode(int64_t database_id,
+                                  int64_t object_store_id,
+                                  const IndexedDBKey& user_key);
+  int Compare(const ExistsEntryKey& other, bool& ok);
+  scoped_ptr<IndexedDBKey> user_key() const;
+
+  static const int64_t SpecialIndexNumber;
+
+ private:
+  std::vector<char> encoded_user_key_;
+  DISALLOW_COPY_AND_ASSIGN(ExistsEntryKey);
+};
+
+class IndexDataKey {
+ public:
+  IndexDataKey();
+  ~IndexDataKey();
+  static const char* Decode(const char* start,
+                            const char* limit,
+                            IndexDataKey* result);
+  CONTENT_EXPORT static std::vector<char> Encode(
+      int64_t database_id,
+      int64_t object_store_id,
+      int64_t index_id,
+      const std::vector<char>& encoded_user_key,
+      const std::vector<char>& encoded_primary_key,
+      int64_t sequence_number = 0);
+  static std::vector<char> Encode(int64_t database_id,
+                                  int64_t object_store_id,
+                                  int64_t index_id,
+                                  const IndexedDBKey& user_key);
+  static std::vector<char> EncodeMinKey(int64_t database_id,
+                                        int64_t object_store_id,
+                                        int64_t index_id);
+  CONTENT_EXPORT static std::vector<char> EncodeMaxKey(int64_t database_id,
+                                                       int64_t object_store_id,
+                                                       int64_t index_id);
+  int Compare(const IndexDataKey& other, bool ignore_duplicates, bool& ok);
+  int64_t DatabaseId() const;
+  int64_t ObjectStoreId() const;
+  int64_t IndexId() const;
+  scoped_ptr<IndexedDBKey> user_key() const;
+  scoped_ptr<IndexedDBKey> primary_key() const;
+
+ private:
+  int64_t database_id_;
+  int64_t object_store_id_;
+  int64_t index_id_;
+  std::vector<char> encoded_user_key_;
+  std::vector<char> encoded_primary_key_;
+  int64_t sequence_number_;
+
+  DISALLOW_COPY_AND_ASSIGN(IndexDataKey);
+};
+
+}  // namespace IndexedDBLevelDBCoding
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_LEVELDB_CODING_H_