Remove IDBNotFoundError ExceptionCode

Source/core/inspector/InspectorIndexedDBAgent.cpp

 /*
  * Copyright (C) 2012 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 #include "core/inspector/InspectorIndexedDBAgent.h"
 
+#include "bindings/v8/ExceptionState.h"
+#include "bindings/v8/ExceptionStatePlaceholder.h"
 #include "bindings/v8/ScriptController.h"
 #include "core/dom/DOMStringList.h"
 #include "core/dom/Document.h"
 #include "core/dom/Event.h"
 #include "core/dom/EventListener.h"
 #include "core/inspector/InjectedScript.h"
 #include "core/inspector/InspectorPageAgent.h"
 #include "core/inspector/InspectorState.h"
 #include "core/page/Frame.h"
 #include "core/platform/JSONValues.h"
@@ skipping 57 matching lines @@
     virtual void handleEvent(ScriptExecutionContext*, Event* event) OVERRIDE
     {
         if (!m_requestCallback->isActive())
             return;
         if (event->type() != eventNames().successEvent) {
             m_requestCallback->sendFailure("Unexpected event type.");
             return;
         }
 
         IDBRequest* idbRequest = static_cast<IDBRequest*>(event->target());
-        ExceptionCode ec = 0;
-        RefPtr<IDBAny> requestResult = idbRequest->result(ec);
-        if (ec) {
+        NonThrowExceptionState es;
+        RefPtr<IDBAny> requestResult = idbRequest->result(es);
+        if (es.hadException()) {
             m_requestCallback->sendFailure("Could not get result in callback.");
             return;
         }
         if (requestResult->type() != IDBAny::DOMStringListType) {
             m_requestCallback->sendFailure("Unexpected result type.");
             return;
         }
 
         RefPtr<DOMStringList> databaseNamesList = requestResult->domStringList();
         RefPtr<TypeBuilder::Array<String> > databaseNames = TypeBuilder::Array<String>::create();
@@ skipping 39 matching lines @@
     }
 
     virtual void handleEvent(ScriptExecutionContext*, Event* event) OVERRIDE
     {
         if (event->type() != eventNames().successEvent) {
             m_executableWithDatabase->requestCallback()->sendFailure("Unexpected event type.");
             return;
         }
 
         IDBOpenDBRequest* idbOpenDBRequest = static_cast<IDBOpenDBRequest*>(event->target());
-        ExceptionCode ec = 0;
-        RefPtr<IDBAny> requestResult = idbOpenDBRequest->result(ec);
-        if (ec) {
+        NonThrowExceptionState es;
+        RefPtr<IDBAny> requestResult = idbOpenDBRequest->result(es);
+        if (es.hadException()) {
             m_executableWithDatabase->requestCallback()->sendFailure("Could not get result in callback.");
             return;
         }
         if (requestResult->type() != IDBAny::IDBDatabaseType) {
             m_executableWithDatabase->requestCallback()->sendFailure("Unexpected result type.");
             return;
         }
 
         RefPtr<IDBDatabase> idbDatabase = requestResult->idbDatabase();
         m_executableWithDatabase->execute(idbDatabase);
         IDBPendingTransactionMonitor::deactivateNewTransactions();
         idbDatabase->close();
     }
 
 private:
     OpenDatabaseCallback(ExecutableWithDatabase* executableWithDatabase)
         : EventListener(EventListener::CPPEventListenerType)
         , m_executableWithDatabase(executableWithDatabase) { }
     RefPtr<ExecutableWithDatabase> m_executableWithDatabase;
 };
 
 void ExecutableWithDatabase::start(IDBFactory* idbFactory, SecurityOrigin*, const String& databaseName)
 {
     RefPtr<OpenDatabaseCallback> callback = OpenDatabaseCallback::create(this);
-    ExceptionCode ec = 0;
-    RefPtr<IDBOpenDBRequest> idbOpenDBRequest = idbFactory->open(context(), databaseName, ec);
-    if (ec) {
+    NonThrowExceptionState es;
+    RefPtr<IDBOpenDBRequest> idbOpenDBRequest = idbFactory->open(context(), databaseName, es);
+    if (es.hadException()) {
         requestCallback()->sendFailure("Could not open database.");
         return;
     }
     idbOpenDBRequest->addEventListener(eventNames().successEvent, callback, false);
 }
 
 static PassRefPtr<IDBTransaction> transactionForDatabase(ScriptExecutionContext* scriptExecutionContext, IDBDatabase* idbDatabase, const String& objectStoreName, const String& mode = IDBTransaction::modeReadOnly())
 {
-    ExceptionCode ec = 0;
-    RefPtr<IDBTransaction> idbTransaction = idbDatabase->transaction(scriptExecutionContext, objectStoreName, mode, ec);
-    if (ec)
+    NonThrowExceptionState es;
+    RefPtr<IDBTransaction> idbTransaction = idbDatabase->transaction(scriptExecutionContext, objectStoreName, mode, es);
+    if (es.hadException())
         return 0;
     return idbTransaction;
 }
 
 static PassRefPtr<IDBObjectStore> objectStoreForTransaction(IDBTransaction* idbTransaction, const String& objectStoreName)
 {
-    ExceptionCode ec = 0;
-    RefPtr<IDBObjectStore> idbObjectStore = idbTransaction->objectStore(objectStoreName, ec);
-    if (ec)
+    NonThrowExceptionState es;
+    RefPtr<IDBObjectStore> idbObjectStore = idbTransaction->objectStore(objectStoreName, es);
+    if (es.hadException())
         return 0;
     return idbObjectStore;
 }
 
 static PassRefPtr<IDBIndex> indexForObjectStore(IDBObjectStore* idbObjectStore, const String& indexName)
 {
-    ExceptionCode ec = 0;
-    RefPtr<IDBIndex> idbIndex = idbObjectStore->index(indexName, ec);
-    if (ec)
+    NonThrowExceptionState es;
+    RefPtr<IDBIndex> idbIndex = idbObjectStore->index(indexName, es);
+    if (es.hadException())
         return 0;
     return idbIndex;
 }
 
 static PassRefPtr<KeyPath> keyPathFromIDBKeyPath(const IDBKeyPath& idbKeyPath)
 {
     RefPtr<KeyPath> keyPath;
     switch (idbKeyPath.type()) {
     case IDBKeyPath::NullType:
         keyPath = KeyPath::create().setType(KeyPath::Type::Null);
@@ skipping 165 matching lines @@
     }
 
     virtual void handleEvent(ScriptExecutionContext*, Event* event) OVERRIDE
     {
         if (event->type() != eventNames().successEvent) {
             m_requestCallback->sendFailure("Unexpected event type.");
             return;
         }
 
         IDBRequest* idbRequest = static_cast<IDBRequest*>(event->target());
-        ExceptionCode ec = 0;
-        RefPtr<IDBAny> requestResult = idbRequest->result(ec);
-        if (ec) {
+        NonThrowExceptionState es;
+        RefPtr<IDBAny> requestResult = idbRequest->result(es);
+        if (es.hadException()) {
             m_requestCallback->sendFailure("Could not get result in callback.");
             return;
         }
         if (requestResult->type() == IDBAny::ScriptValueType) {
             end(false);
             return;
         }
         if (requestResult->type() != IDBAny::IDBCursorWithValueType) {
             m_requestCallback->sendFailure("Unexpected result type.");
             return;
         }
 
         RefPtr<IDBCursorWithValue> idbCursor = requestResult->idbCursorWithValue();
 
         if (m_skipCount) {
-            ExceptionCode ec = 0;
-            idbCursor->advance(m_skipCount, ec);
-            if (ec)
+            NonThrowExceptionState es;
+            idbCursor->advance(m_skipCount, es);
+            if (es.hadException())
                 m_requestCallback->sendFailure("Could not advance cursor.");
             m_skipCount = 0;
             return;
         }
 
         if (m_result->length() == m_pageSize) {
             end(true);
             return;
         }
 
         // Continue cursor before making injected script calls, otherwise transaction might be finished.
-        idbCursor->continueFunction(0, ec);
-        if (ec) {
+        idbCursor->continueFunction(0, es);
+        if (es.hadException()) {
             m_requestCallback->sendFailure("Could not continue cursor.");
             return;
         }
 
         RefPtr<DataEntry> dataEntry = DataEntry::create()
             .setKey(m_injectedScript.wrapObject(idbCursor->key(), String()))
             .setPrimaryKey(m_injectedScript.wrapObject(idbCursor->primaryKey(), String()))
             .setValue(m_injectedScript.wrapObject(idbCursor->value(), String()));
         m_result->addItem(dataEntry);
 
@@ skipping 43 matching lines @@
             return;
         }
         RefPtr<IDBObjectStore> idbObjectStore = objectStoreForTransaction(idbTransaction.get(), m_objectStoreName);
         if (!idbObjectStore) {
             m_requestCallback->sendFailure("Could not get object store");
             return;
         }
 
         RefPtr<OpenCursorCallback> openCursorCallback = OpenCursorCallback::create(m_injectedScript, m_requestCallback, m_skipCount, m_pageSize);
 
-        ExceptionCode ec = 0;
         RefPtr<IDBRequest> idbRequest;
         if (!m_indexName.isEmpty()) {
             RefPtr<IDBIndex> idbIndex = indexForObjectStore(idbObjectStore.get(), m_indexName);
             if (!idbIndex) {
                 m_requestCallback->sendFailure("Could not get index");
                 return;
             }
 
-            idbRequest = idbIndex->openCursor(context(), PassRefPtr<IDBKeyRange>(m_idbKeyRange), IDBCursor::directionNext(), ec);
-        } else
-            idbRequest = idbObjectStore->openCursor(context(), PassRefPtr<IDBKeyRange>(m_idbKeyRange), IDBCursor::directionNext(), ec);
+            idbRequest = idbIndex->openCursor(context(), PassRefPtr<IDBKeyRange>(m_idbKeyRange), IDBCursor::directionNext(), IGNORE_EXCEPTION_STATE);
+        } else {
+            idbRequest = idbObjectStore->openCursor(context(), PassRefPtr<IDBKeyRange>(m_idbKeyRange), IDBCursor::directionNext(), IGNORE_EXCEPTION_STATE);
+        }
         idbRequest->addEventListener(eventNames().successEvent, openCursorCallback, false);
     }
 
     virtual RequestCallback* requestCallback() { return m_requestCallback.get(); }
     DataLoader(ScriptExecutionContext* scriptExecutionContext, PassRefPtr<RequestDataCallback> requestCallback, const InjectedScript& injectedScript, const String& objectStoreName, const String& indexName, PassRefPtr<IDBKeyRange> idbKeyRange, int skipCount, unsigned pageSize)
         : ExecutableWithDatabase(scriptExecutionContext)
         , m_requestCallback(requestCallback)
         , m_injectedScript(injectedScript)
         , m_objectStoreName(objectStoreName)
         , m_indexName(indexName)
@@ skipping 79 matching lines @@
     IDBFactory* idbFactory = assertIDBFactory(errorString, document);
     if (!idbFactory)
         return;
 
     // FIXME: This should probably use ScriptState/ScriptScope instead of V8 API
     v8::HandleScope handleScope;
     v8::Handle<v8::Context> context = document->frame()->script()->mainWorldContext();
     ASSERT(!context.IsEmpty());
     v8::Context::Scope contextScope(context);
 
-    ExceptionCode ec = 0;
-    RefPtr<IDBRequest> idbRequest = idbFactory->getDatabaseNames(document, ec);
-    if (ec) {
+    NonThrowExceptionState es;
+    RefPtr<IDBRequest> idbRequest = idbFactory->getDatabaseNames(document, es);
+    if (es.hadException()) {
         requestCallback->sendFailure("Could not obtain database names.");
         return;
     }
     idbRequest->addEventListener(eventNames().successEvent, GetDatabaseNamesCallback::create(requestCallback, document->securityOrigin()->toRawString()), false);
 }
 
 void InspectorIndexedDBAgent::requestDatabase(ErrorString* errorString, const String& securityOrigin, const String& databaseName, PassRefPtr<RequestDatabaseCallback> requestCallback)
 {
     Frame* frame = m_pageAgent->findFrameWithSecurityOrigin(securityOrigin);
     Document* document = assertDocument(errorString, frame);
@@ skipping 101 matching lines @@
         if (!idbTransaction) {
             m_requestCallback->sendFailure("Could not get transaction");
             return;
         }
         RefPtr<IDBObjectStore> idbObjectStore = objectStoreForTransaction(idbTransaction.get(), m_objectStoreName);
         if (!idbObjectStore) {
             m_requestCallback->sendFailure("Could not get object store");
             return;
         }
 
-        ExceptionCode ec = 0;
-        RefPtr<IDBRequest> idbRequest = idbObjectStore->clear(context(), ec);
-        ASSERT(!ec);
-        if (ec) {
+        NonThrowExceptionState es;
+        RefPtr<IDBRequest> idbRequest = idbObjectStore->clear(context(), es);
+        ASSERT(!es.hadException());
+        if (es.hadException()) {
+            ExceptionCode ec = es;
             m_requestCallback->sendFailure(String::format("Could not clear object store '%s': %d", m_objectStoreName.utf8().data(), ec));
             return;
         }
         idbTransaction->addEventListener(eventNames().completeEvent, ClearObjectStoreListener::create(m_requestCallback), false);
     }
 
     virtual RequestCallback* requestCallback() { return m_requestCallback.get(); }
 private:
     const String m_objectStoreName;
     RefPtr<ClearObjectStoreCallback> m_requestCallback;
@@ skipping 13 matching lines @@
     v8::HandleScope handleScope;
     v8::Handle<v8::Context> context = document->frame()->script()->mainWorldContext();
     ASSERT(!context.IsEmpty());
     v8::Context::Scope contextScope(context);
 
     RefPtr<ClearObjectStore> clearObjectStore = ClearObjectStore::create(document, objectStoreName, requestCallback);
     clearObjectStore->start(idbFactory, document->securityOrigin(), databaseName);
 }
 
 } // namespace WebCore