Home | History | Annotate | Download | only in indexeddb 
      1 /*
      2  * Copyright (C) 2012 Google Inc. All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions are
      6  * met:
      7  *
      8  *     * Redistributions of source code must retain the above copyright
      9  * notice, this list of conditions and the following disclaimer.
     10  *     * Redistributions in binary form must reproduce the above
     11  * copyright notice, this list of conditions and the following disclaimer
     12  * in the documentation and/or other materials provided with the
     13  * distribution.
     14  *     * Neither the name of Google Inc. nor the names of its
     15  * contributors may be used to endorse or promote products derived from
     16  * this software without specific prior written permission.
     17  *
     18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     29  */
     30 
     31 #include "config.h"
     32 #include "modules/indexeddb/InspectorIndexedDBAgent.h"
     33 
     34 #include "bindings/core/v8/ExceptionState.h"
     35 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
     36 #include "bindings/core/v8/ScriptController.h"
     37 #include "bindings/core/v8/ScriptState.h"
     38 #include "bindings/core/v8/V8PerIsolateData.h"
     39 #include "core/dom/DOMStringList.h"
     40 #include "core/dom/Document.h"
     41 #include "core/events/EventListener.h"
     42 #include "core/frame/LocalFrame.h"
     43 #include "core/inspector/InspectorController.h"
     44 #include "core/inspector/InspectorState.h"
     45 #include "core/page/Page.h"
     46 #include "modules/IndexedDBNames.h"
     47 #include "modules/indexeddb/DOMWindowIndexedDatabase.h"
     48 #include "modules/indexeddb/IDBCursor.h"
     49 #include "modules/indexeddb/IDBCursorWithValue.h"
     50 #include "modules/indexeddb/IDBDatabase.h"
     51 #include "modules/indexeddb/IDBFactory.h"
     52 #include "modules/indexeddb/IDBIndex.h"
     53 #include "modules/indexeddb/IDBKey.h"
     54 #include "modules/indexeddb/IDBKeyPath.h"
     55 #include "modules/indexeddb/IDBKeyRange.h"
     56 #include "modules/indexeddb/IDBMetadata.h"
     57 #include "modules/indexeddb/IDBObjectStore.h"
     58 #include "modules/indexeddb/IDBOpenDBRequest.h"
     59 #include "modules/indexeddb/IDBRequest.h"
     60 #include "modules/indexeddb/IDBTransaction.h"
     61 #include "platform/JSONValues.h"
     62 #include "platform/weborigin/SecurityOrigin.h"
     63 #include "public/platform/WebIDBCursor.h"
     64 #include "public/platform/WebIDBTypes.h"
     65 #include "wtf/Vector.h"
     66 
     67 using blink::TypeBuilder::Array;
     68 using blink::TypeBuilder::IndexedDB::DatabaseWithObjectStores;
     69 using blink::TypeBuilder::IndexedDB::DataEntry;
     70 using blink::TypeBuilder::IndexedDB::Key;
     71 using blink::TypeBuilder::IndexedDB::KeyPath;
     72 using blink::TypeBuilder::IndexedDB::KeyRange;
     73 using blink::TypeBuilder::IndexedDB::ObjectStore;
     74 using blink::TypeBuilder::IndexedDB::ObjectStoreIndex;
     75 
     76 typedef blink::InspectorBackendDispatcher::IndexedDBCommandHandler::RequestDatabaseNamesCallback RequestDatabaseNamesCallback;
     77 typedef blink::InspectorBackendDispatcher::IndexedDBCommandHandler::RequestDatabaseCallback RequestDatabaseCallback;
     78 typedef blink::InspectorBackendDispatcher::IndexedDBCommandHandler::RequestDataCallback RequestDataCallback;
     79 typedef blink::InspectorBackendDispatcher::CallbackBase RequestCallback;
     80 typedef blink::InspectorBackendDispatcher::IndexedDBCommandHandler::ClearObjectStoreCallback ClearObjectStoreCallback;
     81 
     82 namespace blink {
     83 
     84 namespace IndexedDBAgentState {
     85 static const char indexedDBAgentEnabled[] = "indexedDBAgentEnabled";
     86 };
     87 
     88 namespace {
     89 
     90 class GetDatabaseNamesCallback FINAL : public EventListener {
     91     WTF_MAKE_NONCOPYABLE(GetDatabaseNamesCallback);
     92 public:
     93     static PassRefPtr<GetDatabaseNamesCallback> create(PassRefPtrWillBeRawPtr<RequestDatabaseNamesCallback> requestCallback, const String& securityOrigin)
     94     {
     95         return adoptRef(new GetDatabaseNamesCallback(requestCallback, securityOrigin));
     96     }
     97 
     98     virtual ~GetDatabaseNamesCallback() { }
     99 
    100     virtual bool operator==(const EventListener& other) OVERRIDE
    101     {
    102         return this == &other;
    103     }
    104 
    105     virtual void handleEvent(ExecutionContext*, Event* event) OVERRIDE
    106     {
    107         if (!m_requestCallback->isActive())
    108             return;
    109         if (event->type() != EventTypeNames::success) {
    110             m_requestCallback->sendFailure("Unexpected event type.");
    111             return;
    112         }
    113 
    114         IDBRequest* idbRequest = static_cast<IDBRequest*>(event->target());
    115         IDBAny* requestResult = idbRequest->resultAsAny();
    116         if (requestResult->type() != IDBAny::DOMStringListType) {
    117             m_requestCallback->sendFailure("Unexpected result type.");
    118             return;
    119         }
    120 
    121         RefPtrWillBeRawPtr<DOMStringList> databaseNamesList = requestResult->domStringList();
    122         RefPtr<TypeBuilder::Array<String> > databaseNames = TypeBuilder::Array<String>::create();
    123         for (size_t i = 0; i < databaseNamesList->length(); ++i)
    124             databaseNames->addItem(databaseNamesList->item(i));
    125         m_requestCallback->sendSuccess(databaseNames.release());
    126     }
    127 
    128 private:
    129     GetDatabaseNamesCallback(PassRefPtrWillBeRawPtr<RequestDatabaseNamesCallback> requestCallback, const String& securityOrigin)
    130         : EventListener(EventListener::CPPEventListenerType)
    131         , m_requestCallback(requestCallback)
    132         , m_securityOrigin(securityOrigin) { }
    133     RefPtrWillBePersistent<RequestDatabaseNamesCallback> m_requestCallback;
    134     String m_securityOrigin;
    135 };
    136 
    137 class ExecutableWithDatabase : public RefCounted<ExecutableWithDatabase> {
    138 public:
    139     ExecutableWithDatabase(ScriptState* scriptState)
    140         : m_scriptState(scriptState) { }
    141     virtual ~ExecutableWithDatabase() { };
    142     void start(IDBFactory*, SecurityOrigin*, const String& databaseName);
    143     virtual void execute(IDBDatabase*) = 0;
    144     virtual RequestCallback* requestCallback() = 0;
    145     ExecutionContext* context() const { return m_scriptState->executionContext(); }
    146     ScriptState* scriptState() const { return m_scriptState.get(); }
    147 private:
    148     RefPtr<ScriptState> m_scriptState;
    149 };
    150 
    151 class OpenDatabaseCallback FINAL : public EventListener {
    152 public:
    153     static PassRefPtr<OpenDatabaseCallback> create(ExecutableWithDatabase* executableWithDatabase)
    154     {
    155         return adoptRef(new OpenDatabaseCallback(executableWithDatabase));
    156     }
    157 
    158     virtual ~OpenDatabaseCallback() { }
    159 
    160     virtual bool operator==(const EventListener& other) OVERRIDE
    161     {
    162         return this == &other;
    163     }
    164 
    165     virtual void handleEvent(ExecutionContext* context, Event* event) OVERRIDE
    166     {
    167         if (event->type() != EventTypeNames::success) {
    168             m_executableWithDatabase->requestCallback()->sendFailure("Unexpected event type.");
    169             return;
    170         }
    171 
    172         IDBOpenDBRequest* idbOpenDBRequest = static_cast<IDBOpenDBRequest*>(event->target());
    173         IDBAny* requestResult = idbOpenDBRequest->resultAsAny();
    174         if (requestResult->type() != IDBAny::IDBDatabaseType) {
    175             m_executableWithDatabase->requestCallback()->sendFailure("Unexpected result type.");
    176             return;
    177         }
    178 
    179         IDBDatabase* idbDatabase = requestResult->idbDatabase();
    180         m_executableWithDatabase->execute(idbDatabase);
    181         V8PerIsolateData::from(m_executableWithDatabase->scriptState()->isolate())->ensureIDBPendingTransactionMonitor()->deactivateNewTransactions();
    182         idbDatabase->close();
    183     }
    184 
    185 private:
    186     OpenDatabaseCallback(ExecutableWithDatabase* executableWithDatabase)
    187         : EventListener(EventListener::CPPEventListenerType)
    188         , m_executableWithDatabase(executableWithDatabase) { }
    189     RefPtr<ExecutableWithDatabase> m_executableWithDatabase;
    190 };
    191 
    192 void ExecutableWithDatabase::start(IDBFactory* idbFactory, SecurityOrigin*, const String& databaseName)
    193 {
    194     RefPtr<OpenDatabaseCallback> callback = OpenDatabaseCallback::create(this);
    195     TrackExceptionState exceptionState;
    196     IDBOpenDBRequest* idbOpenDBRequest = idbFactory->open(scriptState(), databaseName, exceptionState);
    197     if (exceptionState.hadException()) {
    198         requestCallback()->sendFailure("Could not open database.");
    199         return;
    200     }
    201     idbOpenDBRequest->addEventListener(EventTypeNames::success, callback, false);
    202 }
    203 
    204 static IDBTransaction* transactionForDatabase(ScriptState* scriptState, IDBDatabase* idbDatabase, const String& objectStoreName, const String& mode = IndexedDBNames::readonly)
    205 {
    206     TrackExceptionState exceptionState;
    207     IDBTransaction* idbTransaction = idbDatabase->transaction(scriptState, objectStoreName, mode, exceptionState);
    208     if (exceptionState.hadException())
    209         return 0;
    210     return idbTransaction;
    211 }
    212 
    213 static IDBObjectStore* objectStoreForTransaction(IDBTransaction* idbTransaction, const String& objectStoreName)
    214 {
    215     TrackExceptionState exceptionState;
    216     IDBObjectStore* idbObjectStore = idbTransaction->objectStore(objectStoreName, exceptionState);
    217     if (exceptionState.hadException())
    218         return 0;
    219     return idbObjectStore;
    220 }
    221 
    222 static IDBIndex* indexForObjectStore(IDBObjectStore* idbObjectStore, const String& indexName)
    223 {
    224     TrackExceptionState exceptionState;
    225     IDBIndex* idbIndex = idbObjectStore->index(indexName, exceptionState);
    226     if (exceptionState.hadException())
    227         return 0;
    228     return idbIndex;
    229 }
    230 
    231 static PassRefPtr<KeyPath> keyPathFromIDBKeyPath(const IDBKeyPath& idbKeyPath)
    232 {
    233     RefPtr<KeyPath> keyPath;
    234     switch (idbKeyPath.type()) {
    235     case IDBKeyPath::NullType:
    236         keyPath = KeyPath::create().setType(KeyPath::Type::Null);
    237         break;
    238     case IDBKeyPath::StringType:
    239         keyPath = KeyPath::create().setType(KeyPath::Type::String);
    240         keyPath->setString(idbKeyPath.string());
    241         break;
    242     case IDBKeyPath::ArrayType: {
    243         keyPath = KeyPath::create().setType(KeyPath::Type::Array);
    244         RefPtr<TypeBuilder::Array<String> > array = TypeBuilder::Array<String>::create();
    245         const Vector<String>& stringArray = idbKeyPath.array();
    246         for (size_t i = 0; i < stringArray.size(); ++i)
    247             array->addItem(stringArray[i]);
    248         keyPath->setArray(array);
    249         break;
    250     }
    251     default:
    252         ASSERT_NOT_REACHED();
    253     }
    254 
    255     return keyPath.release();
    256 }
    257 
    258 class DatabaseLoader FINAL : public ExecutableWithDatabase {
    259 public:
    260     static PassRefPtr<DatabaseLoader> create(ScriptState* scriptState, PassRefPtrWillBeRawPtr<RequestDatabaseCallback> requestCallback)
    261     {
    262         return adoptRef(new DatabaseLoader(scriptState, requestCallback));
    263     }
    264 
    265     virtual ~DatabaseLoader() { }
    266 
    267     virtual void execute(IDBDatabase* idbDatabase) OVERRIDE
    268     {
    269         if (!requestCallback()->isActive())
    270             return;
    271 
    272         const IDBDatabaseMetadata databaseMetadata = idbDatabase->metadata();
    273 
    274         RefPtr<TypeBuilder::Array<TypeBuilder::IndexedDB::ObjectStore> > objectStores = TypeBuilder::Array<TypeBuilder::IndexedDB::ObjectStore>::create();
    275 
    276         for (IDBDatabaseMetadata::ObjectStoreMap::const_iterator it = databaseMetadata.objectStores.begin(); it != databaseMetadata.objectStores.end(); ++it) {
    277             const IDBObjectStoreMetadata& objectStoreMetadata = it->value;
    278 
    279             RefPtr<TypeBuilder::Array<TypeBuilder::IndexedDB::ObjectStoreIndex> > indexes = TypeBuilder::Array<TypeBuilder::IndexedDB::ObjectStoreIndex>::create();
    280 
    281             for (IDBObjectStoreMetadata::IndexMap::const_iterator it = objectStoreMetadata.indexes.begin(); it != objectStoreMetadata.indexes.end(); ++it) {
    282                 const IDBIndexMetadata& indexMetadata = it->value;
    283 
    284                 RefPtr<ObjectStoreIndex> objectStoreIndex = ObjectStoreIndex::create()
    285                     .setName(indexMetadata.name)
    286                     .setKeyPath(keyPathFromIDBKeyPath(indexMetadata.keyPath))
    287                     .setUnique(indexMetadata.unique)
    288                     .setMultiEntry(indexMetadata.multiEntry);
    289                 indexes->addItem(objectStoreIndex);
    290             }
    291 
    292             RefPtr<ObjectStore> objectStore = ObjectStore::create()
    293                 .setName(objectStoreMetadata.name)
    294                 .setKeyPath(keyPathFromIDBKeyPath(objectStoreMetadata.keyPath))
    295                 .setAutoIncrement(objectStoreMetadata.autoIncrement)
    296                 .setIndexes(indexes);
    297             objectStores->addItem(objectStore);
    298         }
    299         RefPtr<DatabaseWithObjectStores> result = DatabaseWithObjectStores::create()
    300             .setName(databaseMetadata.name)
    301             .setIntVersion(databaseMetadata.intVersion)
    302             .setVersion(databaseMetadata.version)
    303             .setObjectStores(objectStores);
    304 
    305         m_requestCallback->sendSuccess(result);
    306     }
    307 
    308     virtual RequestCallback* requestCallback() OVERRIDE { return m_requestCallback.get(); }
    309 private:
    310     DatabaseLoader(ScriptState* scriptState, PassRefPtrWillBeRawPtr<RequestDatabaseCallback> requestCallback)
    311         : ExecutableWithDatabase(scriptState)
    312         , m_requestCallback(requestCallback) { }
    313     RefPtrWillBePersistent<RequestDatabaseCallback> m_requestCallback;
    314 };
    315 
    316 static IDBKey* idbKeyFromInspectorObject(JSONObject* key)
    317 {
    318     IDBKey* idbKey;
    319 
    320     String type;
    321     if (!key->getString("type", &type))
    322         return 0;
    323 
    324     DEFINE_STATIC_LOCAL(String, number, ("number"));
    325     DEFINE_STATIC_LOCAL(String, string, ("string"));
    326     DEFINE_STATIC_LOCAL(String, date, ("date"));
    327     DEFINE_STATIC_LOCAL(String, array, ("array"));
    328 
    329     if (type == number) {
    330         double number;
    331         if (!key->getNumber("number", &number))
    332             return 0;
    333         idbKey = IDBKey::createNumber(number);
    334     } else if (type == string) {
    335         String string;
    336         if (!key->getString("string", &string))
    337             return 0;
    338         idbKey = IDBKey::createString(string);
    339     } else if (type == date) {
    340         double date;
    341         if (!key->getNumber("date", &date))
    342             return 0;
    343         idbKey = IDBKey::createDate(date);
    344     } else if (type == array) {
    345         IDBKey::KeyArray keyArray;
    346         RefPtr<JSONArray> array = key->getArray("array");
    347         for (size_t i = 0; i < array->length(); ++i) {
    348             RefPtr<JSONValue> value = array->get(i);
    349             RefPtr<JSONObject> object;
    350             if (!value->asObject(&object))
    351                 return 0;
    352             keyArray.append(idbKeyFromInspectorObject(object.get()));
    353         }
    354         idbKey = IDBKey::createArray(keyArray);
    355     } else {
    356         return 0;
    357     }
    358 
    359     return idbKey;
    360 }
    361 
    362 static IDBKeyRange* idbKeyRangeFromKeyRange(JSONObject* keyRange)
    363 {
    364     RefPtr<JSONObject> lower = keyRange->getObject("lower");
    365     IDBKey* idbLower = lower ? idbKeyFromInspectorObject(lower.get()) : 0;
    366     if (lower && !idbLower)
    367         return 0;
    368 
    369     RefPtr<JSONObject> upper = keyRange->getObject("upper");
    370     IDBKey* idbUpper = upper ? idbKeyFromInspectorObject(upper.get()) : 0;
    371     if (upper && !idbUpper)
    372         return 0;
    373 
    374     bool lowerOpen;
    375     if (!keyRange->getBoolean("lowerOpen", &lowerOpen))
    376         return 0;
    377     IDBKeyRange::LowerBoundType lowerBoundType = lowerOpen ? IDBKeyRange::LowerBoundOpen : IDBKeyRange::LowerBoundClosed;
    378 
    379     bool upperOpen;
    380     if (!keyRange->getBoolean("upperOpen", &upperOpen))
    381         return 0;
    382     IDBKeyRange::UpperBoundType upperBoundType = upperOpen ? IDBKeyRange::UpperBoundOpen : IDBKeyRange::UpperBoundClosed;
    383 
    384     return IDBKeyRange::create(idbLower, idbUpper, lowerBoundType, upperBoundType);
    385 }
    386 
    387 class DataLoader;
    388 
    389 class OpenCursorCallback FINAL : public EventListener {
    390 public:
    391     static PassRefPtr<OpenCursorCallback> create(ScriptState* scriptState, PassRefPtrWillBeRawPtr<RequestDataCallback> requestCallback, int skipCount, unsigned pageSize)
    392     {
    393         return adoptRef(new OpenCursorCallback(scriptState, requestCallback, skipCount, pageSize));
    394     }
    395 
    396     virtual ~OpenCursorCallback() { }
    397 
    398     virtual bool operator==(const EventListener& other) OVERRIDE
    399     {
    400         return this == &other;
    401     }
    402 
    403     virtual void handleEvent(ExecutionContext*, Event* event) OVERRIDE
    404     {
    405         if (event->type() != EventTypeNames::success) {
    406             m_requestCallback->sendFailure("Unexpected event type.");
    407             return;
    408         }
    409 
    410         IDBRequest* idbRequest = static_cast<IDBRequest*>(event->target());
    411         IDBAny* requestResult = idbRequest->resultAsAny();
    412         if (requestResult->type() == IDBAny::BufferType) {
    413             end(false);
    414             return;
    415         }
    416         if (requestResult->type() != IDBAny::IDBCursorWithValueType) {
    417             m_requestCallback->sendFailure("Unexpected result type.");
    418             return;
    419         }
    420 
    421         IDBCursorWithValue* idbCursor = requestResult->idbCursorWithValue();
    422 
    423         if (m_skipCount) {
    424             TrackExceptionState exceptionState;
    425             idbCursor->advance(m_skipCount, exceptionState);
    426             if (exceptionState.hadException())
    427                 m_requestCallback->sendFailure("Could not advance cursor.");
    428             m_skipCount = 0;
    429             return;
    430         }
    431 
    432         if (m_result->length() == m_pageSize) {
    433             end(true);
    434             return;
    435         }
    436 
    437         // Continue cursor before making injected script calls, otherwise transaction might be finished.
    438         TrackExceptionState exceptionState;
    439         idbCursor->continueFunction(0, 0, exceptionState);
    440         if (exceptionState.hadException()) {
    441             m_requestCallback->sendFailure("Could not continue cursor.");
    442             return;
    443         }
    444 
    445         Document* document = toDocument(m_scriptState->executionContext());
    446         if (!document)
    447             return;
    448         // FIXME: There are no tests for this error showing when a recursive
    449         // object is inspected.
    450         const String errorMessage("\"Inspection error. Maximum depth reached?\"");
    451         RefPtr<JSONValue> keyJsonValue = idbCursor->key(m_scriptState.get()).toJSONValue(m_scriptState.get());
    452         RefPtr<JSONValue> primaryKeyJsonValue = idbCursor->primaryKey(m_scriptState.get()).toJSONValue(m_scriptState.get());
    453         RefPtr<JSONValue> valueJsonValue = idbCursor->value(m_scriptState.get()).toJSONValue(m_scriptState.get());
    454         String key = keyJsonValue ? keyJsonValue->toJSONString() : errorMessage;
    455         String value = valueJsonValue ? valueJsonValue->toJSONString() : errorMessage;
    456         String primaryKey = primaryKeyJsonValue ? primaryKeyJsonValue->toJSONString() : errorMessage;
    457         RefPtr<DataEntry> dataEntry = DataEntry::create()
    458             .setKey(key)
    459             .setPrimaryKey(primaryKey)
    460             .setValue(value);
    461         m_result->addItem(dataEntry);
    462 
    463     }
    464 
    465     void end(bool hasMore)
    466     {
    467         if (!m_requestCallback->isActive())
    468             return;
    469         m_requestCallback->sendSuccess(m_result.release(), hasMore);
    470     }
    471 
    472 private:
    473     OpenCursorCallback(ScriptState* scriptState, PassRefPtrWillBeRawPtr<RequestDataCallback> requestCallback, int skipCount, unsigned pageSize)
    474         : EventListener(EventListener::CPPEventListenerType)
    475         , m_scriptState(scriptState)
    476         , m_requestCallback(requestCallback)
    477         , m_skipCount(skipCount)
    478         , m_pageSize(pageSize)
    479     {
    480         m_result = Array<DataEntry>::create();
    481     }
    482 
    483     RefPtr<ScriptState> m_scriptState;
    484     RefPtrWillBePersistent<RequestDataCallback> m_requestCallback;
    485     int m_skipCount;
    486     unsigned m_pageSize;
    487     RefPtr<Array<DataEntry> > m_result;
    488 };
    489 
    490 class DataLoader FINAL : public ExecutableWithDatabase {
    491 public:
    492     static PassRefPtr<DataLoader> create(ScriptState* scriptState, PassRefPtrWillBeRawPtr<RequestDataCallback> requestCallback, const String& objectStoreName, const String& indexName, IDBKeyRange* idbKeyRange, int skipCount, unsigned pageSize)
    493     {
    494         return adoptRef(new DataLoader(scriptState, requestCallback, objectStoreName, indexName, idbKeyRange, skipCount, pageSize));
    495     }
    496 
    497     virtual ~DataLoader() { }
    498 
    499     virtual void execute(IDBDatabase* idbDatabase) OVERRIDE
    500     {
    501         if (!requestCallback()->isActive())
    502             return;
    503         IDBTransaction* idbTransaction = transactionForDatabase(scriptState(), idbDatabase, m_objectStoreName);
    504         if (!idbTransaction) {
    505             m_requestCallback->sendFailure("Could not get transaction");
    506             return;
    507         }
    508         IDBObjectStore* idbObjectStore = objectStoreForTransaction(idbTransaction, m_objectStoreName);
    509         if (!idbObjectStore) {
    510             m_requestCallback->sendFailure("Could not get object store");
    511             return;
    512         }
    513 
    514         RefPtr<OpenCursorCallback> openCursorCallback = OpenCursorCallback::create(scriptState(), m_requestCallback, m_skipCount, m_pageSize);
    515 
    516         IDBRequest* idbRequest;
    517         if (!m_indexName.isEmpty()) {
    518             IDBIndex* idbIndex = indexForObjectStore(idbObjectStore, m_indexName);
    519             if (!idbIndex) {
    520                 m_requestCallback->sendFailure("Could not get index");
    521                 return;
    522             }
    523 
    524             idbRequest = idbIndex->openCursor(scriptState(), m_idbKeyRange.get(), WebIDBCursorDirectionNext);
    525         } else {
    526             idbRequest = idbObjectStore->openCursor(scriptState(), m_idbKeyRange.get(), WebIDBCursorDirectionNext);
    527         }
    528         idbRequest->addEventListener(EventTypeNames::success, openCursorCallback, false);
    529     }
    530 
    531     virtual RequestCallback* requestCallback() OVERRIDE { return m_requestCallback.get(); }
    532     DataLoader(ScriptState* scriptState, PassRefPtrWillBeRawPtr<RequestDataCallback> requestCallback, const String& objectStoreName, const String& indexName, IDBKeyRange* idbKeyRange, int skipCount, unsigned pageSize)
    533         : ExecutableWithDatabase(scriptState)
    534         , m_requestCallback(requestCallback)
    535         , m_objectStoreName(objectStoreName)
    536         , m_indexName(indexName)
    537         , m_idbKeyRange(idbKeyRange)
    538         , m_skipCount(skipCount)
    539         , m_pageSize(pageSize)
    540     {
    541     }
    542 
    543     RefPtrWillBePersistent<RequestDataCallback> m_requestCallback;
    544     String m_objectStoreName;
    545     String m_indexName;
    546     Persistent<IDBKeyRange> m_idbKeyRange;
    547     int m_skipCount;
    548     unsigned m_pageSize;
    549 };
    550 
    551 LocalFrame* findFrameWithSecurityOrigin(Page* page, const String& securityOrigin)
    552 {
    553     for (Frame* frame = page->mainFrame(); frame; frame = frame->tree().traverseNext()) {
    554         if (!frame->isLocalFrame())
    555             continue;
    556         RefPtr<SecurityOrigin> documentOrigin = toLocalFrame(frame)->document()->securityOrigin();
    557         if (documentOrigin->toRawString() == securityOrigin)
    558             return toLocalFrame(frame);
    559     }
    560     return 0;
    561 }
    562 
    563 } // namespace
    564 
    565 void InspectorIndexedDBAgent::provideTo(Page* page)
    566 {
    567     OwnPtrWillBeRawPtr<InspectorIndexedDBAgent> agent(adoptPtrWillBeNoop(new InspectorIndexedDBAgent(page)));
    568     page->inspectorController().registerModuleAgent(agent.release());
    569 }
    570 
    571 InspectorIndexedDBAgent::InspectorIndexedDBAgent(Page* page)
    572     : InspectorBaseAgent<InspectorIndexedDBAgent>("IndexedDB")
    573     , m_page(page)
    574 {
    575 }
    576 
    577 InspectorIndexedDBAgent::~InspectorIndexedDBAgent()
    578 {
    579 }
    580 
    581 void InspectorIndexedDBAgent::clearFrontend()
    582 {
    583     disable(0);
    584 }
    585 
    586 void InspectorIndexedDBAgent::restore()
    587 {
    588     if (m_state->getBoolean(IndexedDBAgentState::indexedDBAgentEnabled)) {
    589         ErrorString error;
    590         enable(&error);
    591     }
    592 }
    593 
    594 void InspectorIndexedDBAgent::enable(ErrorString*)
    595 {
    596     m_state->setBoolean(IndexedDBAgentState::indexedDBAgentEnabled, true);
    597 }
    598 
    599 void InspectorIndexedDBAgent::disable(ErrorString*)
    600 {
    601     m_state->setBoolean(IndexedDBAgentState::indexedDBAgentEnabled, false);
    602 }
    603 
    604 static Document* assertDocument(ErrorString* errorString, LocalFrame* frame)
    605 {
    606     Document* document = frame ? frame->document() : 0;
    607 
    608     if (!document)
    609         *errorString = "No document for given frame found";
    610 
    611     return document;
    612 }
    613 
    614 static IDBFactory* assertIDBFactory(ErrorString* errorString, Document* document)
    615 {
    616     LocalDOMWindow* domWindow = document->domWindow();
    617     if (!domWindow) {
    618         *errorString = "No IndexedDB factory for given frame found";
    619         return 0;
    620     }
    621     IDBFactory* idbFactory = DOMWindowIndexedDatabase::indexedDB(*domWindow);
    622 
    623     if (!idbFactory)
    624         *errorString = "No IndexedDB factory for given frame found";
    625 
    626     return idbFactory;
    627 }
    628 
    629 void InspectorIndexedDBAgent::requestDatabaseNames(ErrorString* errorString, const String& securityOrigin, PassRefPtrWillBeRawPtr<RequestDatabaseNamesCallback> requestCallback)
    630 {
    631     LocalFrame* frame = findFrameWithSecurityOrigin(m_page, securityOrigin);
    632     Document* document = assertDocument(errorString, frame);
    633     if (!document)
    634         return;
    635     IDBFactory* idbFactory = assertIDBFactory(errorString, document);
    636     if (!idbFactory)
    637         return;
    638 
    639     ScriptState* scriptState = ScriptState::forMainWorld(frame);
    640     ScriptState::Scope scope(scriptState);
    641     TrackExceptionState exceptionState;
    642     IDBRequest* idbRequest = idbFactory->getDatabaseNames(scriptState, exceptionState);
    643     if (exceptionState.hadException()) {
    644         requestCallback->sendFailure("Could not obtain database names.");
    645         return;
    646     }
    647     idbRequest->addEventListener(EventTypeNames::success, GetDatabaseNamesCallback::create(requestCallback, document->securityOrigin()->toRawString()), false);
    648 }
    649 
    650 void InspectorIndexedDBAgent::requestDatabase(ErrorString* errorString, const String& securityOrigin, const String& databaseName, PassRefPtrWillBeRawPtr<RequestDatabaseCallback> requestCallback)
    651 {
    652     LocalFrame* frame = findFrameWithSecurityOrigin(m_page, securityOrigin);
    653     Document* document = assertDocument(errorString, frame);
    654     if (!document)
    655         return;
    656     IDBFactory* idbFactory = assertIDBFactory(errorString, document);
    657     if (!idbFactory)
    658         return;
    659 
    660     ScriptState* scriptState = ScriptState::forMainWorld(frame);
    661     ScriptState::Scope scope(scriptState);
    662     RefPtr<DatabaseLoader> databaseLoader = DatabaseLoader::create(scriptState, requestCallback);
    663     databaseLoader->start(idbFactory, document->securityOrigin(), databaseName);
    664 }
    665 
    666 void InspectorIndexedDBAgent::requestData(ErrorString* errorString, const String& securityOrigin, const String& databaseName, const String& objectStoreName, const String& indexName, int skipCount, int pageSize, const RefPtr<JSONObject>* keyRange, const PassRefPtrWillBeRawPtr<RequestDataCallback> requestCallback)
    667 {
    668     LocalFrame* frame = findFrameWithSecurityOrigin(m_page, securityOrigin);
    669     Document* document = assertDocument(errorString, frame);
    670     if (!document)
    671         return;
    672     IDBFactory* idbFactory = assertIDBFactory(errorString, document);
    673     if (!idbFactory)
    674         return;
    675 
    676     IDBKeyRange* idbKeyRange = keyRange ? idbKeyRangeFromKeyRange(keyRange->get()) : 0;
    677     if (keyRange && !idbKeyRange) {
    678         *errorString = "Can not parse key range.";
    679         return;
    680     }
    681 
    682     ScriptState* scriptState = ScriptState::forMainWorld(frame);
    683     ScriptState::Scope scope(scriptState);
    684     RefPtr<DataLoader> dataLoader = DataLoader::create(scriptState, requestCallback, objectStoreName, indexName, idbKeyRange, skipCount, pageSize);
    685     dataLoader->start(idbFactory, document->securityOrigin(), databaseName);
    686 }
    687 
    688 class ClearObjectStoreListener FINAL : public EventListener {
    689     WTF_MAKE_NONCOPYABLE(ClearObjectStoreListener);
    690 public:
    691     static PassRefPtr<ClearObjectStoreListener> create(PassRefPtrWillBeRawPtr<ClearObjectStoreCallback> requestCallback)
    692     {
    693         return adoptRef(new ClearObjectStoreListener(requestCallback));
    694     }
    695 
    696     virtual ~ClearObjectStoreListener() { }
    697 
    698     virtual bool operator==(const EventListener& other) OVERRIDE
    699     {
    700         return this == &other;
    701     }
    702 
    703     virtual void handleEvent(ExecutionContext*, Event* event) OVERRIDE
    704     {
    705         if (!m_requestCallback->isActive())
    706             return;
    707         if (event->type() != EventTypeNames::complete) {
    708             m_requestCallback->sendFailure("Unexpected event type.");
    709             return;
    710         }
    711 
    712         m_requestCallback->sendSuccess();
    713     }
    714 private:
    715     ClearObjectStoreListener(PassRefPtrWillBeRawPtr<ClearObjectStoreCallback> requestCallback)
    716         : EventListener(EventListener::CPPEventListenerType)
    717         , m_requestCallback(requestCallback)
    718     {
    719     }
    720 
    721     RefPtrWillBePersistent<ClearObjectStoreCallback> m_requestCallback;
    722 };
    723 
    724 
    725 class ClearObjectStore FINAL : public ExecutableWithDatabase {
    726 public:
    727     static PassRefPtr<ClearObjectStore> create(ScriptState* scriptState, const String& objectStoreName, PassRefPtrWillBeRawPtr<ClearObjectStoreCallback> requestCallback)
    728     {
    729         return adoptRef(new ClearObjectStore(scriptState, objectStoreName, requestCallback));
    730     }
    731 
    732     ClearObjectStore(ScriptState* scriptState, const String& objectStoreName, PassRefPtrWillBeRawPtr<ClearObjectStoreCallback> requestCallback)
    733         : ExecutableWithDatabase(scriptState)
    734         , m_objectStoreName(objectStoreName)
    735         , m_requestCallback(requestCallback)
    736     {
    737     }
    738 
    739     virtual void execute(IDBDatabase* idbDatabase) OVERRIDE
    740     {
    741         if (!requestCallback()->isActive())
    742             return;
    743         IDBTransaction* idbTransaction = transactionForDatabase(scriptState(), idbDatabase, m_objectStoreName, IndexedDBNames::readwrite);
    744         if (!idbTransaction) {
    745             m_requestCallback->sendFailure("Could not get transaction");
    746             return;
    747         }
    748         IDBObjectStore* idbObjectStore = objectStoreForTransaction(idbTransaction, m_objectStoreName);
    749         if (!idbObjectStore) {
    750             m_requestCallback->sendFailure("Could not get object store");
    751             return;
    752         }
    753 
    754         TrackExceptionState exceptionState;
    755         idbObjectStore->clear(scriptState(), exceptionState);
    756         ASSERT(!exceptionState.hadException());
    757         if (exceptionState.hadException()) {
    758             ExceptionCode ec = exceptionState.code();
    759             m_requestCallback->sendFailure(String::format("Could not clear object store '%s': %d", m_objectStoreName.utf8().data(), ec));
    760             return;
    761         }
    762         idbTransaction->addEventListener(EventTypeNames::complete, ClearObjectStoreListener::create(m_requestCallback), false);
    763     }
    764 
    765     virtual RequestCallback* requestCallback() OVERRIDE { return m_requestCallback.get(); }
    766 private:
    767     const String m_objectStoreName;
    768     RefPtrWillBePersistent<ClearObjectStoreCallback> m_requestCallback;
    769 };
    770 
    771 void InspectorIndexedDBAgent::clearObjectStore(ErrorString* errorString, const String& securityOrigin, const String& databaseName, const String& objectStoreName, PassRefPtrWillBeRawPtr<ClearObjectStoreCallback> requestCallback)
    772 {
    773     LocalFrame* frame = findFrameWithSecurityOrigin(m_page, securityOrigin);
    774     Document* document = assertDocument(errorString, frame);
    775     if (!document)
    776         return;
    777     IDBFactory* idbFactory = assertIDBFactory(errorString, document);
    778     if (!idbFactory)
    779         return;
    780 
    781     ScriptState* scriptState = ScriptState::forMainWorld(frame);
    782     ScriptState::Scope scope(scriptState);
    783     RefPtr<ClearObjectStore> clearObjectStore = ClearObjectStore::create(scriptState, objectStoreName, requestCallback);
    784     clearObjectStore->start(idbFactory, document->securityOrigin(), databaseName);
    785 }
    786 
    787 void InspectorIndexedDBAgent::trace(Visitor* visitor)
    788 {
    789     visitor->trace(m_page);
    790     InspectorBaseAgent::trace(visitor);
    791 }
    792 
    793 } // namespace blink
    794