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/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"
 
 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),
         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_; }
   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 45 matching lines @@
   return backing_store->MaybeUpdateKeyGeneratorCurrentNumber(
       transaction->BackingStoreTransaction(),
       database_id,
       object_store_id,
       static_cast<int64>(floor(key.number())) + 1,
       check_current);
 }
 
 struct IndexedDBDatabase::PutOperationParams {
   PutOperationParams() {}
+  ~PutOperationParams() {
+    std::vector<webkit_blob::BlobDataHandle*>::iterator iter;
+    for (iter = handles.begin(); iter != handles.end(); ++iter)
+      delete *iter;
+    handles.clear();
+  }
   int64 object_store_id;
-  std::string value;
+  IndexedDBValue value;
+  std::vector<webkit_blob::BlobDataHandle*> handles;
   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,
+                            std::vector<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(),
+      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);
     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