[DevTools] Dont pass errorString to async protocol methods

third_party/WebKit/Source/modules/indexeddb/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 612 matching lines @@
         return nullptr;
     }
     IDBFactory* idbFactory = GlobalIndexedDB::indexedDB(*domWindow);
 
     if (!idbFactory)
         *errorString = "No IndexedDB factory for given frame found";
 
     return idbFactory;
 }
 
-void InspectorIndexedDBAgent::requestDatabaseNames(ErrorString* errorString, const String& securityOrigin, std::unique_ptr<RequestDatabaseNamesCallback> requestCallback)
+void InspectorIndexedDBAgent::requestDatabaseNames(const String& securityOrigin, std::unique_ptr<RequestDatabaseNamesCallback> requestCallback)
 {
     LocalFrame* frame = m_inspectedFrames->frameWithSecurityOrigin(securityOrigin);
-    Document* document = assertDocument(errorString, frame);
-    if (!document)
+    ErrorString errorString;
+    Document* document = assertDocument(&errorString, frame);
+    if (!document) {
+        requestCallback->sendFailure(errorString);
         return;
-    IDBFactory* idbFactory = assertIDBFactory(errorString, document);
-    if (!idbFactory)
+    }
+    IDBFactory* idbFactory = assertIDBFactory(&errorString, document);
+    if (!idbFactory) {
+        requestCallback->sendFailure(errorString);
         return;
+    }
 
     ScriptState* scriptState = ScriptState::forMainWorld(frame);
     if (!scriptState)
         return;
     ScriptState::Scope scope(scriptState);
     TrackExceptionState exceptionState;
     IDBRequest* idbRequest = idbFactory->getDatabaseNames(scriptState, exceptionState);
     if (exceptionState.hadException()) {
         requestCallback->sendFailure("Could not obtain database names.");
         return;
     }
     idbRequest->addEventListener(EventTypeNames::success, GetDatabaseNamesCallback::create(std::move(requestCallback), document->getSecurityOrigin()->toRawString()), false);
 }
 
-void InspectorIndexedDBAgent::requestDatabase(ErrorString* errorString, const String& securityOrigin, const String& databaseName, std::unique_ptr<RequestDatabaseCallback> requestCallback)
+void InspectorIndexedDBAgent::requestDatabase(const String& securityOrigin, const String& databaseName, std::unique_ptr<RequestDatabaseCallback> requestCallback)
 {
     LocalFrame* frame = m_inspectedFrames->frameWithSecurityOrigin(securityOrigin);
-    Document* document = assertDocument(errorString, frame);
-    if (!document)
+    ErrorString errorString;
+    Document* document = assertDocument(&errorString, frame);
+    if (!document) {
+        requestCallback->sendFailure(errorString);
         return;
-    IDBFactory* idbFactory = assertIDBFactory(errorString, document);
-    if (!idbFactory)
+    }
+    IDBFactory* idbFactory = assertIDBFactory(&errorString, document);
+    if (!idbFactory) {
+        requestCallback->sendFailure(errorString);
         return;
+    }
 
     ScriptState* scriptState = ScriptState::forMainWorld(frame);
     if (!scriptState)
         return;
     ScriptState::Scope scope(scriptState);
     RefPtr<DatabaseLoader> databaseLoader = DatabaseLoader::create(scriptState, std::move(requestCallback));
     databaseLoader->start(idbFactory, document->getSecurityOrigin(), databaseName);
 }
 
-void InspectorIndexedDBAgent::requestData(ErrorString* errorString,
+void InspectorIndexedDBAgent::requestData(
     const String& securityOrigin,
     const String& databaseName,
     const String& objectStoreName,
     const String& indexName,
     int skipCount,
     int pageSize,
     const Maybe<protocol::IndexedDB::KeyRange>& keyRange,
     std::unique_ptr<RequestDataCallback> requestCallback)
 {
     LocalFrame* frame = m_inspectedFrames->frameWithSecurityOrigin(securityOrigin);
-    Document* document = assertDocument(errorString, frame);
-    if (!document)
+    ErrorString errorString;
+    Document* document = assertDocument(&errorString, frame);
+    if (!document) {
+        requestCallback->sendFailure(errorString);
         return;
-    IDBFactory* idbFactory = assertIDBFactory(errorString, document);
-    if (!idbFactory)
+    }
+    IDBFactory* idbFactory = assertIDBFactory(&errorString, document);
+    if (!idbFactory) {
+        requestCallback->sendFailure(errorString);
         return;
+    }
 
     IDBKeyRange* idbKeyRange = keyRange.isJust() ? idbKeyRangeFromKeyRange(keyRange.fromJust()) : nullptr;
     if (keyRange.isJust() && !idbKeyRange) {
-        *errorString = "Can not parse key range.";
+        requestCallback->sendFailure("Can not parse key range.");
         return;
     }
 
     ScriptState* scriptState = ScriptState::forMainWorld(frame);
     if (!scriptState)
         return;
     ScriptState::Scope scope(scriptState);
     RefPtr<DataLoader> dataLoader = DataLoader::create(m_v8Session, scriptState, std::move(requestCallback), objectStoreName, indexName, idbKeyRange, skipCount, pageSize);
     dataLoader->start(idbFactory, document->getSecurityOrigin(), databaseName);
 }
@@ skipping 76 matching lines @@
         }
         idbTransaction->addEventListener(EventTypeNames::complete, ClearObjectStoreListener::create(std::move(m_requestCallback)), false);
     }
 
     RequestCallback* getRequestCallback() override { return m_requestCallback.get(); }
 private:
     const String m_objectStoreName;
     std::unique_ptr<ClearObjectStoreCallback> m_requestCallback;
 };
 
-void InspectorIndexedDBAgent::clearObjectStore(ErrorString* errorString, const String& securityOrigin, const String& databaseName, const String& objectStoreName, std::unique_ptr<ClearObjectStoreCallback> requestCallback)
+void InspectorIndexedDBAgent::clearObjectStore(const String& securityOrigin, const String& databaseName, const String& objectStoreName, std::unique_ptr<ClearObjectStoreCallback> requestCallback)
 {
     LocalFrame* frame = m_inspectedFrames->frameWithSecurityOrigin(securityOrigin);
-    Document* document = assertDocument(errorString, frame);
-    if (!document)
+    ErrorString errorString;
+    Document* document = assertDocument(&errorString, frame);
+    if (!document) {
+        requestCallback->sendFailure(errorString);
         return;
-    IDBFactory* idbFactory = assertIDBFactory(errorString, document);
-    if (!idbFactory)
+    }
+    IDBFactory* idbFactory = assertIDBFactory(&errorString, document);
+    if (!idbFactory) {
+        requestCallback->sendFailure(errorString);
         return;
+    }
 
     ScriptState* scriptState = ScriptState::forMainWorld(frame);
     if (!scriptState)
         return;
     ScriptState::Scope scope(scriptState);
     RefPtr<ClearObjectStore> clearObjectStore = ClearObjectStore::create(scriptState, objectStoreName, std::move(requestCallback));
     clearObjectStore->start(idbFactory, document->getSecurityOrigin(), databaseName);
 }
 
 DEFINE_TRACE(InspectorIndexedDBAgent)
 {
     visitor->trace(m_inspectedFrames);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink