Port messages sent by WebIDBFactoryImpl to Mojo.

third_party/WebKit/Source/modules/indexeddb/IDBObjectStore.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 21 matching lines @@
 #include "bindings/modules/v8/ToV8ForModules.h"
 #include "bindings/modules/v8/V8BindingForModules.h"
 #include "core/dom/DOMStringList.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "modules/indexeddb/IDBAny.h"
 #include "modules/indexeddb/IDBCursorWithValue.h"
 #include "modules/indexeddb/IDBDatabase.h"
 #include "modules/indexeddb/IDBKeyPath.h"
 #include "modules/indexeddb/IDBTracing.h"
-#include "modules/indexeddb/WebIDBCallbacksImpl.h"
 #include "platform/SharedBuffer.h"
 #include "public/platform/WebBlobInfo.h"
 #include "public/platform/WebData.h"
 #include "public/platform/WebVector.h"
 #include "public/platform/modules/indexeddb/WebIDBKey.h"
 #include "public/platform/modules/indexeddb/WebIDBKeyRange.h"
 #include <memory>
 #include <v8.h>
 
 using blink::WebBlobInfo;
@@ skipping 109 matching lines @@
   if (!backendDB()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      IDBDatabase::databaseClosedErrorMessage);
     return nullptr;
   }
 
   IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this),
                                            m_transaction.get());
   backendDB()->get(m_transaction->id(), id(), IDBIndexMetadata::InvalidId,
                    keyRange, false /* keyOnly */,
-                   WebIDBCallbacksImpl::create(request).release());
+                   request->createWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBObjectStore::getKey(ScriptState* scriptState,
                                    const ScriptValue& key,
                                    ExceptionState& exceptionState) {
   IDB_TRACE("IDBObjectStore::getKey");
   if (isDeleted()) {
     exceptionState.throwDOMException(
         InvalidStateError, IDBDatabase::objectStoreDeletedErrorMessage);
@@ skipping 21 matching lines @@
   if (!backendDB()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      IDBDatabase::databaseClosedErrorMessage);
     return nullptr;
   }
 
   IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this),
                                            m_transaction.get());
   backendDB()->get(m_transaction->id(), id(), IDBIndexMetadata::InvalidId,
                    keyRange, true /* keyOnly */,
-                   WebIDBCallbacksImpl::create(request).release());
+                   request->createWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBObjectStore::getAll(ScriptState* scriptState,
                                    const ScriptValue& keyRange,
                                    ExceptionState& exceptionState) {
   return getAll(scriptState, keyRange, std::numeric_limits<uint32_t>::max(),
                 exceptionState);
 }
 
@@ skipping 27 matching lines @@
   if (!backendDB()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      IDBDatabase::databaseClosedErrorMessage);
     return nullptr;
   }
 
   IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this),
                                            m_transaction.get());
   backendDB()->getAll(m_transaction->id(), id(), IDBIndexMetadata::InvalidId,
                       range, maxCount, false,
-                      WebIDBCallbacksImpl::create(request).release());
+                      request->createWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBObjectStore::getAllKeys(ScriptState* scriptState,
                                        const ScriptValue& keyRange,
                                        ExceptionState& exceptionState) {
   return getAllKeys(scriptState, keyRange, std::numeric_limits<uint32_t>::max(),
                     exceptionState);
 }
 
