Blob support for IDB [Chromium]

content/browser/indexed_db/indexed_db_backing_store.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 "base/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "content/browser/child_process_security_policy_impl.h"
+#include "content/browser/indexed_db/indexed_db_blob_info.h"
 #include "content/browser/indexed_db/indexed_db_leveldb_coding.h"
 #include "content/browser/indexed_db/indexed_db_metadata.h"
 #include "content/browser/indexed_db/indexed_db_tracing.h"
+#include "content/browser/indexed_db/indexed_db_value.h"
 #include "content/browser/indexed_db/leveldb/leveldb_comparator.h"
 #include "content/browser/indexed_db/leveldb/leveldb_database.h"
 #include "content/browser/indexed_db/leveldb/leveldb_iterator.h"
 #include "content/browser/indexed_db/leveldb/leveldb_transaction.h"
 #include "content/common/indexed_db/indexed_db_key.h"
 #include "content/common/indexed_db/indexed_db_key_path.h"
 #include "content/common/indexed_db/indexed_db_key_range.h"
+#include "content/public/browser/browser_thread.h"
+#include "net/url_request/url_request_context.h"
 #include "third_party/WebKit/public/platform/WebIDBTypes.h"
 #include "third_party/leveldatabase/env_chromium.h"
+#include "webkit/browser/fileapi/file_writer_delegate.h"
+#include "webkit/browser/fileapi/local_file_stream_writer.h"
 
+using base::FilePath;
 using base::StringPiece;
