Blob support for IDB [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 <string>
 
 #include "base/basictypes.h"
@@ skipping 78 matching lines @@
   static bool Decode(base::StringPiece* slice, KeyPrefix* result);
   std::string Encode() const;
   static std::string EncodeEmpty();
   int Compare(const KeyPrefix& other) const;
 
   enum Type {
     GLOBAL_METADATA,
     DATABASE_METADATA,
     OBJECT_STORE_DATA,
     EXISTS_ENTRY,
+    BLOB_ENTRY,

[jsbell, 2013/12/20 00:44:20]

Needs to be appended, since these are serialized - see Compare()

We should add a comment.

[ericu, 2014/02/20 00:50:29]

Done.

     INDEX_DATA,
     INVALID_TYPE
   };
 
   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
@@ skipping 55 matching lines @@
 class MaxDatabaseIdKey {
  public:
   CONTENT_EXPORT static std::string Encode();
 };
 
 class DataVersionKey {
  public:
   static std::string Encode();
 };
 
+class BlobJournalKey {
+ public:
+  static std::string Encode();
+};
+
+class LiveBlobJournalKey {
+ public:
+  static std::string Encode();
+};
+
 class DatabaseFreeListKey {
  public:
   DatabaseFreeListKey();
   static bool Decode(base::StringPiece* slice, DatabaseFreeListKey* result);
   CONTENT_EXPORT static std::string Encode(int64 database_id);
   static CONTENT_EXPORT std::string EncodeMaxKey();
   int64 DatabaseId() const;
   int Compare(const DatabaseFreeListKey& other) const;
 
  private:
@@ skipping 19 matching lines @@
 };
 
 class DatabaseMetaDataKey {
  public:
   enum MetaDataType {
     ORIGIN_NAME = 0,
     DATABASE_NAME = 1,
     USER_VERSION = 2,
     MAX_OBJECT_STORE_ID = 3,
     USER_INT_VERSION = 4,
-    MAX_SIMPLE_METADATA_TYPE = 5
+    BLOB_KEY_GENERATOR_CURRENT_NUMBER = 5,
+    MAX_SIMPLE_METADATA_TYPE = 6
   };
 
+  static const int64 kAllBlobsKey = 1;
+  static const int64 kBlobKeyGeneratorInitialNumber = 2;
+  static const int64 kInvalidBlobKey = -1;  // All keys <= 0 are invalid.
+
+  static bool IsValidBlobKey(int64 blobKey);
   CONTENT_EXPORT static std::string Encode(int64 database_id,
                                            MetaDataType type);
 };
 
 class ObjectStoreMetaDataKey {
  public:
   enum MetaDataType {
     NAME = 0,
     KEY_PATH = 1,
     AUTO_INCREMENT = 2,
@@ skipping 150 matching lines @@
   int Compare(const ExistsEntryKey& other, bool* ok);
   scoped_ptr<IndexedDBKey> user_key() const;
 
   static const int64 kSpecialIndexNumber;
 
  private:
   std::string encoded_user_key_;
   DISALLOW_COPY_AND_ASSIGN(ExistsEntryKey);
 };
 
+class BlobEntryKey {
+ public:
+  BlobEntryKey() : database_id_(0), object_store_id_(0) {}
+  static bool Decode(base::StringPiece* slice, BlobEntryKey* result);
+  static bool FromObjectStoreDataKey(base::StringPiece* slice,
+                                     BlobEntryKey* result);
+  static std::string ReencodeToObjectStoreDataKey(base::StringPiece* slice);
+  static std::string EncodeMinForObjectStore(int64 database_id,
+                                             int64 object_store_id);
+  static std::string EncodeMaxForObjectStore(int64 database_id,
+                                             int64 object_store_id);
+  static std::string Encode(int64 database_id,
+                            int64 object_store_id,
+                            const IndexedDBKey& user_key);
+  std::string Encode() const;
+  int64 database_id() const { return database_id_; }
+  int64 object_store_id() const { return object_store_id_; }
+  int Compare(const BlobEntryKey& other, bool* ok);
+
+  static const int64 kSpecialIndexNumber;
+
+ private:
+  static std::string Encode(int64 database_id,
+                            int64 object_store_id,
+                            const std::string& encoded_user_key);
+  int64 database_id_;
+  int64 object_store_id_;
+  // This is the user's ObjectStoreDataKey, not the BlobEntryKey itself.
+  std::string encoded_user_key_;
+};
+
 class IndexDataKey {
  public:
   IndexDataKey();
   ~IndexDataKey();
   static bool Decode(base::StringPiece* slice, IndexDataKey* result);
   CONTENT_EXPORT static std::string Encode(
       int64 database_id,
       int64 object_store_id,
       int64 index_id,
       const std::string& encoded_user_key,
@@ skipping 30 matching lines @@
   std::string encoded_user_key_;
   std::string encoded_primary_key_;
   int64 sequence_number_;
 
   DISALLOW_COPY_AND_ASSIGN(IndexDataKey);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_LEVELDB_CODING_H_