@@ skipping 27 matching lines @@
   if (!backendDB()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      IDBDatabase::databaseClosedErrorMessage);
     return nullptr;
   }
 
   IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this),
                                            m_transaction.get());
   backendDB()->getAll(m_transaction->id(), id(), IDBIndexMetadata::InvalidId,
                       range, maxCount, true,
-                      WebIDBCallbacksImpl::create(request).release());
+                      request->createWebCallbacks().release());
   return request;
 }
 
 static void generateIndexKeysForValue(v8::Isolate* isolate,
                                       const IDBIndexMetadata& indexMetadata,
                                       const ScriptValue& objectValue,
                                       IndexKeys* indexKeys) {
   DCHECK(indexKeys);
   NonThrowableExceptionState exceptionState;
   IDBKey* indexKey = ScriptValue::to<IDBKey*>(
@@ skipping 187 matching lines @@
   }
 
   IDBRequest* request =
       IDBRequest::create(scriptState, source, m_transaction.get());
   Vector<char> wireBytes;
   serializedValue->toWireBytes(wireBytes);
   RefPtr<SharedBuffer> valueBuffer = SharedBuffer::adoptVector(wireBytes);
 
   backendDB()->put(m_transaction->id(), id(), WebData(valueBuffer), blobInfo,
                    key, static_cast<WebIDBPutMode>(putMode),
-                   WebIDBCallbacksImpl::create(request).release(), indexIds,
+                   request->createWebCallbacks().release(), indexIds,
                    indexKeys);
   return request;
 }
 
 IDBRequest* IDBObjectStore::deleteFunction(ScriptState* scriptState,
                                            const ScriptValue& key,
                                            ExceptionState& exceptionState) {
   IDB_TRACE("IDBObjectStore::delete");
   if (isDeleted()) {
     exceptionState.throwDOMException(
@@ skipping 27 matching lines @@
   }
   if (!backendDB()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      IDBDatabase::databaseClosedErrorMessage);
     return nullptr;
   }
 
   IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this),
                                            m_transaction.get());
   backendDB()->deleteRange(m_transaction->id(), id(), keyRange,
-                           WebIDBCallbacksImpl::create(request).release());
+                           request->createWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBObjectStore::clear(ScriptState* scriptState,
                                   ExceptionState& exceptionState) {
   IDB_TRACE("IDBObjectStore::clear");
   if (isDeleted()) {
     exceptionState.throwDOMException(
         InvalidStateError, IDBDatabase::objectStoreDeletedErrorMessage);
     return nullptr;
@@ skipping 15 matching lines @@
   }
   if (!backendDB()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      IDBDatabase::databaseClosedErrorMessage);
     return nullptr;
   }
 
   IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this),
                                            m_transaction.get());
   backendDB()->clear(m_transaction->id(), id(),
-                     WebIDBCallbacksImpl::create(request).release());
+                     request->createWebCallbacks().release());
   return request;
 }
 
 namespace {
 // This class creates the index keys for a given index by extracting
 // them from the SerializedScriptValue, for all the existing values in
 // the objectStore. It only needs to be kept alive by virtue of being
 // a listener on an IDBRequest object, in the same way that JavaScript
 // cursor success handlers are kept alive.
 class IndexPopulator final : public EventListener {
@@ skipping 280 matching lines @@
 }
 
 IDBRequest* IDBObjectStore::openCursor(ScriptState* scriptState,
                                        IDBKeyRange* range,
                                        WebIDBCursorDirection direction,
                                        WebIDBTaskType taskType) {
   IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this),
                                            m_transaction.get());
   request->setCursorDetails(IndexedDB::CursorKeyAndValue, direction);
 
-  backendDB()->openCursor(
-      m_transaction->id(), id(), IDBIndexMetadata::InvalidId, range, direction,
-      false, taskType, WebIDBCallbacksImpl::create(request).release());
+  backendDB()->openCursor(m_transaction->id(), id(),
+                          IDBIndexMetadata::InvalidId, range, direction, false,
+                          taskType, request->createWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBObjectStore::openKeyCursor(ScriptState* scriptState,
                                           const ScriptValue& range,
                                           const String& directionString,
                                           ExceptionState& exceptionState) {
   IDB_TRACE("IDBObjectStore::openKeyCursor");
   if (isDeleted()) {
     exceptionState.throwDOMException(
@@ skipping 24 matching lines @@
     return nullptr;
   }
 
   IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this),
                                            m_transaction.get());
   request->setCursorDetails(IndexedDB::CursorKeyOnly, direction);
 
   backendDB()->openCursor(m_transaction->id(), id(),
                           IDBIndexMetadata::InvalidId, keyRange, direction,
                           true, WebIDBTaskTypeNormal,
-                          WebIDBCallbacksImpl::create(request).release());
+                          request->createWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBObjectStore::count(ScriptState* scriptState,
                                   const ScriptValue& range,
                                   ExceptionState& exceptionState) {
   IDB_TRACE("IDBObjectStore::count");
   if (isDeleted()) {
     exceptionState.throwDOMException(
         InvalidStateError, IDBDatabase::objectStoreDeletedErrorMessage);
@@ skipping 17 matching lines @@
 
   if (!backendDB()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      IDBDatabase::databaseClosedErrorMessage);
     return nullptr;
   }
 
   IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this),
                                            m_transaction.get());
   backendDB()->count(m_transaction->id(), id(), IDBIndexMetadata::InvalidId,
-                     keyRange, WebIDBCallbacksImpl::create(request).release());
+                     keyRange, request->createWebCallbacks().release());
   return request;
 }
 
 void IDBObjectStore::markDeleted() {
   DCHECK(m_transaction->isVersionChange())
       << "An object store got deleted outside a versionchange transaction.";
 
   m_deleted = true;
   m_metadata->indexes.clear();
 
@@ skipping 89 matching lines @@
     }
   }
   return IDBIndexMetadata::InvalidId;
 }
 
 WebIDBDatabase* IDBObjectStore::backendDB() const {
   return m_transaction->backendDB();
 }
 
 }  // namespace blink