+using fileapi::FileWriterDelegate;
 
 // TODO(jsbell): Make blink push the version during the open() call.
 static const uint32 kWireVersion = 2;
 
 namespace content {
 
+namespace {
+
+FilePath GetIDBBlobDirectoryName(const FilePath& pathBase,
+                                       int64 database_id) {
+  return pathBase.AppendASCII(base::StringPrintf("%lx", database_id));
+}
+
+FilePath GetIDBBlobDirectoryNameForKey(const FilePath& pathBase,
+    int64 database_id, int64 key) {
+  FilePath path = GetIDBBlobDirectoryName(pathBase, database_id);
+  path = path.AppendASCII(
+      base::StringPrintf("%x", static_cast<int>(key & 0x0000ff00) >> 8));
+  return path;
+}
+
+// This assumes a file path of dbId/3rd-byte-of-counter/counter.
+bool MakeIDBBlobDirectory(
+    const FilePath& pathBase, int64 database_id, int64 key) {
+  FilePath path =
+      GetIDBBlobDirectoryNameForKey(pathBase, database_id, key);
+  return file_util::CreateDirectory(path);
+}
+
+} // anonymous namespace
+
 static const int64 kKeyGeneratorInitialNumber =
     1;  // From the IndexedDB specification.
 
 enum IndexedDBBackingStoreErrorSource {
   // 0 - 2 are no longer used.
   FIND_KEY_IN_INDEX = 3,
   GET_IDBDATABASE_METADATA,
   GET_INDEXES,
   GET_KEY_GENERATOR_CURRENT_NUMBER,
   GET_OBJECT_STORES,
   GET_RECORD,
   KEY_EXISTS_IN_OBJECT_STORE,
   LOAD_CURRENT_ROW,
   SET_UP_METADATA,
   GET_PRIMARY_KEY_VIA_INDEX,
   KEY_EXISTS_IN_INDEX,
   VERSION_EXISTS,
   DELETE_OBJECT_STORE,
   SET_MAX_OBJECT_STORE_ID,
   SET_MAX_INDEX_ID,
   GET_NEW_DATABASE_ID,
   GET_NEW_VERSION_NUMBER,
   CREATE_IDBDATABASE_METADATA,
   DELETE_DATABASE,
   TRANSACTION_COMMIT_METHOD,  // TRANSACTION_COMMIT is a WinNT.h macro
+  GET_BLOB_KEY_GENERATOR_CURRENT_NUMBER,
+  GET_BLOB_INFO_FOR_RECORD,
+  DECODE_BLOB_JOURNAL,
   GET_DATABASE_NAMES,
   INTERNAL_ERROR_MAX,
 };
 
 static void RecordInternalError(const char* type,
                                 IndexedDBBackingStoreErrorSource location) {
   std::string name;
   name.append("WebCore.IndexedDB.BackingStore.").append(type).append("Error");
   base::Histogram::FactoryGet(name,
                               1,
@@ skipping 279 matching lines @@
 }
 
 class DefaultLevelDBFactory : public LevelDBFactory {
  public:
   virtual leveldb::Status OpenLevelDB(const base::FilePath& file_name,
                                       const LevelDBComparator* comparator,
                                       scoped_ptr<LevelDBDatabase>* db,
                                       bool* is_disk_full) OVERRIDE {
     return LevelDBDatabase::Open(file_name, comparator, db, is_disk_full);
   }
-  virtual bool DestroyLevelDB(const base::FilePath& file_name) OVERRIDE {
+  virtual bool DestroyLevelDB(const FilePath& file_name) OVERRIDE {
     return LevelDBDatabase::Destroy(file_name);
   }
 };
 
+static bool GetBlobKeyGeneratorCurrentNumber(
+  LevelDBTransaction* leveldb_transaction, int64 database_id,
+  int64& blob_key_generator_current_number) {
+  const std::string key_gen_key =
+      DatabaseMetaDataKey::Encode(
+          database_id, DatabaseMetaDataKey::BLOB_KEY_GENERATOR_CURRENT_NUMBER);
+
+  // Default to initial number if not found.
+  int64 cur_number = DatabaseMetaDataKey::kBlobKeyGeneratorInitialNumber;
+  std::string data;
+
+  bool found = false;
+  bool ok = leveldb_transaction->Get(key_gen_key, &data, &found);
+  if (!ok) {
+    INTERNAL_READ_ERROR(GET_BLOB_KEY_GENERATOR_CURRENT_NUMBER);
+    return false;
+  }
+  if (found) {
+    StringPiece slice(data);
+    if (!DecodeVarInt(&slice, &cur_number) ||
+        !DatabaseMetaDataKey::IsValidBlobKey(cur_number)) {
+      INTERNAL_READ_ERROR(GET_BLOB_KEY_GENERATOR_CURRENT_NUMBER);
+      return false;
+    }
+  }
+  blob_key_generator_current_number = cur_number;
+  return true;
+}
+
+static bool UpdateBlobKeyGeneratorCurrentNumber(
+    LevelDBTransaction* leveldb_transaction, int64 database_id,
+    int64 blob_key_generator_current_number) {
+#ifndef NDEBUG
+  int64 old_number;
+  if (!GetBlobKeyGeneratorCurrentNumber(leveldb_transaction, database_id,
+      old_number))
+    return false;
+  DCHECK_LT(old_number, blob_key_generator_current_number);
+#endif
+  DCHECK(DatabaseMetaDataKey::IsValidBlobKey(
+      blob_key_generator_current_number));
+  const std::string key =
+      DatabaseMetaDataKey::Encode(
+          database_id, DatabaseMetaDataKey::BLOB_KEY_GENERATOR_CURRENT_NUMBER);
+
+  PutInt(leveldb_transaction, key, blob_key_generator_current_number);
+  return true;
+}
+
+static bool DecodeBlobJournal(const std::string& data,
+    IndexedDBBackingStore::Transaction::BlobJournalType& journal) {
+  // TODO(ericu): Yell something on errors. If we persistently can't read the
+  // blob journal, the safe thing to do is to clear it and leak the blobs,
+  // though that may be costly. Still, database/directory deletion should always
+  // clean things up, and we can write an fsck that will do a full correction if
+  // need be.
+  IndexedDBBackingStore::Transaction::BlobJournalType output;
+  StringPiece slice(data);
+  while (!slice.empty()) {
+    int64 database_id = -1;
+    int64 blob_key = -1;
+    if (!DecodeVarInt(&slice, &database_id))
+      return false;
+    else if (!KeyPrefix::IsValidDatabaseId(database_id))
+      return false;
+    if (!DecodeVarInt(&slice, &blob_key)) {
+      return false;
+    } else if (!DatabaseMetaDataKey::IsValidBlobKey(blob_key) &&
+        (blob_key != DatabaseMetaDataKey::kAllBlobsKey)) {
+      return false;
+    }
+    output.push_back(std::make_pair(database_id, blob_key));
+  }
+  journal.swap(output);
+  return true;
+}
+
+static bool GetBlobJournalHelper(
+    bool ok, bool found,
+    const std::string& data,
+    IndexedDBBackingStore::Transaction::BlobJournalType& journal) {
+  if (!ok) {
+    INTERNAL_READ_ERROR(KEY_EXISTS_IN_OBJECT_STORE);
+    return false;
+  }
+  journal.clear();
+  if (!found)
+    return true;
+  if (!data.size())
+    return true;
+  if (!DecodeBlobJournal(data, journal)) {
+    INTERNAL_READ_ERROR(DECODE_BLOB_JOURNAL);
+    return false;
+  }
+  return true;
+}
+
+static bool GetBlobJournal(
+    const StringPiece& leveldb_key,
+    LevelDBTransaction* leveldb_transaction,
+    IndexedDBBackingStore::Transaction::BlobJournalType& journal) {
+  std::string data;
+  bool found = false;
+  bool ok = leveldb_transaction->Get(leveldb_key, &data, &found);
+  return GetBlobJournalHelper(ok, found, data, journal);
+}
+
+static bool GetBlobJournal(
+    const StringPiece& leveldb_key,
+    LevelDBWriteOnlyTransaction* leveldb_transaction,
+    IndexedDBBackingStore::Transaction::BlobJournalType& journal) {
+  std::string data;
+  bool found = false;
+  bool ok = leveldb_transaction->Get(leveldb_key, &data, &found);
+  return GetBlobJournalHelper(ok, found, data, journal);
+}
+
+static std::string EncodeBlobJournalWithBlobList(
+    const IndexedDBBackingStore::Transaction::BlobJournalType& journal) {
+  std::string data;
+  if (journal.size()) {
+    IndexedDBBackingStore::Transaction::BlobJournalType::const_iterator iter;
+    for (iter = journal.begin(); iter != journal.end(); ++iter) {
+      EncodeVarInt(iter->first, &data);
+      EncodeVarInt(iter->second, &data);
+    }
+  }
+  return data;
+}
+
+static void ClearBlobJournal(LevelDBTransaction* leveldb_transaction,
+    const std::string& level_db_key) {
+  leveldb_transaction->Remove(level_db_key);
+}
+
+static void UpdatePrimaryJournalWithBlobList(
+    LevelDBTransaction* leveldb_transaction,
+    const IndexedDBBackingStore::Transaction::BlobJournalType& journal) {
+  const std::string leveldbKey = BlobJournalKey::Encode();
+  std::string data = EncodeBlobJournalWithBlobList(journal);
+  leveldb_transaction->Put(leveldbKey, &data);
+}
+
+static void UpdateSecondaryJournalWithBlobList(
+    LevelDBTransaction* leveldb_transaction,
+    const IndexedDBBackingStore::Transaction::BlobJournalType& journal) {
+  const std::string leveldbKey = LiveBlobJournalKey::Encode();
+  std::string data = EncodeBlobJournalWithBlobList(journal);
+  leveldb_transaction->Put(leveldbKey, &data);
+}
+
+static bool MergeBlobsIntoSecondaryJournal(
+    LevelDBTransaction* leveldb_transaction,
+    const IndexedDBBackingStore::Transaction::BlobJournalType& journal) {
+  IndexedDBBackingStore::Transaction::BlobJournalType old_journal;
+  std::string key = LiveBlobJournalKey::Encode();
+  if (!GetBlobJournal(key, leveldb_transaction, old_journal))
+    return false;
+
+  fprintf(stderr, "ERICU: Secondary: old %lu entries, new %lu entries.\n",
+      old_journal.size(), journal.size());
+  old_journal.insert(old_journal.end(), journal.begin(), journal.end());
+  fprintf(stderr, "ERICU: final %lu entries.\n", old_journal.size());
+
+  UpdateSecondaryJournalWithBlobList(leveldb_transaction, old_journal);
+  return true;
+}
+
+static void UpdateBlobJournalWithDatabase(
+    LevelDBWriteOnlyTransaction* leveldb_transaction, int64 database_id) {
+  IndexedDBBackingStore::Transaction::BlobJournalType journal;
+  journal.push_back(
+      std::make_pair(database_id, DatabaseMetaDataKey::kAllBlobsKey));
+  const std::string key = BlobJournalKey::Encode();
+  std::string data = EncodeBlobJournalWithBlobList(journal);
+  leveldb_transaction->Put(key, &data);
+}
+
+static bool MergeDatabaseIntoSecondaryJournal(
+    LevelDBWriteOnlyTransaction* leveldb_transaction, int64 database_id) {
+  IndexedDBBackingStore::Transaction::BlobJournalType journal;
+  std::string key = LiveBlobJournalKey::Encode();
+  if (!GetBlobJournal(key, leveldb_transaction, journal))
+    return false;
+  journal.push_back(
+      std::make_pair(database_id, DatabaseMetaDataKey::kAllBlobsKey));
+  std::string data = EncodeBlobJournalWithBlobList(journal);
+  leveldb_transaction->Put(key, &data);
+  return true;
+}
+
+// Blob Data is encoded as { is_file [bool], key [int64 as varInt],
+// type [string-with-length, may be empty], then [for Blobs] size
+// [int64 as varInt] or [for Files] fileName [string-with-length] }
+static std::string EncodeBlobData(
+  const std::vector<IndexedDBBlobInfo*>& blob_info) {
+  std::string ret;
+  std::vector<IndexedDBBlobInfo*>::const_iterator iter;
+  for (iter = blob_info.begin(); iter != blob_info.end(); ++iter) {
+    const IndexedDBBlobInfo& info = **iter;
+    EncodeBool(info.is_file(), &ret);
+    EncodeVarInt(info.key(), &ret);
+    EncodeStringWithLength(info.type(), &ret);
+    if (info.is_file())
+      EncodeStringWithLength(info.file_name(), &ret);
+    else
+      EncodeVarInt(info.size(), &ret);
+  }
+  return ret;
+}
+
+static bool DecodeBlobData(
+    const std::string& data,
+    std::vector<IndexedDBBlobInfo>* output) {
+  std::vector<IndexedDBBlobInfo> ret;
+  output->clear();
+  StringPiece slice(data);
+  while (!slice.empty()) {
+    bool is_file;
+    int64 key;
+    string16 type;
+    int64 size;
+    string16 file_name;
+
+    if (!DecodeBool(&slice, &is_file))
+      return false;
+    if (!DecodeVarInt(&slice, &key) ||
+        !DatabaseMetaDataKey::IsValidBlobKey(key))
+      return false;
+    if (!DecodeStringWithLength(&slice, &type))
+      return false;
+    if (is_file) {
+      if (!DecodeStringWithLength(&slice, &file_name))
+        return false;
+      ret.push_back(IndexedDBBlobInfo(type, file_name, key));
+    } else {
+      if (!DecodeVarInt(&slice, &size) || size < 0)
+        return false;
+      ret.push_back(IndexedDBBlobInfo(type, static_cast<uint64>(size), key));
+    }
+  }
+  output->swap(ret);
+
+  return true;
+}
+
 IndexedDBBackingStore::IndexedDBBackingStore(
     const std::string& identifier,
+    const FilePath& blob_path,
+    net::URLRequestContext* request_context,
     scoped_ptr<LevelDBDatabase> db,
-    scoped_ptr<LevelDBComparator> comparator)
+    scoped_ptr<LevelDBComparator> comparator,
+    base::TaskRunner* task_runner)
     : identifier_(identifier),
+      blob_path_(blob_path),
+      request_context_(request_context),
+      task_runner_(task_runner),
       db_(db.Pass()),
       comparator_(comparator.Pass()),
-      weak_factory_(this) {}
+      active_blob_registry_(this),
+      weak_factory_(this) {
+}
 
 IndexedDBBackingStore::~IndexedDBBackingStore() {
+  if (!blob_path_.empty()) {
+    ChildProcessSecurityPolicyImpl* policy =
+        ChildProcessSecurityPolicyImpl::GetInstance();
+    for (std::set<int>::iterator iter = child_process_ids_granted_.begin();
+        iter != child_process_ids_granted_.end(); ++iter) {
+      policy->RevokeAllPermissionsForFile(*iter, blob_path_);
+    }
+  }
   // db_'s destructor uses comparator_. The order of destruction is important.
   db_.reset();
   comparator_.reset();
 }
 
 IndexedDBBackingStore::RecordIdentifier::RecordIdentifier(
     const std::string& primary_key,
     int64 version)
     : primary_key_(primary_key), version_(version) {
   DCHECK(!primary_key.empty());
@@ skipping 53 matching lines @@
       }
     }
     default:
       return true;
   }
   return true;
 }
 
 scoped_refptr<IndexedDBBackingStore> IndexedDBBackingStore::Open(
     const std::string& origin_identifier,
-    const base::FilePath& path_base,
+    const FilePath& path_base,
     const std::string& file_identifier,
-    WebKit::WebIDBCallbacks::DataLoss* data_loss) {
+    net::URLRequestContext* request_context,
+    WebKit::WebIDBCallbacks::DataLoss* data_loss,
+    base::TaskRunner* task_runner,
+    bool clean_journal) {
   *data_loss = WebKit::WebIDBCallbacks::DataLossNone;
   DefaultLevelDBFactory leveldb_factory;
   return IndexedDBBackingStore::Open(origin_identifier,
                                      path_base,
                                      file_identifier,
+                                     request_context,
                                      data_loss,
-                                     &leveldb_factory);
+                                     &leveldb_factory,
+                                     task_runner,
+                                     clean_journal);
 }
 
 scoped_refptr<IndexedDBBackingStore> IndexedDBBackingStore::Open(
     const std::string& origin_identifier,
-    const base::FilePath& path_base,
+    const FilePath& path_base,
     const std::string& file_identifier,
+    net::URLRequestContext* request_context,
     WebKit::WebIDBCallbacks::DataLoss* data_loss,
-    LevelDBFactory* leveldb_factory) {
+    LevelDBFactory* leveldb_factory,
+    base::TaskRunner* task_runner,
+    bool clean_journal) {
   IDB_TRACE("IndexedDBBackingStore::Open");
   DCHECK(!path_base.empty());
   *data_loss = WebKit::WebIDBCallbacks::DataLossNone;
 
   scoped_ptr<LevelDBComparator> comparator(new Comparator());
 
   if (!IsStringASCII(path_base.AsUTF8Unsafe())) {
     base::Histogram::FactoryGet("WebCore.IndexedDB.BackingStore.OpenStatus",
                                 1,
                                 INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX,
                                 INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX + 1,
                                 base::HistogramBase::kUmaTargetedHistogramFlag)
         ->Add(INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_ATTEMPT_NON_ASCII);
   }
   if (!file_util::CreateDirectory(path_base)) {
     LOG(ERROR) << "Unable to create IndexedDB database path "
                << path_base.AsUTF8Unsafe();
     base::Histogram::FactoryGet("WebCore.IndexedDB.BackingStore.OpenStatus",
                                 1,
                                 INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX,
                                 INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX + 1,
                                 base::HistogramBase::kUmaTargetedHistogramFlag)
         ->Add(INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_FAILED_DIRECTORY);
     return scoped_refptr<IndexedDBBackingStore>();
   }
 
-  base::FilePath identifier_path =
-      base::FilePath().AppendASCII(origin_identifier)
-          .AddExtension(FILE_PATH_LITERAL(".indexeddb.leveldb"));
+  base::FilePath db_dir_name =
+      FilePath().AppendASCII(origin_identifier).
+      AddExtension(FILE_PATH_LITERAL(".indexeddb.leveldb"));
+  base::FilePath blob_dir_name =
+      FilePath().AppendASCII(origin_identifier).
+      AddExtension(FILE_PATH_LITERAL(".indexeddb.blob"));
 
   int limit = file_util::GetMaximumPathComponentLength(path_base);
   if (limit == -1) {
     DLOG(WARNING) << "GetMaximumPathComponentLength returned -1";
     // In limited testing, ChromeOS returns 143, other OSes 255.
 #if defined(OS_CHROMEOS)
     limit = 143;
 #else
     limit = 255;
 #endif
   }
-  if (identifier_path.value().length() > static_cast<uint32_t>(limit)) {
+  if (db_dir_name.value().length() > static_cast<uint32_t>(limit)) {
     DLOG(WARNING) << "Path component length ("
-                  << identifier_path.value().length() << ") exceeds maximum ("
+                  << db_dir_name.value().length() << ") exceeds maximum ("
                   << limit << ") allowed by this filesystem.";
     const int min = 140;
     const int max = 300;
     const int num_buckets = 12;
     // TODO(dgrogan): Remove WebCore from these histogram names.
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "WebCore.IndexedDB.BackingStore.OverlyLargeOriginLength",
-        identifier_path.value().length(),
+        db_dir_name.value().length(),
         min,
         max,
         num_buckets);
     // TODO(dgrogan): Translate the FactoryGet calls to
     // UMA_HISTOGRAM_ENUMERATION. FactoryGet was the most direct translation
     // from the WebCore code.
     base::Histogram::FactoryGet("WebCore.IndexedDB.BackingStore.OpenStatus",
                                 1,
                                 INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX,
                                 INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX + 1,
                                 base::HistogramBase::kUmaTargetedHistogramFlag)
         ->Add(INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_ORIGIN_TOO_LONG);
     return scoped_refptr<IndexedDBBackingStore>();
   }
 
-  base::FilePath file_path = path_base.Append(identifier_path);
+  FilePath file_path = path_base.Append(db_dir_name);
+  FilePath blob_path = path_base.Append(blob_dir_name);
 
   bool is_disk_full = false;
   scoped_ptr<LevelDBDatabase> db;
   leveldb::Status status = leveldb_factory->OpenLevelDB(
       file_path, comparator.get(), &db, &is_disk_full);
 
   if (db) {
     bool known = false;
     bool ok = IsSchemaKnown(db.get(), &known);
     if (!ok) {
@@ skipping 88 matching lines @@
     NOTREACHED();
     base::Histogram::FactoryGet("WebCore.IndexedDB.BackingStore.OpenStatus",
                                 1,
                                 INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX,
                                 INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX + 1,
                                 base::HistogramBase::kUmaTargetedHistogramFlag)
         ->Add(INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_FAILED_UNKNOWN_ERR);
     return scoped_refptr<IndexedDBBackingStore>();
   }
 
-  return Create(file_identifier, db.Pass(), comparator.Pass());
+  scoped_refptr<IndexedDBBackingStore> backing_store = Create(
+      file_identifier, blob_path, request_context, db.Pass(), comparator.Pass(),
+      task_runner);
+
+  if (clean_journal)
+    fprintf(stderr, "ERICU: first open of DB since boot.\n");
+  if (clean_journal && !backing_store->CleanUpBlobJournal(
+      LiveBlobJournalKey::Encode()))
+    return scoped_refptr<IndexedDBBackingStore>();
+  return backing_store;
 }
 
 scoped_refptr<IndexedDBBackingStore> IndexedDBBackingStore::OpenInMemory(
     const std::string& file_identifier) {
   DefaultLevelDBFactory leveldb_factory;
   return IndexedDBBackingStore::OpenInMemory(file_identifier, &leveldb_factory);
 }
 
 scoped_refptr<IndexedDBBackingStore> IndexedDBBackingStore::OpenInMemory(
     const std::string& file_identifier,
@@ skipping 13 matching lines @@
         ->Add(INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MEMORY_FAILED);
     return scoped_refptr<IndexedDBBackingStore>();
   }
   base::Histogram::FactoryGet("WebCore.IndexedDB.BackingStore.OpenStatus",
                               1,
                               INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX,
                               INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MAX + 1,
                               base::HistogramBase::kUmaTargetedHistogramFlag)
       ->Add(INDEXED_DB_LEVEL_DB_BACKING_STORE_OPEN_MEMORY_SUCCESS);
 
-  return Create(file_identifier, db.Pass(), comparator.Pass());
+  return Create(file_identifier, FilePath(), NULL, db.Pass(),
+      comparator.Pass(), NULL);
 }
 
 scoped_refptr<IndexedDBBackingStore> IndexedDBBackingStore::Create(
     const std::string& identifier,
+    const FilePath& blob_path,
+    net::URLRequestContext* request_context,
     scoped_ptr<LevelDBDatabase> db,
-    scoped_ptr<LevelDBComparator> comparator) {
+    scoped_ptr<LevelDBComparator> comparator,
+    base::TaskRunner* task_runner) {
   // TODO(jsbell): Handle comparator name changes.
   scoped_refptr<IndexedDBBackingStore> backing_store(
-      new IndexedDBBackingStore(identifier, db.Pass(), comparator.Pass()));
+      new IndexedDBBackingStore(identifier, blob_path, request_context,
+          db.Pass(), comparator.Pass(), task_runner));
 
   if (!SetUpMetadata(backing_store->db_.get(), identifier))
     return scoped_refptr<IndexedDBBackingStore>();
 
   return backing_store;
 }
 
