Port messages sent by WebIDBFactoryImpl to Mojo.

third_party/WebKit/Source/modules/indexeddb/IDBIndex.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 17 matching lines @@
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/modules/v8/ToV8ForModules.h"
 #include "bindings/modules/v8/V8BindingForModules.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "modules/indexeddb/IDBDatabase.h"
 #include "modules/indexeddb/IDBKey.h"
 #include "modules/indexeddb/IDBObjectStore.h"
 #include "modules/indexeddb/IDBTracing.h"
 #include "modules/indexeddb/IDBTransaction.h"
-#include "modules/indexeddb/WebIDBCallbacksImpl.h"
 #include "public/platform/modules/indexeddb/WebIDBKeyRange.h"
 #include <memory>
 
 using blink::WebIDBCallbacks;
 using blink::WebIDBCursor;
 using blink::WebIDBDatabase;
 
 namespace blink {
 
 IDBIndex::IDBIndex(const IDBIndexMetadata& metadata,
@@ skipping 102 matching lines @@
 }
 
 IDBRequest* IDBIndex::openCursor(ScriptState* scriptState,
                                  IDBKeyRange* keyRange,
                                  WebIDBCursorDirection direction) {
   IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this),
                                            m_transaction.get());
   request->setCursorDetails(IndexedDB::CursorKeyAndValue, direction);
   backendDB()->openCursor(m_transaction->id(), m_objectStore->id(), id(),
                           keyRange, direction, false, WebIDBTaskTypeNormal,
-                          WebIDBCallbacksImpl::create(request).release());
+                          request->createWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBIndex::count(ScriptState* scriptState,
                             const ScriptValue& range,
                             ExceptionState& exceptionState) {
   IDB_TRACE("IDBIndex::count");
   if (isDeleted()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      IDBDatabase::indexDeletedErrorMessage);
@@ 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(), m_objectStore->id(), id(), keyRange,
-                     WebIDBCallbacksImpl::create(request).release());
+                     request->createWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBIndex::openKeyCursor(ScriptState* scriptState,
                                     const ScriptValue& range,
                                     const String& directionString,
                                     ExceptionState& exceptionState) {
   IDB_TRACE("IDBIndex::openKeyCursor");
   if (isDeleted()) {
     exceptionState.throwDOMException(InvalidStateError,
@@ skipping 20 matching lines @@
     exceptionState.throwDOMException(InvalidStateError,
                                      IDBDatabase::databaseClosedErrorMessage);
     return nullptr;
   }
 
   IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this),
                                            m_transaction.get());
   request->setCursorDetails(IndexedDB::CursorKeyOnly, direction);
   backendDB()->openCursor(m_transaction->id(), m_objectStore->id(), id(),
                           keyRange, direction, true, WebIDBTaskTypeNormal,
-                          WebIDBCallbacksImpl::create(request).release());
+                          request->createWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBIndex::get(ScriptState* scriptState,
                           const ScriptValue& key,
                           ExceptionState& exceptionState) {
   IDB_TRACE("IDBIndex::get");
   return getInternal(scriptState, key, exceptionState, false);
 }
 
@@ skipping 66 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(), m_objectStore->id(), id(), keyRange,
-                   keyOnly, WebIDBCallbacksImpl::create(request).release());
+                   keyOnly, request->createWebCallbacks().release());
   return request;
 }
 
 IDBRequest* IDBIndex::getAllInternal(ScriptState* scriptState,
                                      const ScriptValue& range,
                                      unsigned long maxCount,
                                      ExceptionState& exceptionState,
                                      bool keyOnly) {
   if (!maxCount)
     maxCount = std::numeric_limits<uint32_t>::max();
@@ 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()->getAll(m_transaction->id(), m_objectStore->id(), id(), keyRange,
                       maxCount, keyOnly,
-                      WebIDBCallbacksImpl::create(request).release());
+                      request->createWebCallbacks().release());
   return request;
 }
 
 WebIDBDatabase* IDBIndex::backendDB() const {
   return m_transaction->backendDB();
 }
 
 bool IDBIndex::isDeleted() const {
   return m_deleted || m_objectStore->isDeleted();
 }
 
 }  // namespace blink