Blob support for IDB [Chromium]

content/browser/indexed_db/indexed_db_database.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_database.h"
 
 #include <math.h>
 #include <set>
+#include <vector>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
+#include "content/browser/indexed_db/indexed_db_blob_info.h"
 #include "content/browser/indexed_db/indexed_db_connection.h"
 #include "content/browser/indexed_db/indexed_db_cursor.h"
 #include "content/browser/indexed_db/indexed_db_factory.h"
 #include "content/browser/indexed_db/indexed_db_index_writer.h"
 #include "content/browser/indexed_db/indexed_db_tracing.h"
 #include "content/browser/indexed_db/indexed_db_transaction.h"
+#include "content/browser/indexed_db/indexed_db_value.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 "third_party/WebKit/public/platform/WebIDBDatabaseException.h"
+#include "webkit/browser/blob/blob_data_handle.h"
 
 using base::Int64ToString16;
 using blink::WebIDBKeyTypeNumber;
 
 namespace content {
 
 // PendingOpenCall has a scoped_refptr<IndexedDBDatabaseCallbacks> because it
 // isn't a connection yet.
 class IndexedDBDatabase::PendingOpenCall {
  public:
   PendingOpenCall(scoped_refptr<IndexedDBCallbacks> callbacks,
                   scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
+                  int child_process_id,
                   int64 transaction_id,
                   int64 version)
       : callbacks_(callbacks),

[jsbell, 2013/12/18 23:04:40]

We could potentially introduce a IndexedDBPendingConnection class that
encapsulates { callbacks, database_callbacks, version, transaction_id,
child_process_id } rather than schlepping these all around in parallel. That
could land early (without child_process_id) to minimize the later diff.

(There's a TODO item to introduce an actual queue of pending connections - 
crbug.com/225850 - so this would be generally helpful.)

[ericu, 2013/12/19 05:19:11]

I put a TODO in my notes; I'll look into it.

[ericu, 2014/03/05 23:30:40]

I just put this change in.

         database_callbacks_(database_callbacks),
+        child_process_id_(child_process_id),
         version_(version),
         transaction_id_(transaction_id) {}
   scoped_refptr<IndexedDBCallbacks> Callbacks() { return callbacks_; }
   scoped_refptr<IndexedDBDatabaseCallbacks> DatabaseCallbacks() {
     return database_callbacks_;
   }
+  int ChildProcessId() { return child_process_id_; }

[jsbell, 2013/12/18 23:04:40]

FYI, I think I have a patch in flight somewhere that makes all of these conform
to coding conventions, i.e. simple const accessors are named child_process_id().
But you'll probably notice during a rebase.

[ericu, 2013/12/19 05:19:11]

Yep--that'll be fun.

   int64 Version() { return version_; }
   int64 TransactionId() const { return transaction_id_; }
 
  private:
   scoped_refptr<IndexedDBCallbacks> callbacks_;
   scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks_;
+  int child_process_id_;
   int64 version_;
   const int64 transaction_id_;
 };
 
 // PendingUpgradeCall has a scoped_ptr<IndexedDBConnection> because it owns the
 // in-progress connection.
 class IndexedDBDatabase::PendingUpgradeCall {
  public:
   PendingUpgradeCall(scoped_refptr<IndexedDBCallbacks> callbacks,
                      scoped_ptr<IndexedDBConnection> connection,
@@ skipping 504 matching lines @@
       return;
     }
 
     key = &backing_store_cursor->key();
   }
 
   scoped_ptr<IndexedDBKey> primary_key;
   bool ok;
   if (index_id == IndexedDBIndexMetadata::kInvalidId) {
     // Object Store Retrieval Operation
-    std::string value;
+    IndexedDBValue value;
     ok = backing_store_->GetRecord(transaction->BackingStoreTransaction(),
                                    id(),
                                    object_store_id,
                                    *key,
                                    &value);
     if (!ok) {
       callbacks->OnError(
           IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error in GetRecord."));
       return;
@@ skipping 32 matching lines @@
     callbacks->OnSuccess();
     return;
   }
   if (cursor_type == indexed_db::CURSOR_KEY_ONLY) {
     // Index Value Retrieval Operation
     callbacks->OnSuccess(*primary_key);
     return;
   }
 
   // Index Referenced Value Retrieval Operation
-  std::string value;
+  IndexedDBValue value;
   ok = backing_store_->GetRecord(transaction->BackingStoreTransaction(),
                                  id(),
                                  object_store_id,
                                  *primary_key,
                                  &value);
   if (!ok) {
     callbacks->OnError(
         IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                "Internal error in GetRecord."));
     return;
@@ skipping 46 matching lines @@
       transaction->BackingStoreTransaction(),
       database_id,
       object_store_id,
       static_cast<int64>(floor(key.number())) + 1,
       check_current);
 }
 
 struct IndexedDBDatabase::PutOperationParams {
   PutOperationParams() {}
   int64 object_store_id;
-  std::string value;
+  IndexedDBValue value;
+  ScopedVector<webkit_blob::BlobDataHandle> handles;

[jsbell, 2013/12/18 23:04:40]

Would it make sense to add the vector to IndexedDBValue, to avoid passing things
in parallel?

[ericu, 2013/12/19 05:19:11]

It's not a clear win to me.  We'd use it here, but when doing gets we'd have an
IndexedDBValue coming back that had no BlobDataHandles, even if it had blob
info.  Would it complicate managing the lifetime of the BlobDataHandles?  I'm
not sure.  Is it worth it?  I suspect not.

   scoped_ptr<IndexedDBKey> key;
   IndexedDBDatabase::PutMode put_mode;
   scoped_refptr<IndexedDBCallbacks> callbacks;
   std::vector<int64> index_ids;
   std::vector<IndexKeys> index_keys;
 
   DISALLOW_COPY_AND_ASSIGN(PutOperationParams);
 };
 
 void IndexedDBDatabase::Put(int64 transaction_id,
                             int64 object_store_id,
-                            std::string* value,
+                            IndexedDBValue* value,
+                            ScopedVector<webkit_blob::BlobDataHandle>* handles,
                             scoped_ptr<IndexedDBKey> key,
                             PutMode put_mode,
                             scoped_refptr<IndexedDBCallbacks> callbacks,
                             const std::vector<int64>& index_ids,
                             const std::vector<IndexKeys>& index_keys) {
   IDB_TRACE("IndexedDBDatabase::Put");
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
   DCHECK_NE(transaction->mode(), indexed_db::TRANSACTION_READ_ONLY);
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   DCHECK(key);
+  DCHECK(value);
   scoped_ptr<PutOperationParams> params(new PutOperationParams());
   params->object_store_id = object_store_id;
   params->value.swap(*value);
+  params->handles.swap(*handles);
   params->key = key.Pass();
   params->put_mode = put_mode;
   params->callbacks = callbacks;
   params->index_ids = index_ids;
   params->index_keys = index_keys;
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::PutOperation, this, base::Passed(&params)));
 }
 
 void IndexedDBDatabase::PutOperation(scoped_ptr<PutOperationParams> params,
@@ skipping 79 matching lines @@
   }
 
   // Before this point, don't do any mutation. After this point, rollback the
   // transaction in case of error.
   backing_store_success =
       backing_store_->PutRecord(transaction->BackingStoreTransaction(),
                                 id(),
                                 params->object_store_id,
                                 *key,
                                 params->value,
+                                &params->handles,
                                 &record_identifier);
   if (!backing_store_success) {
     params->callbacks->OnError(IndexedDBDatabaseError(
         blink::WebIDBDatabaseExceptionUnknownError,
         "Internal error: backing store error performing put/add."));
     return;
   }
 
   for (size_t i = 0; i < index_writers.size(); ++i) {
     IndexWriter* index_writer = index_writers[i];
@@ skipping 211 matching lines @@
           transaction->BackingStoreTransaction(),
           id(),
           params->object_store_id,
           params->index_id,
           *params->key_range,
           params->direction);
     }
   }
 
   if (!backing_store_cursor) {
-    params->callbacks->OnSuccess(static_cast<std::string*>(NULL));
+    params->callbacks->OnSuccess(static_cast<IndexedDBValue*>(NULL));
     return;
   }
 
   scoped_refptr<IndexedDBCursor> cursor =
       new IndexedDBCursor(backing_store_cursor.Pass(),
                           params->cursor_type,
                           params->task_type,
                           transaction);
   params->callbacks->OnSuccess(
       cursor, cursor->key(), cursor->primary_key(), cursor->Value());