+void IndexedDBBackingStore::GrantChildProcessPermissions(int child_process_id) {
+  if (!child_process_ids_granted_.count(child_process_id)) {
+    child_process_ids_granted_.insert(child_process_id);
+    ChildProcessSecurityPolicyImpl::GetInstance()->GrantReadDirectory(
+        child_process_id, blob_path_);
+  }
+}
+
 std::vector<string16> IndexedDBBackingStore::GetDatabaseNames() {
   std::vector<string16> found_names;
   const std::string start_key =
       DatabaseNameKey::EncodeMinKeyForOrigin(identifier_);
   const std::string stop_key =
       DatabaseNameKey::EncodeStopKeyForOrigin(identifier_);
 
   DCHECK(found_names.empty());
 
   scoped_ptr<LevelDBIterator> it = db_->CreateIterator();
@@ skipping 57 matching lines @@
   if (metadata->int_version == IndexedDBDatabaseMetadata::DEFAULT_INT_VERSION)
     metadata->int_version = IndexedDBDatabaseMetadata::NO_INT_VERSION;
 
   ok = GetMaxObjectStoreId(
       db_.get(), metadata->id, &metadata->max_object_store_id);
   if (!ok) {
     INTERNAL_READ_ERROR(GET_IDBDATABASE_METADATA);
     return false;
   }
 
+  int64 blob_key_generator_current_number =
+      DatabaseMetaDataKey::kInvalidBlobKey;
+
+  ok = GetVarInt(db_.get(),
+                 DatabaseMetaDataKey::Encode(
+                     metadata->id,
+                     DatabaseMetaDataKey::BLOB_KEY_GENERATOR_CURRENT_NUMBER),
+                 &blob_key_generator_current_number,
+                 found);
+  if (!ok) {
+    INTERNAL_READ_ERROR(GET_IDBDATABASE_METADATA);
+    return false;
+  }
+  if (!*found ||
+      !DatabaseMetaDataKey::IsValidBlobKey(blob_key_generator_current_number)) {
+    INTERNAL_CONSISTENCY_ERROR(GET_IDBDATABASE_METADATA);
+    // TODO(ericu): If BLOB_KEY_GENERATOR_CURRENT_NUMBER isn't present,
+    // initialize it to kBlobKeyGeneratorInitialNumber. We may also want to
+    // verify that this object store predates blob support, or that there
+    // aren't any blobs on disk.
+    // This would be a read-modify-write, so we'd need a transaction,
+    // and to double-check. It might just be easier to write it lazily
+    // when we first try to increment it.
+    return false;
+  }
+
   return true;
 }
 
 WARN_UNUSED_RESULT static bool GetNewDatabaseId(LevelDBDatabase* db,
                                                 int64* new_id) {
   scoped_refptr<LevelDBTransaction> transaction = new LevelDBTransaction(db);
 
   *new_id = -1;
   int64 max_database_id = -1;
   bool found = false;
@@ skipping 35 matching lines @@
   PutInt(
       transaction.get(), DatabaseNameKey::Encode(identifier_, name), *row_id);
   PutString(
       transaction.get(),
       DatabaseMetaDataKey::Encode(*row_id, DatabaseMetaDataKey::USER_VERSION),
       version);
   PutVarInt(transaction.get(),
             DatabaseMetaDataKey::Encode(*row_id,
                                         DatabaseMetaDataKey::USER_INT_VERSION),
             int_version);
+  PutVarInt(
+      transaction.get(),
+      DatabaseMetaDataKey::Encode(*row_id,
+          DatabaseMetaDataKey::BLOB_KEY_GENERATOR_CURRENT_NUMBER),
+      DatabaseMetaDataKey::kBlobKeyGeneratorInitialNumber);
   if (!transaction->Commit()) {
     INTERNAL_WRITE_ERROR(CREATE_IDBDATABASE_METADATA);
     return false;
   }
   return true;
 }
 
 bool IndexedDBBackingStore::UpdateIDBDatabaseIntVersion(
     IndexedDBBackingStore::Transaction* transaction,
     int64 row_id,
@@ skipping 12 matching lines @@
     IndexedDBBackingStore::Transaction* transaction,
     int64 row_id,
     const string16& version) {
   PutString(
       Transaction::LevelDBTransactionFrom(transaction),
       DatabaseMetaDataKey::Encode(row_id, DatabaseMetaDataKey::USER_VERSION),
       version);
   return true;
 }
 