@@ skipping 78 matching lines @@
                                        base::Passed(&key_range),
                                        callbacks));
 }
 
 void IndexedDBDatabase::DeleteRangeOperation(
     int64 object_store_id,
     scoped_ptr<IndexedDBKeyRange> key_range,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* transaction) {
   IDB_TRACE("IndexedDBDatabase::DeleteRangeOperation");
-  scoped_ptr<IndexedDBBackingStore::Cursor> backing_store_cursor =
-      backing_store_->OpenObjectStoreCursor(
-          transaction->BackingStoreTransaction(),
-          id(),
-          object_store_id,
-          *key_range,
-          indexed_db::CURSOR_NEXT);
-  if (backing_store_cursor) {
-    do {
-      if (!backing_store_->DeleteRecord(
-              transaction->BackingStoreTransaction(),
-              id(),
-              object_store_id,
-              backing_store_cursor->record_identifier())) {
-        callbacks->OnError(
-            IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
-                                   "Internal error deleting data in range"));
-        return;
-      }
-    } while (backing_store_cursor->Continue());
+  if (!backing_store_->DeleteRange(transaction->BackingStoreTransaction(),

[jsbell, 2013/12/18 23:04:40]

This could be landed early, along with IndexedDBBackingStore::DeleteRange

[ericu, 2013/12/19 05:19:11]

...or just dropped for now, as it doesn't gain any efficiency yet.

+      id(), object_store_id, *key_range)) {
+    callbacks->OnError(
+        IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
+                               "Internal error deleting data in range"));
+    return;
   }
-
   callbacks->OnSuccess();
 }
 
 void IndexedDBDatabase::Clear(int64 transaction_id,
                               int64 object_store_id,
                               scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE("IndexedDBDatabase::Clear");
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
@@ skipping 182 matching lines @@
   }
 
   if (!IsOpenConnectionBlocked()) {
     PendingOpenCallList pending_open_calls;
     pending_open_calls_.swap(pending_open_calls);
     while (!pending_open_calls.empty()) {
       scoped_ptr<PendingOpenCall> pending_open_call(pending_open_calls.front());
       pending_open_calls.pop_front();
       OpenConnection(pending_open_call->Callbacks(),
                      pending_open_call->DatabaseCallbacks(),
+                     pending_open_call->ChildProcessId(),
                      pending_open_call->TransactionId(),
                      pending_open_call->Version());
     }
   }
 }
 
 void IndexedDBDatabase::CreateTransaction(
     int64 transaction_id,
     IndexedDBConnection* connection,
     const std::vector<int64>& object_store_ids,
@@ skipping 15 matching lines @@
 
 bool IndexedDBDatabase::IsOpenConnectionBlocked() const {
   return !pending_delete_calls_.empty() ||
          running_version_change_transaction_ ||
          pending_run_version_change_transaction_call_;
 }
 
 void IndexedDBDatabase::OpenConnection(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
+    int child_process_id,
     int64 transaction_id,
     int64 version) {
   const blink::WebIDBDataLoss kDataLoss =
       blink::WebIDBDataLossNone;
   OpenConnection(
-      callbacks, database_callbacks, transaction_id, version, kDataLoss, "");
+      callbacks, database_callbacks, child_process_id, transaction_id, version,
+      kDataLoss, "");
 }
 
 void IndexedDBDatabase::OpenConnection(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
+    int child_process_id,
     int64 transaction_id,
     int64 version,
     blink::WebIDBDataLoss data_loss,
     std::string data_loss_message) {
   DCHECK(backing_store_);
 
   // TODO(jsbell): Should have a priority queue so that higher version
   // requests are processed first. http://crbug.com/225850
   if (IsOpenConnectionBlocked()) {
     // The backing store only detects data loss when it is first opened. The
     // presence of existing connections means we didn't even check for data loss
     // so there'd better not be any.
     DCHECK_NE(blink::WebIDBDataLossTotal, data_loss);
     pending_open_calls_.push_back(new PendingOpenCall(
-        callbacks, database_callbacks, transaction_id, version));
+        callbacks, database_callbacks, child_process_id, transaction_id,
+        version));
     return;
   }
 
   if (metadata_.id == kInvalidId) {
     // The database was deleted then immediately re-opened; OpenInternal()
     // recreates it in the backing store.
     if (OpenInternal()) {
       DCHECK_EQ(IndexedDBDatabaseMetadata::NO_INT_VERSION,
                 metadata_.int_version);
     } else {
@@ skipping 19 matching lines @@
 
   scoped_ptr<IndexedDBConnection> connection(
       new IndexedDBConnection(this, database_callbacks));
 
   if (version == IndexedDBDatabaseMetadata::DEFAULT_INT_VERSION) {
     // For unit tests only - skip upgrade steps. Calling from script with
     // DEFAULT_INT_VERSION throws exception.
     // TODO(jsbell): DCHECK that not in unit tests.
     DCHECK(is_new_database);
     connections_.insert(connection.get());
+    backing_store_->GrantChildProcessPermissions(child_process_id);

[jsbell, 2013/12/18 23:04:40]

DRY; can we wrap the connection insertion and granting permissions (and even
connection object creation?) into a helper?

[ericu, 2013/12/19 05:19:11]

Done.

     callbacks->OnSuccess(connection.Pass(), this->metadata());
     return;
   }
 
   if (version == IndexedDBDatabaseMetadata::NO_INT_VERSION) {
     if (!is_new_database) {
       connections_.insert(connection.get());
+      backing_store_->GrantChildProcessPermissions(child_process_id);
       callbacks->OnSuccess(connection.Pass(), this->metadata());
       return;
     }
     // Spec says: If no version is specified and no database exists, set
     // database version to 1.
     version = 1;
   }
 
   if (version > metadata_.int_version) {
     connections_.insert(connection.get());
+    backing_store_->GrantChildProcessPermissions(child_process_id);
     RunVersionChangeTransaction(callbacks,
                                 connection.Pass(),
                                 transaction_id,
                                 version,
                                 data_loss,
                                 data_loss_message);
     return;
   }
   if (version < metadata_.int_version) {
     callbacks->OnError(IndexedDBDatabaseError(
         blink::WebIDBDatabaseExceptionVersionError,
         ASCIIToUTF16("The requested version (") + Int64ToString16(version) +
             ASCIIToUTF16(") is less than the existing version (") +
             Int64ToString16(metadata_.int_version) + ASCIIToUTF16(").")));
     return;
   }
   DCHECK_EQ(version, metadata_.int_version);
   connections_.insert(connection.get());
+  backing_store_->GrantChildProcessPermissions(child_process_id);
   callbacks->OnSuccess(connection.Pass(), this->metadata());
 }
 
 void IndexedDBDatabase::RunVersionChangeTransaction(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_ptr<IndexedDBConnection> connection,
     int64 transaction_id,
     int64 requested_version,
     blink::WebIDBDataLoss data_loss,
     std::string data_loss_message) {
@@ skipping 191 matching lines @@
     const string16& previous_version,
     int64 previous_int_version,
     IndexedDBTransaction* transaction) {
   IDB_TRACE("IndexedDBDatabase::VersionChangeAbortOperation");
   DCHECK(!transaction);
   metadata_.version = previous_version;
   metadata_.int_version = previous_int_version;
 }
 
 }  // namespace content