-static void DeleteRange(LevelDBTransaction* transaction,
-                        const std::string& begin,
-                        const std::string& end) {
+// Note that if you're deleting a range that contains user keys that have blob
+// info, this won't clean up the blobs.
+static void DeleteRangeHelper(LevelDBTransaction* transaction,
+                              const std::string& begin,
+                              const std::string& end) {
   scoped_ptr<LevelDBIterator> it = transaction->CreateIterator();
   for (it->Seek(begin); it->IsValid() && CompareKeys(it->Key(), end) < 0;
        it->Next())
     transaction->Remove(it->Key());
 }
 
+// For a whole-object-store deletion, we still use the one-blob-record-at-a-time
+// deletion mechanism designed for normal transactions. We could go with the
+// nuke-the-whole-directory method used for deleteDatabase, but that would
+// complicate the kind of info we store in the LevelDBTransaction.
+static void DeleteBlobsInObjectStore(
+    IndexedDBBackingStore::Transaction* transaction,
+    int64 database_id, int64 object_store_id) {
+  fprintf(stderr, "ERICU: DeleteBlobsInObjectStore.\n");
+  std::string start_key, end_key;
+  start_key =
+      BlobEntryKey::EncodeMinForObjectStore(database_id, object_store_id);
+  end_key =
+      BlobEntryKey::EncodeMaxForObjectStore(database_id, object_store_id);
+
+  scoped_ptr<LevelDBIterator> it =
+      IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(
+          transaction)->CreateIterator();
+  for (it->Seek(start_key);
+       it->IsValid() && CompareKeys(it->Key(), end_key) < 0; it->Next()) {
+    StringPiece key_piece(it->Key());
+    std::string user_key = BlobEntryKey::EncodeToObjectStoreDataKey(&key_piece);
+    if (user_key.size())
+      transaction->PutBlobInfo(database_id, object_store_id, user_key, NULL);
+    else
+      INTERNAL_CONSISTENCY_ERROR(GET_IDBDATABASE_METADATA);
+  }
+}
+
+static bool GetBlobInfoForRecord(
+    IndexedDBBackingStore* backing_store,
+    LevelDBTransaction* leveldb_transaction,
+    int64 database_id,
+    const std::string& leveldb_key,
+    IndexedDBValue* value) {
+
+  BlobEntryKey blob_entry_key;
+  StringPiece leveldb_key_piece(leveldb_key);
+  if (!BlobEntryKey::FromObjectStoreDataKey(
+      &leveldb_key_piece, &blob_entry_key)) {
+    NOTREACHED();
+    return false;
+  }
+  scoped_ptr<LevelDBIterator> it = leveldb_transaction->CreateIterator();
+  std::string encoded_key = blob_entry_key.Encode();
+  it->Seek(encoded_key);
+  if (it->IsValid() && CompareKeys(it->Key(), encoded_key) == 0) {
+    if (!DecodeBlobData(it->Value().as_string(), &value->blob_info)) {
+      INTERNAL_READ_ERROR(GET_BLOB_INFO_FOR_RECORD);
+      return false;
+    }
+    std::vector<IndexedDBBlobInfo>::iterator iter;
+    for (iter = value->blob_info.begin(); iter != value->blob_info.end();
+        ++iter) {
+      iter->set_file_path(
+          backing_store->GetIDBBlobFileName(database_id, iter->key()));
+      iter->set_mark_used_callback(
+          backing_store->active_blob_registry()->GetMarkUsedCallback(
+              database_id, iter->key()));
+      iter->set_release_callback(
+          backing_store->active_blob_registry()->GetReleaseCallback(
+              database_id, iter->key()));
+      if (iter->is_file()) {
+        base::PlatformFileInfo info;
+        if (file_util::GetFileInfo(iter->file_path(), &info)) {
+          // This should always work, but it isn't fatal if it doesn't; it just
+          // means a potential slow synchronous call from the renderer later.
+          iter->set_last_modified(info.last_modified);
+          iter->set_size(info.size);
+        }
+      }
+    }
+  }
+  return true;
+}
+
 bool IndexedDBBackingStore::DeleteDatabase(const string16& name) {
   IDB_TRACE("IndexedDBBackingStore::DeleteDatabase");
   scoped_ptr<LevelDBWriteOnlyTransaction> transaction =
       LevelDBWriteOnlyTransaction::Create(db_.get());
 
+  if (!CleanUpBlobJournal(BlobJournalKey::Encode()))
+    return false;
+
   IndexedDBDatabaseMetadata metadata;
   bool success = false;
   bool ok = GetIDBDatabaseMetaData(name, &metadata, &success);
   if (!ok)
     return false;
   if (!success)
     return true;
 
   const std::string start_key = DatabaseMetaDataKey::Encode(
       metadata.id, DatabaseMetaDataKey::ORIGIN_NAME);
   const std::string stop_key = DatabaseMetaDataKey::Encode(
       metadata.id + 1, DatabaseMetaDataKey::ORIGIN_NAME);
   scoped_ptr<LevelDBIterator> it = db_->CreateIterator();
   for (it->Seek(start_key);
        it->IsValid() && CompareKeys(it->Key(), stop_key) < 0;
        it->Next())
     transaction->Remove(it->Key());
 
   const std::string key = DatabaseNameKey::Encode(identifier_, name);
   transaction->Remove(key);
 
+  bool need_cleanup = false;
+  if (active_blob_registry()->MarkDeletedCheckIfUsed(
+      metadata.id, DatabaseMetaDataKey::kAllBlobsKey)) {
+    if (!MergeDatabaseIntoSecondaryJournal(transaction.get(), metadata.id))
+        return false;
+  } else {
+    UpdateBlobJournalWithDatabase(transaction.get(), metadata.id);
+    need_cleanup = true;
+  }
+
   if (!transaction->Commit()) {
     INTERNAL_WRITE_ERROR(DELETE_DATABASE);
     return false;
   }
+
+  if (need_cleanup)
+    CleanUpBlobJournal(BlobJournalKey::Encode());
+
   return true;
 }
 
 static bool CheckObjectStoreAndMetaDataType(const LevelDBIterator* it,
                                             const std::string& stop_key,
                                             int64 object_store_id,
                                             int64 meta_data_type) {
   if (!it->IsValid() || CompareKeys(it->Key(), stop_key) >= 0)
     return false;
 
@@ skipping 72 matching lines @@
       INTERNAL_CONSISTENCY_ERROR(GET_OBJECT_STORES);
       break;
     }
     bool auto_increment;
     {
       StringPiece slice(it->Value());
       if (!DecodeBool(&slice, &auto_increment) || !slice.empty())
         INTERNAL_CONSISTENCY_ERROR(GET_OBJECT_STORES);
     }
 
-    it->Next();  // Is evicatble.
+    it->Next();  // Is evictable.
     if (!CheckObjectStoreAndMetaDataType(it.get(),
                                          stop_key,
                                          object_store_id,
                                          ObjectStoreMetaDataKey::EVICTABLE)) {
       INTERNAL_CONSISTENCY_ERROR(GET_OBJECT_STORES);
       break;
     }
 
     it->Next();  // Last version.
     if (!CheckObjectStoreAndMetaDataType(
@@ skipping 168 matching lines @@
       &found);
   if (!ok) {
     INTERNAL_READ_ERROR(DELETE_OBJECT_STORE);
     return false;
   }
   if (!found) {
     INTERNAL_CONSISTENCY_ERROR(DELETE_OBJECT_STORE);
     return false;
   }
 
-  DeleteRange(
+  DeleteBlobsInObjectStore(transaction, database_id, object_store_id);
+  DeleteRangeHelper(
       leveldb_transaction,
       ObjectStoreMetaDataKey::Encode(database_id, object_store_id, 0),
       ObjectStoreMetaDataKey::EncodeMaxKey(database_id, object_store_id));
 
   leveldb_transaction->Remove(
       ObjectStoreNamesKey::Encode(database_id, object_store_name));
 
-  DeleteRange(leveldb_transaction,
-              IndexFreeListKey::Encode(database_id, object_store_id, 0),
-              IndexFreeListKey::EncodeMaxKey(database_id, object_store_id));
-  DeleteRange(leveldb_transaction,
-              IndexMetaDataKey::Encode(database_id, object_store_id, 0, 0),
-              IndexMetaDataKey::EncodeMaxKey(database_id, object_store_id));
+  DeleteRangeHelper(
+      leveldb_transaction,
+      IndexFreeListKey::Encode(database_id, object_store_id, 0),
+      IndexFreeListKey::EncodeMaxKey(database_id, object_store_id));
+  DeleteRangeHelper(
+      leveldb_transaction,
+      IndexMetaDataKey::Encode(database_id, object_store_id, 0, 0),
+      IndexMetaDataKey::EncodeMaxKey(database_id, object_store_id));
 
   return ClearObjectStore(transaction, database_id, object_store_id);
 }
 
 bool IndexedDBBackingStore::GetRecord(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     const IndexedDBKey& key,
-    std::string* record) {
+    IndexedDBValue* record) {
   IDB_TRACE("IndexedDBBackingStore::GetRecord");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return false;
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
 
   const std::string leveldb_key =
       ObjectStoreDataKey::Encode(database_id, object_store_id, key);
   std::string data;
 
@@ skipping 12 matching lines @@
     return false;
   }
 
   int64 version;
   StringPiece slice(data);
   if (!DecodeVarInt(&slice, &version)) {
     INTERNAL_READ_ERROR(GET_RECORD);
     return false;
   }
 
-  *record = slice.as_string();
-  return true;
+  record->bits = slice.as_string();
+  return GetBlobInfoForRecord(
+      this, leveldb_transaction, database_id, leveldb_key, record);
 }
 
 WARN_UNUSED_RESULT static bool GetNewVersionNumber(
     LevelDBTransaction* transaction,
     int64 database_id,
     int64 object_store_id,
     int64* new_version_number) {
   const std::string last_version_key = ObjectStoreMetaDataKey::Encode(
       database_id, object_store_id, ObjectStoreMetaDataKey::LAST_VERSION);
 
@@ skipping 18 matching lines @@
 
   *new_version_number = version;
   return true;
 }
 
 bool IndexedDBBackingStore::PutRecord(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     const IndexedDBKey& key,
-    const std::string& value,
+    IndexedDBValue& value,
     RecordIdentifier* record_identifier) {
   IDB_TRACE("IndexedDBBackingStore::PutRecord");
+  fprintf(stderr, "ERICU: PutRecord.\n");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return false;
   DCHECK(key.IsValid());
 
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
   int64 version = -1;
   bool ok = GetNewVersionNumber(
       leveldb_transaction, database_id, object_store_id, &version);
   if (!ok)
     return false;
   DCHECK_GE(version, 0);
-  const std::string object_storedata_key =
+  const std::string object_store_data_key =
       ObjectStoreDataKey::Encode(database_id, object_store_id, key);
 
   std::string v;
   EncodeVarInt(version, &v);
-  v.append(value);
+  v.append(value.bits);
 
-  leveldb_transaction->Put(object_storedata_key, &v);
+  leveldb_transaction->Put(object_store_data_key, &v);
+  transaction->PutBlobInfo(database_id, object_store_id, object_store_data_key,
+      &value.blob_info);
 
   const std::string exists_entry_key =
       ExistsEntryKey::Encode(database_id, object_store_id, key);
   std::string version_encoded;
   EncodeInt(version, &version_encoded);
   leveldb_transaction->Put(exists_entry_key, &version_encoded);
 
   std::string key_encoded;
   EncodeIDBKey(key, &key_encoded);
   record_identifier->Reset(key_encoded, version);
   return true;
 }
 
 bool IndexedDBBackingStore::ClearObjectStore(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id) {
   IDB_TRACE("IndexedDBBackingStore::ClearObjectStore");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return false;
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
   const std::string start_key =
       KeyPrefix(database_id, object_store_id).Encode();
   const std::string stop_key =
       KeyPrefix(database_id, object_store_id + 1).Encode();
 
-  DeleteRange(leveldb_transaction, start_key, stop_key);
+  DeleteRangeHelper(leveldb_transaction, start_key, stop_key);
+  DeleteBlobsInObjectStore(transaction, database_id, object_store_id);
   return true;
 }
 
 bool IndexedDBBackingStore::DeleteRecord(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     const RecordIdentifier& record_identifier) {
+  fprintf(stderr, "ERICU: DeleteRecord.\n");
   IDB_TRACE("IndexedDBBackingStore::DeleteRecord");
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return false;
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
 
   const std::string object_store_data_key = ObjectStoreDataKey::Encode(
       database_id, object_store_id, record_identifier.primary_key());
   leveldb_transaction->Remove(object_store_data_key);
+  transaction->PutBlobInfo(database_id, object_store_id, object_store_data_key,
+      NULL);
 
   const std::string exists_entry_key = ExistsEntryKey::Encode(
       database_id, object_store_id, record_identifier.primary_key());
   leveldb_transaction->Remove(exists_entry_key);
   return true;
 }
 
+bool IndexedDBBackingStore::DeleteRange(
+    IndexedDBBackingStore::Transaction* transaction,
+    int64 database_id,
+    int64 object_store_id,
+    const IndexedDBKeyRange& key_range) {
+  fprintf(stderr, "ERICU: DeleteRange.\n");
+  scoped_ptr<IndexedDBBackingStore::Cursor> backing_store_cursor =
+    OpenObjectStoreCursor(transaction, database_id, object_store_id,
+                key_range, indexed_db::CURSOR_NEXT);
+  if (backing_store_cursor) {
+    do {
+      if (!DeleteRecord(
+          transaction, database_id, object_store_id,
+          backing_store_cursor->record_identifier()))
+        return false;
+    } while (backing_store_cursor->Continue());
+  }
+
+  std::string blob_lower =
+      BlobEntryKey::Encode(database_id, object_store_id,
+          key_range.lower());
+  std::string blob_upper =
+      BlobEntryKey::Encode(database_id, object_store_id,
+          key_range.upper());
+  LevelDBTransaction* leveldb_transaction =
+      IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
+  scoped_ptr<LevelDBIterator> it = leveldb_transaction->CreateIterator();
+  it->Seek(blob_lower);
+  while (it->IsValid() &&
+      ((key_range.lowerOpen() &&
+        CompareKeys(it->Key(), blob_lower) <= 0) ||
+       (!key_range.lowerOpen() &&
+        CompareKeys(it->Key(), blob_lower) < 0)))

[jsbell, 2013/09/13 00:12:21]

Given it->Seek(blob_lower), can CompareKeys(it->Key(), blob_lower) < 0 ?

[ericu, 2013/11/20 23:05:39]

Nope; fixed.

+    it->Next();
+
+  while (it->IsValid() &&
+      ((key_range.upperOpen() &&
+        CompareKeys(it->Key(), blob_upper) < 0) ||
+       (!key_range.upperOpen() &&
+        CompareKeys(it->Key(), blob_upper) <= 0))) {
+    StringPiece key_piece(it->Key());
+    std::string object_store_data_key =
+        BlobEntryKey::EncodeToObjectStoreDataKey(&key_piece);
+    if (!object_store_data_key.size())
+      return false;
+    transaction->PutBlobInfo(database_id, object_store_id,
+        object_store_data_key, NULL);
+    it->Next();
+  }
+
+  return true;
+}
+
 bool IndexedDBBackingStore::GetKeyGeneratorCurrentNumber(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     int64* key_generator_current_number) {
   if (!KeyPrefix::ValidIds(database_id, object_store_id))
     return false;
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
 
@@ skipping 119 matching lines @@
   StringPiece slice(data);
   if (!DecodeVarInt(&slice, &version))
     return false;
 
   std::string encoded_key;
   EncodeIDBKey(key, &encoded_key);
   found_record_identifier->Reset(encoded_key, version);
   return true;
 }
 
+class IndexedDBBackingStore::Transaction::ChainedBlobWriter : public
+    base::RefCounted<IndexedDBBackingStore::Transaction::ChainedBlobWriter> {
+public:
+  typedef IndexedDBBackingStore::Transaction::WriteDescriptorVec
+    WriteDescriptorVec;
+  ChainedBlobWriter(
+      int64 database_id,
+      IndexedDBBackingStore* backingStore,
+      WriteDescriptorVec& blobs,
+      scoped_refptr<IndexedDBBackingStore::BlobWriteCallback> callback)
+    : waiting_for_callback_(false),
+      database_id_(database_id),
+      backing_store_(backingStore),
+      callback_(callback),
+      aborted_(false) {
+    blobs_.swap(blobs);
+    iter_ = blobs_.begin();
+    WriteNextFile();
+  }
+
+  void set_delegate(scoped_ptr<FileWriterDelegate> delegate) {
+    delegate_.reset(delegate.release());
+  }
+
+  void ReportWriteCompletion(bool succeeded, int64 bytes_written) {
+    // TODO(ericu): Is there any need to check bytes_written against what we
+    // know, if we know it?
+    DCHECK(waiting_for_callback_);
+    DCHECK(bytes_written >= 0);
+    waiting_for_callback_ = false;
+    content::BrowserThread::DeleteSoon(
+        content::BrowserThread::IO, FROM_HERE,
+        delegate_.release());
+    if (aborted_) {
+      self_ref_ = NULL;
+      return;
+    }
+    if (succeeded)
+      WriteNextFile();
+    else
+      callback_->didFail();
+  }
+
+  void Abort() {
+    if (!waiting_for_callback_)
+      return;
+    self_ref_ = this;
+    aborted_ = true;
+  }
+
+private:
+  void WriteNextFile() {
+    DCHECK(!waiting_for_callback_);
+    DCHECK(!aborted_);
+    if (iter_ == blobs_.end()) {
+      callback_->didSucceed();
+      self_ref_ = NULL;
+    } else {
+      if (!backing_store_->WriteBlobFile(database_id_, *iter_, this)) {
+        callback_->didFail();
+        return;
+      }
+      waiting_for_callback_ = true;
+      ++iter_;
+    }
+  }
+
+  bool waiting_for_callback_;
+  scoped_refptr<ChainedBlobWriter> self_ref_;
+  WriteDescriptorVec blobs_;
+  WriteDescriptorVec::const_iterator iter_;
+  int64 database_id_;
+  IndexedDBBackingStore* backing_store_;
+  scoped_refptr<IndexedDBBackingStore::BlobWriteCallback> callback_;
+  scoped_ptr<FileWriterDelegate> delegate_;
+  bool aborted_;
+};
+
+class LocalWriteClosure : public FileWriterDelegate::DelegateWriteCallback,
+    public base::RefCounted<LocalWriteClosure> {
+ public:
+  LocalWriteClosure(
+      IndexedDBBackingStore::Transaction::ChainedBlobWriter*
+          chained_blob_writer_,
+      base::TaskRunner* task_runner)
+    : chained_blob_writer_(chained_blob_writer_),
+      task_runner_(task_runner),
+      bytes_written_(-1) {
+  }
+
+  void Run(
+      base::PlatformFileError rv,
+      int64 bytes,
+      FileWriterDelegate::WriteProgressStatus write_status) {
+    if (write_status == FileWriterDelegate::SUCCESS_IO_PENDING)
+      return; // We don't care about progress events.
+    if (rv == base::PLATFORM_FILE_OK) {
+      DCHECK(bytes >= 0);
+      DCHECK(write_status == FileWriterDelegate::SUCCESS_COMPLETED);
+      bytes_written_ = bytes;
+    } else {
+      DCHECK(write_status == FileWriterDelegate::ERROR_WRITE_STARTED ||
+          write_status == FileWriterDelegate::ERROR_WRITE_NOT_STARTED);
+    }
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &LocalWriteClosure::callBlobCallbackOnIDBTaskRunner, this,
+            write_status == FileWriterDelegate::SUCCESS_COMPLETED));
+  }
+
+  void writeBlobToFileOnIOThread(
+      const FilePath& file_path, const GURL& blob_url,
+      net::URLRequestContext* request_context) {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+    scoped_ptr<fileapi::FileStreamWriter> writer(
+        new fileapi::LocalFileStreamWriter(
+            task_runner_, file_path, 0, false));
+    scoped_ptr<FileWriterDelegate> delegate(
+        new FileWriterDelegate(writer.Pass()));
+
+    DCHECK(blob_url.is_valid());
+    scoped_ptr<net::URLRequest> blob_request(request_context->CreateRequest(
+        blob_url, delegate.get()));
+
+    delegate->Start(blob_request.Pass(),
+        base::Bind(&LocalWriteClosure::Run, this));
+    chained_blob_writer_->set_delegate(delegate.Pass());
+  }
+
+ private:
+  void callBlobCallbackOnIDBTaskRunner(bool succeeded) {
+    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    chained_blob_writer_->ReportWriteCompletion(succeeded, bytes_written_);
+  }
+
+  IndexedDBBackingStore::Transaction::ChainedBlobWriter* chained_blob_writer_;
+  base::TaskRunner* task_runner_;
+  int64 bytes_written_;
+};
+
+bool IndexedDBBackingStore::WriteBlobFile(
+    int64 database_id,
+    const Transaction::WriteDescriptor& descriptor,
+    Transaction::ChainedBlobWriter* chained_blob_writer) {
+
+  if (!MakeIDBBlobDirectory(blob_path_, database_id, descriptor.key()))
+      return false;
+
+  FilePath path = GetIDBBlobFileName(database_id, descriptor.key());
+
+  if (descriptor.is_file()) {
+    // TODO: Should we validate the snapshot date here?
+    DCHECK(!descriptor.file_path().empty());
+    if (!base::CopyFile(descriptor.file_path(), path))
+      return false;
+
+    base::PlatformFileInfo info;
+    if (file_util::GetFileInfo(descriptor.file_path(), &info)) {
+      if (!file_util::TouchFile(path, info.last_accessed, info.last_modified))
+        ; // TODO: Complain quietly; timestamp's probably not vital.
+    } else {
+        ; // TODO: Complain quietly; timestamp's probably not vital.
+    }
+
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(
+            &Transaction::ChainedBlobWriter::ReportWriteCompletion,
+            chained_blob_writer, true, info.size));
+  } else {
+    DCHECK(descriptor.url().is_valid());
+    scoped_refptr<LocalWriteClosure> write_closure(
+        new LocalWriteClosure(chained_blob_writer, task_runner_));
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(
+            &LocalWriteClosure::writeBlobToFileOnIOThread, write_closure.get(),
+            path, descriptor.url(), request_context_));
+  }
+  return true;
+}
+
+void IndexedDBBackingStore::ReportBlobUnused(
+    int64 database_id,
+    int64 blob_key) {
+  fprintf(stderr, "ERICU: ReportBlobUnused(%ld, %ld).\n", database_id,
+      blob_key);
+  DCHECK(KeyPrefix::IsValidDatabaseId(database_id));
+  bool all_blobs = blob_key == DatabaseMetaDataKey::kAllBlobsKey;
+  DCHECK(all_blobs || DatabaseMetaDataKey::IsValidBlobKey(blob_key));
+  scoped_refptr<LevelDBTransaction> transaction =
+      new LevelDBTransaction(db_.get());
+
+  std::string secondary_key = LiveBlobJournalKey::Encode();
+  IndexedDBBackingStore::Transaction::BlobJournalType secondary_journal;
+  if (!GetBlobJournal(secondary_key, transaction.get(), secondary_journal))
+    return;
+  DCHECK(secondary_journal.size());
+
+  std::string primary_key = BlobJournalKey::Encode();
+  IndexedDBBackingStore::Transaction::BlobJournalType primary_journal;
+  if (!GetBlobJournal(primary_key, transaction.get(), primary_journal))
+    return;
+
+  IndexedDBBackingStore::Transaction::BlobJournalType::iterator journal_iter;
+  // There are several cases to handle.  If blob_key is kAllBlobsKey, we want to
+  // remove all entries with database_id from the secondary journal and add only
+  // kAllBlobsKey to the primary journal.  Otherwise if IsValidBlobKey(blob_key)
+  // and we hit kAllBlobsKey for the right database_id in the journal, we leave
+  // the kAllBlobsKey entry in the secondary journal but add the specific blob
+  // to the primary.  Otherwise if IsValidBlobKey(blob_key) and we find a
+  // matching (database_id, blob_key) tuple, we should move it to the primary
+  // journal.
+  fprintf(stderr, "ERICU: journal sizes are: %ld, %ld.\n",
+      primary_journal.size(), secondary_journal.size());
+  IndexedDBBackingStore::Transaction::BlobJournalType new_secondary_journal;
+  for (journal_iter = secondary_journal.begin();
+      journal_iter != secondary_journal.end(); ++journal_iter) {
+    int64 current_database_id = journal_iter->first;
+    int64 current_blob_key = journal_iter->second;
+    bool current_all_blobs =
+        current_blob_key == DatabaseMetaDataKey::kAllBlobsKey;
+    DCHECK(KeyPrefix::IsValidDatabaseId(current_database_id) ||
+        current_all_blobs);
+    if (current_database_id == database_id && (all_blobs ||
+        current_all_blobs || blob_key == current_blob_key)) {
+      if (!all_blobs) {
+        fprintf(stderr, "ERICU: moving to primary: %ld, %ld.\n", database_id,
+            blob_key);
+        primary_journal.push_back(
+            std::make_pair(database_id, current_blob_key));
+        if (current_all_blobs)
+          new_secondary_journal.push_back(*journal_iter);
+        new_secondary_journal.insert(new_secondary_journal.end(),
+            ++journal_iter, secondary_journal.end()); // All the rest.
+        break;
+      } else {
+        fprintf(stderr, "ERICU: was all_blobs\n");
+      }
+    } else {
+      fprintf(stderr, "ERICU: leaving in secondary: %ld, %ld.\n", database_id,
+          blob_key);
+      new_secondary_journal.push_back(*journal_iter);
+    }
+  }
+  if (all_blobs) {
+    primary_journal.push_back(std::make_pair(
+        database_id, DatabaseMetaDataKey::kAllBlobsKey));
+  }
+  fprintf(stderr, "ERICU: journal sizes are now: %ld, %ld.\n",
+      primary_journal.size(), new_secondary_journal.size());
+  UpdatePrimaryJournalWithBlobList(transaction.get(), primary_journal);
+  UpdateSecondaryJournalWithBlobList(transaction.get(), new_secondary_journal);
+  transaction->Commit();
+  fprintf(stderr, "ERICU: committed journal updates.  Cleaning in 5 sec.\n");
+  // We could just do the deletions/cleaning here, but if there are a lot of
+  // blobs about to be garbage collected, it'd be better to wait and do them all
+  // at once.
+  journal_cleaning_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromSeconds(5), this,

[jsbell, 2013/09/13 00:12:21]

I just landed a change which tweaks the lifetime rules for the backing store so
the factory can keep one alive. It assumes only factory and databases maintain
pointers to the backing store, and uses hasOneRef() to check. I believe this
this change would make the factory retain the backing store indefinitely if the
journal_cleaning_timer_ was running when the backing store was closed - we'll
need to tweak things, e.g. have an explicit database-ref count rather than
relying on hasOneRef()

[ericu, 2013/11/20 23:05:39]

OK, we should talk about what the right thing to do here [and there] is.

[ericu, 2013/12/02 23:35:19]

Addressed in patch set 57.

+      &IndexedDBBackingStore::CleanPrimaryJournalIgnoreReturn);
+}
+
+// This assumes a file path of dbId/3rd-byte-of-counter/counter.
+FilePath IndexedDBBackingStore::GetIDBBlobFileName(
+    int64 database_id, int64 key) {
+  FilePath path = GetIDBBlobDirectoryNameForKey(blob_path_, database_id, key);
+  path = path.AppendASCII(base::StringPrintf("%lx", key));
+  return path;
+}
+
 static bool CheckIndexAndMetaDataKey(const LevelDBIterator* it,
                                      const std::string& stop_key,
                                      int64 index_id,
                                      unsigned char meta_data_type) {
   if (!it->IsValid() || CompareKeys(it->Key(), stop_key) >= 0)
     return false;
 
   StringPiece slice(it->Key());
   IndexMetaDataKey meta_data_key;
   bool ok = IndexMetaDataKey::Decode(&slice, &meta_data_key);
@@ skipping 82 matching lines @@
 
       it->Next();
     }
 
     (*indexes)[index_id] = IndexedDBIndexMetadata(
         index_name, index_id, key_path, index_unique, index_multi_entry);
   }
   return true;
 }
 
+bool IndexedDBBackingStore::RemoveBlobFile(int64 database_id, int64 key) {
+  FilePath fileName = GetIDBBlobFileName(database_id, key);
+  return base::DeleteFile(fileName, false);
+}
+
+bool IndexedDBBackingStore::RemoveBlobDirectory(int64 database_id) {
+  FilePath dirName = GetIDBBlobDirectoryName(blob_path_, database_id);
+  return base::DeleteFile(dirName, true);
+}
+
+bool IndexedDBBackingStore::CleanUpBlobJournal(
+  const std::string& level_db_key) {
+  scoped_refptr<LevelDBTransaction> journal_transaction =
+      new LevelDBTransaction(db_.get());
+  IndexedDBBackingStore::Transaction::BlobJournalType journal;
+  if (!GetBlobJournal(level_db_key, journal_transaction.get(),
+      journal)) {
+    return false;
+  }
+  if (!journal.size()) {
+    return true;
+  }
+  if (journal.size()) {
+    IndexedDBBackingStore::Transaction::BlobJournalType::iterator journal_iter;
+    for (journal_iter = journal.begin(); journal_iter != journal.end();
+        ++journal_iter) {
+      int64 database_id = journal_iter->first;
+      int64 blob_key = journal_iter->second;
+      DCHECK(KeyPrefix::IsValidDatabaseId(database_id));
+      if (blob_key == DatabaseMetaDataKey::kAllBlobsKey) {
+        RemoveBlobDirectory(database_id);
+      } else {
+        DCHECK(DatabaseMetaDataKey::IsValidBlobKey(blob_key));
+        RemoveBlobFile(database_id, blob_key);
+      }
+    }
+  }
+  ClearBlobJournal(journal_transaction.get(), level_db_key);
+  return journal_transaction->Commit();
+}
+
+void IndexedDBBackingStore::CleanPrimaryJournalIgnoreReturn() {
+  fprintf(stderr, "ERICU: Cleaning primary journal.\n");
+  CleanUpBlobJournal(BlobJournalKey::Encode());
+}
+
 WARN_UNUSED_RESULT static bool SetMaxIndexId(LevelDBTransaction* transaction,
                                              int64 database_id,
                                              int64 object_store_id,
                                              int64 index_id) {
   int64 max_index_id = -1;
   const std::string max_index_id_key = ObjectStoreMetaDataKey::Encode(
       database_id, object_store_id, ObjectStoreMetaDataKey::MAX_INDEX_ID);
   bool found = false;
   bool ok = GetInt(transaction, max_index_id_key, &max_index_id, &found);
   if (!ok) {
@@ skipping 54 matching lines @@
   IDB_TRACE("IndexedDBBackingStore::DeleteIndex");
   if (!KeyPrefix::ValidIds(database_id, object_store_id, index_id))
     return false;
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
 
   const std::string index_meta_data_start =
       IndexMetaDataKey::Encode(database_id, object_store_id, index_id, 0);
   const std::string index_meta_data_end =
       IndexMetaDataKey::EncodeMaxKey(database_id, object_store_id, index_id);
-  DeleteRange(leveldb_transaction, index_meta_data_start, index_meta_data_end);
+  DeleteRangeHelper(leveldb_transaction, index_meta_data_start,
+      index_meta_data_end);
 
   const std::string index_data_start =
       IndexDataKey::EncodeMinKey(database_id, object_store_id, index_id);
   const std::string index_data_end =
       IndexDataKey::EncodeMaxKey(database_id, object_store_id, index_id);
-  DeleteRange(leveldb_transaction, index_data_start, index_data_end);
+  DeleteRangeHelper(leveldb_transaction, index_data_start, index_data_end);
   return true;
 }
 
 bool IndexedDBBackingStore::PutIndexDataForRecord(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     int64 index_id,
     const IndexedDBKey& key,
     const RecordIdentifier& record_identifier) {
@@ skipping 200 matching lines @@
     INTERNAL_READ_ERROR(KEY_EXISTS_IN_INDEX);
     return false;
   }
 
   StringPiece slice(found_encoded_primary_key);
   return DecodeIDBKey(&slice, found_primary_key) && slice.empty();
 }
 
 IndexedDBBackingStore::Cursor::Cursor(
     const IndexedDBBackingStore::Cursor* other)
-    : transaction_(other->transaction_),
+    : backing_store_(other->backing_store_),
+      transaction_(other->transaction_),
+      database_id_(other->database_id_),
       cursor_options_(other->cursor_options_),
       current_key_(new IndexedDBKey(*other->current_key_)) {
   if (other->iterator_) {
     iterator_ = transaction_->CreateIterator();
 
     if (other->iterator_->IsValid()) {
       iterator_->Seek(other->iterator_->Key());
       DCHECK(iterator_->IsValid());
     }
   }
 }
 
-IndexedDBBackingStore::Cursor::Cursor(LevelDBTransaction* transaction,
-                                      const CursorOptions& cursor_options)
-    : transaction_(transaction), cursor_options_(cursor_options) {}
+IndexedDBBackingStore::Cursor::Cursor(
+    scoped_refptr<IndexedDBBackingStore> backing_store,
+    LevelDBTransaction* transaction,
+    int64 database_id,
+    const CursorOptions& cursor_options)
+  : backing_store_(backing_store),
+    transaction_(transaction),
+    database_id_(database_id),
+    cursor_options_(cursor_options) {
+}
 IndexedDBBackingStore::Cursor::~Cursor() {}
 
 bool IndexedDBBackingStore::Cursor::FirstSeek() {
   iterator_ = transaction_->CreateIterator();
   if (cursor_options_.forward)
     iterator_->Seek(cursor_options_.low_key);
   else
     iterator_->Seek(cursor_options_.high_key);
 
   return Continue(0, READY);
@@ skipping 143 matching lines @@
 }
 
 const IndexedDBBackingStore::RecordIdentifier&
 IndexedDBBackingStore::Cursor::record_identifier() const {
   return record_identifier_;
 }
 
 class ObjectStoreKeyCursorImpl : public IndexedDBBackingStore::Cursor {
  public:
   ObjectStoreKeyCursorImpl(
+      scoped_refptr<IndexedDBBackingStore> backing_store,
       LevelDBTransaction* transaction,
+      int64 database_id,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
-      : IndexedDBBackingStore::Cursor(transaction, cursor_options) {}
+      : IndexedDBBackingStore::Cursor(
+          backing_store, transaction, database_id, cursor_options) {}
 
   virtual Cursor* Clone() OVERRIDE {
     return new ObjectStoreKeyCursorImpl(this);
   }
 
   // IndexedDBBackingStore::Cursor
-  virtual std::string* Value() OVERRIDE {
+  virtual IndexedDBValue* Value() OVERRIDE {
     NOTREACHED();
     return NULL;
   }
   virtual bool LoadCurrentRow() OVERRIDE;
 
  protected:
   virtual std::string EncodeKey(const IndexedDBKey& key) OVERRIDE {
     return ObjectStoreDataKey::Encode(
         cursor_options_.database_id, cursor_options_.object_store_id, key);
   }
@@ skipping 24 matching lines @@
   std::string encoded_key;
   EncodeIDBKey(*current_key_, &encoded_key);
   record_identifier_.Reset(encoded_key, version);
 
   return true;
 }
 
 class ObjectStoreCursorImpl : public IndexedDBBackingStore::Cursor {
  public:
   ObjectStoreCursorImpl(
+      scoped_refptr<IndexedDBBackingStore> backing_store,
       LevelDBTransaction* transaction,
+      int64 database_id,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
-      : IndexedDBBackingStore::Cursor(transaction, cursor_options) {}
+      : IndexedDBBackingStore::Cursor(
+          backing_store, transaction, database_id, cursor_options) {}
 
   virtual Cursor* Clone() OVERRIDE { return new ObjectStoreCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
-  virtual std::string* Value() OVERRIDE { return &current_value_; }
+  virtual IndexedDBValue* Value() OVERRIDE { return &current_value_; }
   virtual bool LoadCurrentRow() OVERRIDE;
 
  protected:
   virtual std::string EncodeKey(const IndexedDBKey& key) OVERRIDE {
     return ObjectStoreDataKey::Encode(
         cursor_options_.database_id, cursor_options_.object_store_id, key);
   }
 
  private:
   explicit ObjectStoreCursorImpl(const ObjectStoreCursorImpl* other)
       : IndexedDBBackingStore::Cursor(other),
         current_value_(other->current_value_) {}
 
-  std::string current_value_;
+  IndexedDBValue current_value_;
 };
 
 bool ObjectStoreCursorImpl::LoadCurrentRow() {
-  StringPiece slice(iterator_->Key());
+  StringPiece key_slice(iterator_->Key());
   ObjectStoreDataKey object_store_data_key;
-  if (!ObjectStoreDataKey::Decode(&slice, &object_store_data_key)) {
+  if (!ObjectStoreDataKey::Decode(&key_slice, &object_store_data_key)) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
 
   current_key_ = object_store_data_key.user_key();
 
   int64 version;
-  slice = StringPiece(iterator_->Value());
-  if (!DecodeVarInt(&slice, &version)) {
+  StringPiece value_slice = StringPiece(iterator_->Value());
+  if (!DecodeVarInt(&value_slice, &version)) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
 
   // TODO(jsbell): This re-encodes what was just decoded; try and optimize.
   std::string encoded_key;
   EncodeIDBKey(*current_key_, &encoded_key);
   record_identifier_.Reset(encoded_key, version);
 
-  current_value_ = slice.as_string();
-  return true;
+  // TODO(ericu): Don't set bits until we know we've succeeded?
+  current_value_.bits = value_slice.as_string();
+  return GetBlobInfoForRecord(backing_store_, transaction_, database_id_,
+      iterator_->Key().as_string(), &current_value_);
 }
 
 class IndexKeyCursorImpl : public IndexedDBBackingStore::Cursor {
  public:
   IndexKeyCursorImpl(
+      scoped_refptr<IndexedDBBackingStore> backing_store,
       LevelDBTransaction* transaction,
+      int64 database_id,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
-      : IndexedDBBackingStore::Cursor(transaction, cursor_options) {}
+      : IndexedDBBackingStore::Cursor(
+          backing_store, transaction, database_id, cursor_options) {}
 
   virtual Cursor* Clone() OVERRIDE { return new IndexKeyCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
-  virtual std::string* Value() OVERRIDE {
+  virtual IndexedDBValue* Value() OVERRIDE {
     NOTREACHED();
     return NULL;
   }
   virtual const IndexedDBKey& primary_key() const OVERRIDE {
     return *primary_key_;
   }
-  virtual const IndexedDBBackingStore::RecordIdentifier& RecordIdentifier()
-      const {
+  virtual const IndexedDBBackingStore::RecordIdentifier& record_identifier()
+      const OVERRIDE {
     NOTREACHED();
     return record_identifier_;
   }
   virtual bool LoadCurrentRow() OVERRIDE;
 
  protected:
   virtual std::string EncodeKey(const IndexedDBKey& key) OVERRIDE {
     return IndexDataKey::Encode(cursor_options_.database_id,
                                 cursor_options_.object_store_id,
                                 cursor_options_.index_id,
@@ skipping 63 matching lines @@
     transaction_->Remove(iterator_->Key());
     return false;
   }
 
   return true;
 }
 
 class IndexCursorImpl : public IndexedDBBackingStore::Cursor {
  public:
   IndexCursorImpl(
+      scoped_refptr<IndexedDBBackingStore> backing_store,
       LevelDBTransaction* transaction,
+      int64 database_id,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
-      : IndexedDBBackingStore::Cursor(transaction, cursor_options) {}
+      : IndexedDBBackingStore::Cursor(
+          backing_store, transaction, database_id, cursor_options) {}
 
   virtual Cursor* Clone() OVERRIDE { return new IndexCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
-  virtual std::string* Value() OVERRIDE { return &current_value_; }
+  virtual IndexedDBValue* Value() OVERRIDE { return &current_value_; }
   virtual const IndexedDBKey& primary_key() const OVERRIDE {
     return *primary_key_;
   }
-  virtual const IndexedDBBackingStore::RecordIdentifier& RecordIdentifier()
-      const {
+  virtual const IndexedDBBackingStore::RecordIdentifier& record_identifier()
+      const OVERRIDE {
     NOTREACHED();
     return record_identifier_;
   }
   virtual bool LoadCurrentRow() OVERRIDE;
 
  protected:
   virtual std::string EncodeKey(const IndexedDBKey& key) OVERRIDE {
     return IndexDataKey::Encode(cursor_options_.database_id,
                                 cursor_options_.object_store_id,
                                 cursor_options_.index_id,
                                 key);
   }
 
  private:
   explicit IndexCursorImpl(const IndexCursorImpl* other)
       : IndexedDBBackingStore::Cursor(other),
         primary_key_(new IndexedDBKey(*other->primary_key_)),
         current_value_(other->current_value_),
         primary_leveldb_key_(other->primary_leveldb_key_) {}
 
   scoped_ptr<IndexedDBKey> primary_key_;
-  std::string current_value_;
+  IndexedDBValue current_value_;
   std::string primary_leveldb_key_;
 };
 
 bool IndexCursorImpl::LoadCurrentRow() {
   StringPiece slice(iterator_->Key());
   IndexDataKey index_data_key;
   if (!IndexDataKey::Decode(&slice, &index_data_key)) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
 
   current_key_ = index_data_key.user_key();
   DCHECK(current_key_);
 
   slice = StringPiece(iterator_->Value());
   int64 index_data_version;
   if (!DecodeVarInt(&slice, &index_data_version)) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
   if (!DecodeIDBKey(&slice, &primary_key_)) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
 
+  DCHECK_EQ(index_data_key.DatabaseId(), database_id_);
   primary_leveldb_key_ =
       ObjectStoreDataKey::Encode(index_data_key.DatabaseId(),
                                  index_data_key.ObjectStoreId(),
                                  *primary_key_);
 
   std::string result;
   bool found = false;
   bool ok = transaction_->Get(primary_leveldb_key_, &result, &found);
   if (!ok) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
@@ skipping 13 matching lines @@
   if (!DecodeVarInt(&slice, &object_store_data_version)) {
     INTERNAL_READ_ERROR(LOAD_CURRENT_ROW);
     return false;
   }
 
   if (object_store_data_version != index_data_version) {
     transaction_->Remove(iterator_->Key());
     return false;
   }
 
-  current_value_ = slice.as_string();
-  return true;
+  current_value_.bits = slice.as_string();
+  return GetBlobInfoForRecord(backing_store_, transaction_, database_id_,
+      primary_leveldb_key_, &current_value_);
 }
 
 bool ObjectStoreCursorOptions(
     LevelDBTransaction* transaction,
     int64 database_id,
     int64 object_store_id,
     const IndexedDBKeyRange& range,
     indexed_db::CursorDirection direction,
     IndexedDBBackingStore::Cursor::CursorOptions* cursor_options) {
   cursor_options->database_id = database_id;
@@ skipping 137 matching lines @@
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
   IndexedDBBackingStore::Cursor::CursorOptions cursor_options;
   if (!ObjectStoreCursorOptions(leveldb_transaction,
                                 database_id,
                                 object_store_id,
                                 range,
                                 direction,
                                 &cursor_options))
     return scoped_ptr<IndexedDBBackingStore::Cursor>();
   scoped_ptr<ObjectStoreCursorImpl> cursor(
-      new ObjectStoreCursorImpl(leveldb_transaction, cursor_options));
+      new ObjectStoreCursorImpl(
+          this, leveldb_transaction, database_id, cursor_options));
   if (!cursor->FirstSeek())
     return scoped_ptr<IndexedDBBackingStore::Cursor>();
 
   return cursor.PassAs<IndexedDBBackingStore::Cursor>();
 }
 
 scoped_ptr<IndexedDBBackingStore::Cursor>
 IndexedDBBackingStore::OpenObjectStoreKeyCursor(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     const IndexedDBKeyRange& range,
     indexed_db::CursorDirection direction) {
   IDB_TRACE("IndexedDBBackingStore::OpenObjectStoreKeyCursor");
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
   IndexedDBBackingStore::Cursor::CursorOptions cursor_options;
   if (!ObjectStoreCursorOptions(leveldb_transaction,
                                 database_id,
                                 object_store_id,
                                 range,
                                 direction,
                                 &cursor_options))
     return scoped_ptr<IndexedDBBackingStore::Cursor>();
   scoped_ptr<ObjectStoreKeyCursorImpl> cursor(
-      new ObjectStoreKeyCursorImpl(leveldb_transaction, cursor_options));
+      new ObjectStoreKeyCursorImpl(
+          this, leveldb_transaction, database_id, cursor_options));
   if (!cursor->FirstSeek())
     return scoped_ptr<IndexedDBBackingStore::Cursor>();
 
   return cursor.PassAs<IndexedDBBackingStore::Cursor>();
 }
 
 scoped_ptr<IndexedDBBackingStore::Cursor>
 IndexedDBBackingStore::OpenIndexKeyCursor(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     int64 index_id,
     const IndexedDBKeyRange& range,
     indexed_db::CursorDirection direction) {
   IDB_TRACE("IndexedDBBackingStore::OpenIndexKeyCursor");
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
   IndexedDBBackingStore::Cursor::CursorOptions cursor_options;
   if (!IndexCursorOptions(leveldb_transaction,
                           database_id,
                           object_store_id,
                           index_id,
                           range,
                           direction,
                           &cursor_options))
     return scoped_ptr<IndexedDBBackingStore::Cursor>();
   scoped_ptr<IndexKeyCursorImpl> cursor(
-      new IndexKeyCursorImpl(leveldb_transaction, cursor_options));
+      new IndexKeyCursorImpl(
+          this, leveldb_transaction, database_id, cursor_options));
   if (!cursor->FirstSeek())
     return scoped_ptr<IndexedDBBackingStore::Cursor>();
 
   return cursor.PassAs<IndexedDBBackingStore::Cursor>();
 }
 
 scoped_ptr<IndexedDBBackingStore::Cursor>
 IndexedDBBackingStore::OpenIndexCursor(
     IndexedDBBackingStore::Transaction* transaction,
     int64 database_id,
     int64 object_store_id,
     int64 index_id,
     const IndexedDBKeyRange& range,
     indexed_db::CursorDirection direction) {
   IDB_TRACE("IndexedDBBackingStore::OpenIndexCursor");
   LevelDBTransaction* leveldb_transaction =
       IndexedDBBackingStore::Transaction::LevelDBTransactionFrom(transaction);
   IndexedDBBackingStore::Cursor::CursorOptions cursor_options;
   if (!IndexCursorOptions(leveldb_transaction,
                           database_id,
                           object_store_id,
                           index_id,
                           range,
                           direction,
                           &cursor_options))
     return scoped_ptr<IndexedDBBackingStore::Cursor>();
   scoped_ptr<IndexCursorImpl> cursor(
-      new IndexCursorImpl(leveldb_transaction, cursor_options));
+      new IndexCursorImpl(
+          this, leveldb_transaction, database_id, cursor_options));
   if (!cursor->FirstSeek())
     return scoped_ptr<IndexedDBBackingStore::Cursor>();
 
   return cursor.PassAs<IndexedDBBackingStore::Cursor>();
 }
 
 IndexedDBBackingStore::Transaction::Transaction(
     IndexedDBBackingStore* backing_store)
-    : backing_store_(backing_store) {}
+    : backing_store_(backing_store),
+      database_id_(-1) {
+  blob_info_tree_.abstractor().comparator_ = backing_store->comparator();
+}
 
 IndexedDBBackingStore::Transaction::~Transaction() {}
 
 void IndexedDBBackingStore::Transaction::Begin() {
   IDB_TRACE("IndexedDBBackingStore::Transaction::Begin");
   DCHECK(!transaction_.get());
   transaction_ = new LevelDBTransaction(backing_store_->db_.get());
-}
-
-bool IndexedDBBackingStore::Transaction::Commit() {
-  IDB_TRACE("IndexedDBBackingStore::Transaction::Commit");
-  DCHECK(transaction_.get());
+  fprintf(stderr, "ERICU: %p::Begin(%p).\n", this, transaction_.get());
+}
+
+bool IndexedDBBackingStore::Transaction::HandleBlobPreTransaction(
+    BlobEntryKeyValuePairVec* new_blob_entries,
+    WriteDescriptorVec* new_files_to_write) {
+  TreeType::Iterator iter;
+  iter.StartIterLeast(&blob_info_tree_);
+  new_blob_entries->clear();
+  new_files_to_write->clear();
+  if (*iter) {
+    // Create LevelDBTransaction for the name generator seed and add-journal.
+    scoped_refptr<LevelDBTransaction> pre_transaction =
+        new LevelDBTransaction(backing_store_->db_.get());
+    BlobJournalType journal;
+    for (; *iter; ++iter) {
+      std::vector<IndexedDBBlobInfo>::iterator info_iter;
+      std::vector<IndexedDBBlobInfo*> new_blob_keys;
+      for (info_iter = (*iter)->blob_info.begin();
+           info_iter != (*iter)->blob_info.end(); ++info_iter) {
+        int64 next_blob_key = -1;
+        bool result = GetBlobKeyGeneratorCurrentNumber(
+            pre_transaction.get(), database_id_, next_blob_key);
+        if (!result || next_blob_key < 0)
+          return false;
+        BlobJournalEntryType journal_entry =
+            std::make_pair(database_id_, next_blob_key);
+        journal.push_back(journal_entry);
+        if (info_iter->is_file()) {
+          new_files_to_write->push_back(
+              WriteDescriptor(info_iter->file_path(), next_blob_key));
+        } else {
+          new_files_to_write->push_back(
+              WriteDescriptor(info_iter->url(), next_blob_key));
+        }
+        info_iter->set_key(next_blob_key);
+        new_blob_keys.push_back(&*info_iter);
+        result = UpdateBlobKeyGeneratorCurrentNumber(
+            pre_transaction.get(), database_id_, next_blob_key + 1);
+        if (!result)
+          return result;
+      }
+      BlobEntryKey blob_entry_key;
+      StringPiece key_piece((*iter)->key);
+      if (!BlobEntryKey::FromObjectStoreDataKey(&key_piece, &blob_entry_key)) {
+        NOTREACHED();
+        return false;
+      }
+      new_blob_entries->push_back(std::make_pair(blob_entry_key,
+          EncodeBlobData(new_blob_keys)));
+    }
+    UpdatePrimaryJournalWithBlobList(pre_transaction.get(), journal);
+    if (!pre_transaction->Commit())
+      return false;
+  }
+  return true;
+}
+
+bool IndexedDBBackingStore::Transaction::CollectBlobFilesToRemove() {
+  TreeType::Iterator iter;
+  iter.StartIterLeast(&blob_info_tree_);
+  // Look up all old files to remove as part of the transaction, store their
+  // names in blobs_to_remove_, and remove their old blob data entries.
+  if (*iter) {
+    scoped_ptr<LevelDBIterator> db_iter = transaction_->CreateIterator();
+    for (; *iter; ++iter) {
+      BlobEntryKey blob_entry_key;
+      StringPiece key_piece((*iter)->key);
+      if (!BlobEntryKey::FromObjectStoreDataKey(&key_piece, &blob_entry_key)) {
+        NOTREACHED();
+        INTERNAL_WRITE_ERROR(TRANSACTION_COMMIT_METHOD);
+        transaction_ = NULL;
+        return false;
+      }
+      if (database_id_ < 0)
+        database_id_ = blob_entry_key.database_id();
+      else
+        DCHECK_EQ(database_id_, blob_entry_key.database_id());
+      std::string blob_entry_key_bytes = blob_entry_key.Encode();
+      db_iter->Seek(blob_entry_key_bytes);
+      if (db_iter->IsValid()) {
+        std::vector<IndexedDBBlobInfo> blob_info;
+        if (!DecodeBlobData(db_iter->Value().as_string(), &blob_info)) {
+          INTERNAL_READ_ERROR(TRANSACTION_COMMIT_METHOD);
+          transaction_ = NULL;
+          return false;
+        }
+        std::vector<IndexedDBBlobInfo>::iterator blob_info_iter;
+        for (blob_info_iter = blob_info.begin();
+            blob_info_iter != blob_info.end(); ++blob_info_iter)
+          blobs_to_remove_.push_back(
+              std::make_pair(database_id_, blob_info_iter->key()));
+        transaction_->Remove(blob_entry_key_bytes);
+      } else {
+        fprintf(stderr, "ERICU: db_iter wasn't valid.\n");
+      }
+    }
+  }
+  return true;
+}
+
+void IndexedDBBackingStore::Transaction::WriteNewBlobs(
+    BlobEntryKeyValuePairVec& new_blob_entries,
+    WriteDescriptorVec& new_files_to_write,
+    scoped_refptr<BlobWriteCallback> callback) {
+  DCHECK_GT(new_files_to_write.size(), 0UL);
+  DCHECK_GT(database_id_, 0);
+  BlobEntryKeyValuePairVec::iterator blob_entry_iter;
+  for (blob_entry_iter = new_blob_entries.begin();
+      blob_entry_iter != new_blob_entries.end(); ++blob_entry_iter) {
+    // Add the new blob-table entry for each blob to the main transaction, or
+    // remove any entry that may exist if there's no new one.
+    if (!blob_entry_iter->second.size())
+      transaction_->Remove(blob_entry_iter->first.Encode());
+    else
+      transaction_->Put(blob_entry_iter->first.Encode(),
+          &blob_entry_iter->second);
+  }
+  // Creating the writer will start it going asynchronously.
+  chained_blob_writer_ = new ChainedBlobWriter(database_id_, backing_store_,
+      new_files_to_write, callback);
+}
+
+bool IndexedDBBackingStore::Transaction::SortBlobsToRemove() {
+  IndexedDBActiveBlobRegistry* registry =
+      backing_store_->active_blob_registry();
+  BlobJournalType::iterator iter;
+  BlobJournalType primary_journal, secondary_journal;
+  for (iter = blobs_to_remove_.begin(); iter != blobs_to_remove_.end();
+       ++iter) {
+    if (registry->MarkDeletedCheckIfUsed(iter->first, iter->second))
+      secondary_journal.push_back(*iter);
+    else
+      primary_journal.push_back(*iter);
+  }
+  fprintf(stderr, "ERICU: Updating primary journal.\n");
+  UpdatePrimaryJournalWithBlobList(transaction_.get(), primary_journal);
+  fprintf(stderr, "ERICU: Updating secondary journal.\n");
+  if (!MergeBlobsIntoSecondaryJournal(transaction_.get(), secondary_journal)) {
+    fprintf(stderr, "ERICU: Updating secondary journal FAILED!\n");
+    return false;
+  }
+  // To signal how many blobs need attention right now.
+  blobs_to_remove_.swap(primary_journal);
+  return true;
+}
+
+bool IndexedDBBackingStore::Transaction::CommitPhaseOne(
+    scoped_refptr<BlobWriteCallback> callback) {
+  IDB_TRACE("IndexedDBBackingStore::Transaction::commit");
+  DCHECK(transaction_);
+  DCHECK(backing_store_->task_runner()->RunsTasksOnCurrentThread());
+
+  if (!backing_store_->CleanUpBlobJournal(BlobJournalKey::Encode())) {
+    INTERNAL_WRITE_ERROR(TRANSACTION_COMMIT_METHOD);
+    transaction_ = NULL;
+    return false;
+  }
+
+  BlobEntryKeyValuePairVec new_blob_entries;
+  WriteDescriptorVec new_files_to_write;
+  // This commits the journal of blob files we're about to add, if any.
+  if (!HandleBlobPreTransaction(&new_blob_entries, &new_files_to_write)) {
+    INTERNAL_WRITE_ERROR(TRANSACTION_COMMIT_METHOD);
+    transaction_ = NULL;
+    return false;
+  }
+
+  DCHECK(!new_files_to_write.size() ||
+      KeyPrefix::IsValidDatabaseId(database_id_));
+  fprintf(stderr, "ERICU: Calling CollectBlobFilesToRemove.\n");
+  if (!CollectBlobFilesToRemove()) {
+    INTERNAL_WRITE_ERROR(TRANSACTION_COMMIT_METHOD);
+    transaction_ = NULL;
+    return false;
+  }
+
+  if (new_files_to_write.size()) {
+    // This kicks off the writes of the new blobs, if any.
+    // This call will zero out new_blob_entries and new_files_to_write.
+    WriteNewBlobs(new_blob_entries, new_files_to_write, callback);
+    // Remove the add journal, if any; once the blobs are written, and we
+    // commit, this will do the cleanup.
+    ClearBlobJournal(transaction_.get(), BlobJournalKey::Encode());
+  } else {
+    callback->didSucceed();
+  }
+
+  return true;
+}
+
+bool IndexedDBBackingStore::Transaction::CommitPhaseTwo() {
+  fprintf(stderr, "ERICU: In CommitPhaseTwo; blobs_to_remove_.size() is %lu.\n",
+      blobs_to_remove_.size());
+  if (blobs_to_remove_.size())
+    if (!SortBlobsToRemove()) {
+      INTERNAL_WRITE_ERROR(TRANSACTION_COMMIT_METHOD);
+      transaction_ = NULL;
+      return false;
+    }
+
+  fprintf(stderr, "ERICU: committing transaction_.\n");
   bool result = transaction_->Commit();
   transaction_ = NULL;
+
   if (!result)
     INTERNAL_WRITE_ERROR(TRANSACTION_COMMIT_METHOD);
+  else if (blobs_to_remove_.size())
+    backing_store_->CleanUpBlobJournal(BlobJournalKey::Encode());
+
   return result;
 }
 
 void IndexedDBBackingStore::Transaction::Rollback() {
   IDB_TRACE("IndexedDBBackingStore::Transaction::Rollback");
   DCHECK(transaction_.get());
+  if (chained_blob_writer_)
+    chained_blob_writer_->Abort();
   transaction_->Rollback();
   transaction_ = NULL;
 }
 
+// This is storing an info, even if empty, even if the previous key had no blob
+// info that we know of.  It duplicates a bunch of information stored in the
+// leveldb transaction, but only w.r.t. the user keys altered--we don't keep the
+// changes to exists or index keys here.
+void IndexedDBBackingStore::Transaction::PutBlobInfo(
+    int64 database_id,
+    int64 object_store_id,
+    const std::string&key,
+    std::vector<IndexedDBBlobInfo>* blob_info) {
+    fprintf(stderr, "ERICU: PutBlobInfo ; blob_info is %p.\n", blob_info);
+    DCHECK_GT(key.size(), 0UL);
+    if (database_id_ < 0)
+        database_id_ = database_id;
+    DCHECK_EQ(database_id_, database_id);
+    AVLTreeNode* node = blob_info_tree_.Search(key);
+    if (!node) {
+        node = new AVLTreeNode;
+        node->key.insert(node->key.end(), key.begin(), key.end());
+        blob_info_tree_.Insert(node);
+        node->object_store_id = object_store_id;
+    }
+    DCHECK_EQ(node->object_store_id, object_store_id);
+    node->blob_info.clear();
+    if (blob_info)
+        node->blob_info.swap(*blob_info);
+}
+
+IndexedDBBackingStore::Transaction::WriteDescriptor::WriteDescriptor(
+    const GURL& url, int64_t key)
+    : is_file_(false),
+      url_(url),
+      key_(key)
+{
+}
+
+IndexedDBBackingStore::Transaction::WriteDescriptor::WriteDescriptor(
+    const FilePath& file_path, int64_t key)
+    : is_file_(true),
+      file_path_(file_path),
+      key_(key)
+{
+}
+
 }  // namespace content