[DevTools] migrate Database, IndexedDB and CacheStorage to new style

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 69 matching lines @@
     ClearObjectStoreCallback;
 
 namespace blink {
 
 namespace IndexedDBAgentState {
 static const char indexedDBAgentEnabled[] = "indexedDBAgentEnabled";
 };
 
 namespace {
 
 static const char indexedDBObjectGroup[] = "indexeddb";

[dgozman, 2016/11/02 17:49:36]

Please change these to use kConstantName style.

[kozy, 2016/11/02 18:28:02]

Done.

+static const char noDocumentError[] = "No document for given frame found";
 
 class GetDatabaseNamesCallback final : public EventListener {
   WTF_MAKE_NONCOPYABLE(GetDatabaseNamesCallback);
 
  public:
   static GetDatabaseNamesCallback* create(
       std::unique_ptr<RequestDatabaseNamesCallback> requestCallback,
       const String& securityOrigin) {
     return new GetDatabaseNamesCallback(std::move(requestCallback),
                                         securityOrigin);
   }
 
   ~GetDatabaseNamesCallback() override {}
 
   bool operator==(const EventListener& other) const override {
     return this == &other;
   }
 
   void handleEvent(ExecutionContext*, Event* event) override {
     if (event->type() != EventTypeNames::success) {
-      m_requestCallback->sendFailure("Unexpected event type.");
+      m_requestCallback->sendFailure(Response::Error("Unexpected event type."));
       return;
     }
 
     IDBRequest* idbRequest = static_cast<IDBRequest*>(event->target());
     IDBAny* requestResult = idbRequest->resultAsAny();
     if (requestResult->getType() != IDBAny::DOMStringListType) {
-      m_requestCallback->sendFailure("Unexpected result type.");
+      m_requestCallback->sendFailure(
+          Response::Error("Unexpected result type."));
       return;
     }
 
     DOMStringList* databaseNamesList = requestResult->domStringList();
     std::unique_ptr<protocol::Array<String>> databaseNames =
         protocol::Array<String>::create();
     for (size_t i = 0; i < databaseNamesList->length(); ++i)
       databaseNames->addItem(databaseNamesList->anonymousIndexedGetter(i));
     m_requestCallback->sendSuccess(std::move(databaseNames));
   }
@@ skipping 27 matching lines @@
              SecurityOrigin*,
              const String& databaseName) {
     OpenDatabaseCallback<RequestCallback>* openCallback =
         OpenDatabaseCallback<RequestCallback>::create(this);
     UpgradeDatabaseCallback<RequestCallback>* upgradeCallback =
         UpgradeDatabaseCallback<RequestCallback>::create(this);
     TrackExceptionState exceptionState;
     IDBOpenDBRequest* idbOpenDBRequest =
         idbFactory->open(getScriptState(), databaseName, exceptionState);
     if (exceptionState.hadException()) {
-      getRequestCallback()->sendFailure("Could not open database.");
+      getRequestCallback()->sendFailure(
+          Response::Error("Could not open database."));
       return;
     }
     idbOpenDBRequest->addEventListener(EventTypeNames::upgradeneeded,
                                        upgradeCallback, false);
     idbOpenDBRequest->addEventListener(EventTypeNames::success, openCallback,
                                        false);
   }
   virtual void execute(IDBDatabase*) = 0;
   virtual RequestCallback* getRequestCallback() = 0;
   ExecutionContext* context() const {
@@ skipping 15 matching lines @@
 
   ~OpenDatabaseCallback() override {}
 
   bool operator==(const EventListener& other) const override {
     return this == &other;
   }
 
   void handleEvent(ExecutionContext* context, Event* event) override {
     if (event->type() != EventTypeNames::success) {
       m_executableWithDatabase->getRequestCallback()->sendFailure(
-          "Unexpected event type.");
+          Response::Error("Unexpected event type."));
       return;
     }
 
     IDBOpenDBRequest* idbOpenDBRequest =
         static_cast<IDBOpenDBRequest*>(event->target());
     IDBAny* requestResult = idbOpenDBRequest->resultAsAny();
     if (requestResult->getType() != IDBAny::IDBDatabaseType) {
       m_executableWithDatabase->getRequestCallback()->sendFailure(
-          "Unexpected result type.");
+          Response::Error("Unexpected result type."));
       return;
     }
 
     IDBDatabase* idbDatabase = requestResult->idbDatabase();
     m_executableWithDatabase->execute(idbDatabase);
     V8PerIsolateData::from(
         m_executableWithDatabase->getScriptState()->isolate())
         ->runEndOfScopeTasks();
     idbDatabase->close();
   }
@@ skipping 16 matching lines @@
 
   ~UpgradeDatabaseCallback() override {}
 
   bool operator==(const EventListener& other) const override {
     return this == &other;
   }
 
   void handleEvent(ExecutionContext* context, Event* event) override {
     if (event->type() != EventTypeNames::upgradeneeded) {
       m_executableWithDatabase->getRequestCallback()->sendFailure(
-          "Unexpected event type.");
+          Response::Error("Unexpected event type."));
       return;
     }
 
     // If an "upgradeneeded" event comes through then the database that
     // had previously been enumerated was deleted. We don't want to
     // implicitly re-create it here, so abort the transaction.
     IDBOpenDBRequest* idbOpenDBRequest =
         static_cast<IDBOpenDBRequest*>(event->target());
     NonThrowableExceptionState exceptionState;
     idbOpenDBRequest->transaction()->abort(exceptionState);
     m_executableWithDatabase->getRequestCallback()->sendFailure(
-        "Aborted upgrade.");
+        Response::Error("Aborted upgrade."));
   }
 
  private:
   UpgradeDatabaseCallback(
       ExecutableWithDatabase<RequestCallback>* executableWithDatabase)
       : EventListener(EventListener::CPPEventListenerType),
         m_executableWithDatabase(executableWithDatabase) {}
   RefPtr<ExecutableWithDatabase<RequestCallback>> m_executableWithDatabase;
 };
 
@@ skipping 205 matching lines @@
   }
 
   ~OpenCursorCallback() override {}
 
   bool operator==(const EventListener& other) const override {
     return this == &other;
   }
 
   void handleEvent(ExecutionContext*, Event* event) override {
     if (event->type() != EventTypeNames::success) {
-      m_requestCallback->sendFailure("Unexpected event type.");
+      m_requestCallback->sendFailure(Response::Error("Unexpected event type."));
       return;
     }
 
     IDBRequest* idbRequest = static_cast<IDBRequest*>(event->target());
     IDBAny* requestResult = idbRequest->resultAsAny();
     if (requestResult->getType() == IDBAny::IDBValueType) {
       end(false);
       return;
     }
     if (requestResult->getType() != IDBAny::IDBCursorWithValueType) {
-      m_requestCallback->sendFailure("Unexpected result type.");
+      m_requestCallback->sendFailure(
+          Response::Error("Unexpected result type."));
       return;
     }
 
     IDBCursorWithValue* idbCursor = requestResult->idbCursorWithValue();
 
     if (m_skipCount) {
       TrackExceptionState exceptionState;
       idbCursor->advance(m_skipCount, exceptionState);
-      if (exceptionState.hadException())
-        m_requestCallback->sendFailure("Could not advance cursor.");
+      if (exceptionState.hadException()) {
+        m_requestCallback->sendFailure(
+            Response::Error("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.
     TrackExceptionState exceptionState;
     idbCursor->continueFunction(nullptr, nullptr, exceptionState);
     if (exceptionState.hadException()) {
-      m_requestCallback->sendFailure("Could not continue cursor.");
+      m_requestCallback->sendFailure(
+          Response::Error("Could not continue cursor."));
       return;
     }
 
     Document* document = toDocument(m_scriptState->getExecutionContext());
     if (!document)
       return;
     ScriptState* scriptState = m_scriptState.get();
     ScriptState::Scope scope(scriptState);
     v8::Local<v8::Context> context = scriptState->context();
     v8_inspector::StringView objectGroup =
@@ skipping 55 matching lines @@
         v8Session, scriptState, std::move(requestCallback), objectStoreName,
         indexName, idbKeyRange, skipCount, pageSize));
   }
 
   ~DataLoader() override {}
 
   void execute(IDBDatabase* idbDatabase) override {
     IDBTransaction* idbTransaction = transactionForDatabase(
         getScriptState(), idbDatabase, m_objectStoreName);
     if (!idbTransaction) {
-      m_requestCallback->sendFailure("Could not get transaction");
+      m_requestCallback->sendFailure(
+          Response::Error("Could not get transaction"));
       return;
     }
     IDBObjectStore* idbObjectStore =
         objectStoreForTransaction(idbTransaction, m_objectStoreName);
     if (!idbObjectStore) {
-      m_requestCallback->sendFailure("Could not get object store");
+      m_requestCallback->sendFailure(
+          Response::Error("Could not get object store"));
       return;
     }
 
     IDBRequest* idbRequest;
     if (!m_indexName.isEmpty()) {
       IDBIndex* idbIndex = indexForObjectStore(idbObjectStore, m_indexName);
       if (!idbIndex) {
-        m_requestCallback->sendFailure("Could not get index");
+        m_requestCallback->sendFailure(Response::Error("Could not get index"));
         return;
       }
 
       idbRequest = idbIndex->openCursor(getScriptState(), m_idbKeyRange.get(),
                                         WebIDBCursorDirectionNext);
     } else {
       idbRequest = idbObjectStore->openCursor(
           getScriptState(), m_idbKeyRange.get(), WebIDBCursorDirectionNext);
     }
     OpenCursorCallback* openCursorCallback = OpenCursorCallback::create(
@@ skipping 38 matching lines @@
 InspectorIndexedDBAgent::InspectorIndexedDBAgent(
     InspectedFrames* inspectedFrames,
     v8_inspector::V8InspectorSession* v8Session)
     : m_inspectedFrames(inspectedFrames), m_v8Session(v8Session) {}
 
 InspectorIndexedDBAgent::~InspectorIndexedDBAgent() {}
 
 void InspectorIndexedDBAgent::restore() {
   if (m_state->booleanProperty(IndexedDBAgentState::indexedDBAgentEnabled,
                                false)) {
-    ErrorString error;
-    enable(&error);
+    enable();
   }
 }
 
 void InspectorIndexedDBAgent::didCommitLoadForLocalFrame(LocalFrame* frame) {
   if (frame == m_inspectedFrames->root())
     m_v8Session->releaseObjectGroup(
         toV8InspectorStringView(indexedDBObjectGroup));
 }
 
-void InspectorIndexedDBAgent::enable(ErrorString*) {
+Response InspectorIndexedDBAgent::enable() {
   m_state->setBoolean(IndexedDBAgentState::indexedDBAgentEnabled, true);
+  return Response::OK();
 }
 
-void InspectorIndexedDBAgent::disable(ErrorString*) {
+Response InspectorIndexedDBAgent::disable() {
   m_state->setBoolean(IndexedDBAgentState::indexedDBAgentEnabled, false);
   m_v8Session->releaseObjectGroup(
       toV8InspectorStringView(indexedDBObjectGroup));
+  return Response::OK();
 }
 
-static Document* assertDocument(ErrorString* errorString, LocalFrame* frame) {
-  Document* document = frame ? frame->document() : nullptr;
-
-  if (!document)
-    *errorString = "No document for given frame found";
-
-  return document;
-}
-
-static IDBFactory* assertIDBFactory(ErrorString* errorString,
-                                    Document* document) {
+static Response assertIDBFactory(Document* document, IDBFactory*& result) {
   LocalDOMWindow* domWindow = document->domWindow();
-  if (!domWindow) {
-    *errorString = "No IndexedDB factory for given frame found";
-    return nullptr;
-  }
+  if (!domWindow)
+    return Response::Error("No IndexedDB factory for given frame found");
   IDBFactory* idbFactory = GlobalIndexedDB::indexedDB(*domWindow);
 
   if (!idbFactory)
-    *errorString = "No IndexedDB factory for given frame found";
-
-  return idbFactory;
+    return Response::Error("No IndexedDB factory for given frame found");
+  result = idbFactory;
+  return Response::OK();
 }
 
 void InspectorIndexedDBAgent::requestDatabaseNames(
     const String& securityOrigin,
     std::unique_ptr<RequestDatabaseNamesCallback> requestCallback) {
   LocalFrame* frame =
       m_inspectedFrames->frameWithSecurityOrigin(securityOrigin);
   ErrorString errorString;
-  Document* document = assertDocument(&errorString, frame);
+  Document* document = frame ? frame->document() : nullptr;
   if (!document) {
-    requestCallback->sendFailure(errorString);
+    requestCallback->sendFailure(Response::Error(noDocumentError));
     return;
   }
-  IDBFactory* idbFactory = assertIDBFactory(&errorString, document);
-  if (!idbFactory) {
-    requestCallback->sendFailure(errorString);
+  IDBFactory* idbFactory = nullptr;
+  Response response = assertIDBFactory(document, idbFactory);
+  if (!response.isSuccess()) {
+    requestCallback->sendFailure(response);
     return;
   }
 
   ScriptState* scriptState = ScriptState::forMainWorld(frame);
-  if (!scriptState)
+  if (!scriptState) {
+    requestCallback->sendFailure(Response::InternalError());
     return;
+  }
   ScriptState::Scope scope(scriptState);
   TrackExceptionState exceptionState;
   IDBRequest* idbRequest =
       idbFactory->getDatabaseNames(scriptState, exceptionState);
   if (exceptionState.hadException()) {
-    requestCallback->sendFailure("Could not obtain database names.");
+    requestCallback->sendFailure(
+        Response::Error("Could not obtain database names."));
     return;
   }
   idbRequest->addEventListener(
       EventTypeNames::success,
       GetDatabaseNamesCallback::create(
           std::move(requestCallback),
           document->getSecurityOrigin()->toRawString()),
       false);
 }
 
 void InspectorIndexedDBAgent::requestDatabase(
     const String& securityOrigin,
     const String& databaseName,
     std::unique_ptr<RequestDatabaseCallback> requestCallback) {
   LocalFrame* frame =
       m_inspectedFrames->frameWithSecurityOrigin(securityOrigin);
   ErrorString errorString;
-  Document* document = assertDocument(&errorString, frame);
+  Document* document = frame ? frame->document() : nullptr;
   if (!document) {
-    requestCallback->sendFailure(errorString);
+    requestCallback->sendFailure(Response::Error(noDocumentError));
     return;
   }
-  IDBFactory* idbFactory = assertIDBFactory(&errorString, document);
-  if (!idbFactory) {
-    requestCallback->sendFailure(errorString);
+  IDBFactory* idbFactory = nullptr;
+  Response response = assertIDBFactory(document, idbFactory);
+  if (!response.isSuccess()) {
+    requestCallback->sendFailure(response);
     return;
   }
 
   ScriptState* scriptState = ScriptState::forMainWorld(frame);
-  if (!scriptState)
+  if (!scriptState) {
+    requestCallback->sendFailure(Response::InternalError());
     return;
+  }
+
   ScriptState::Scope scope(scriptState);
   RefPtr<DatabaseLoader> databaseLoader =
       DatabaseLoader::create(scriptState, std::move(requestCallback));
   databaseLoader->start(idbFactory, document->getSecurityOrigin(),
                         databaseName);
 }
 
 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,
+    Maybe<protocol::IndexedDB::KeyRange> keyRange,
     std::unique_ptr<RequestDataCallback> requestCallback) {
   LocalFrame* frame =
       m_inspectedFrames->frameWithSecurityOrigin(securityOrigin);
   ErrorString errorString;
-  Document* document = assertDocument(&errorString, frame);
+  Document* document = frame ? frame->document() : nullptr;
   if (!document) {
-    requestCallback->sendFailure(errorString);
+    requestCallback->sendFailure(Response::Error(noDocumentError));
     return;
   }
-  IDBFactory* idbFactory = assertIDBFactory(&errorString, document);
-  if (!idbFactory) {
-    requestCallback->sendFailure(errorString);
+  IDBFactory* idbFactory = nullptr;
+  Response response = assertIDBFactory(document, idbFactory);
+  if (!response.isSuccess()) {
+    requestCallback->sendFailure(response);
     return;
   }
 
   IDBKeyRange* idbKeyRange = keyRange.isJust()
                                  ? idbKeyRangeFromKeyRange(keyRange.fromJust())
                                  : nullptr;
   if (keyRange.isJust() && !idbKeyRange) {
-    requestCallback->sendFailure("Can not parse key range.");
+    requestCallback->sendFailure(Response::Error("Can not parse key range."));
     return;
   }
 
   ScriptState* scriptState = ScriptState::forMainWorld(frame);
-  if (!scriptState)
+  if (!scriptState) {
+    requestCallback->sendFailure(Response::InternalError());
     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);
 }
 
 class ClearObjectStoreListener final : public EventListener {
   WTF_MAKE_NONCOPYABLE(ClearObjectStoreListener);
 
  public:
   static ClearObjectStoreListener* create(
       std::unique_ptr<ClearObjectStoreCallback> requestCallback) {
     return new ClearObjectStoreListener(std::move(requestCallback));
   }
 
   ~ClearObjectStoreListener() override {}
 
   bool operator==(const EventListener& other) const override {
     return this == &other;
   }
 
   void handleEvent(ExecutionContext*, Event* event) override {
     if (event->type() != EventTypeNames::complete) {
-      m_requestCallback->sendFailure("Unexpected event type.");
+      m_requestCallback->sendFailure(Response::Error("Unexpected event type."));
       return;
     }
 
     m_requestCallback->sendSuccess();
   }
 
   DEFINE_INLINE_VIRTUAL_TRACE() { EventListener::trace(visitor); }
 
  private:
   ClearObjectStoreListener(
@@ skipping 20 matching lines @@
                    std::unique_ptr<ClearObjectStoreCallback> requestCallback)
       : ExecutableWithDatabase(scriptState),
         m_objectStoreName(objectStoreName),
         m_requestCallback(std::move(requestCallback)) {}
 
   void execute(IDBDatabase* idbDatabase) override {
     IDBTransaction* idbTransaction =
         transactionForDatabase(getScriptState(), idbDatabase, m_objectStoreName,
                                IndexedDBNames::readwrite);
     if (!idbTransaction) {
-      m_requestCallback->sendFailure("Could not get transaction");
+      m_requestCallback->sendFailure(
+          Response::Error("Could not get transaction"));
       return;
     }
     IDBObjectStore* idbObjectStore =
         objectStoreForTransaction(idbTransaction, m_objectStoreName);
     if (!idbObjectStore) {
-      m_requestCallback->sendFailure("Could not get object store");
+      m_requestCallback->sendFailure(
+          Response::Error("Could not get object store"));
       return;
     }
 
     TrackExceptionState exceptionState;
     idbObjectStore->clear(getScriptState(), exceptionState);
     ASSERT(!exceptionState.hadException());
     if (exceptionState.hadException()) {
       ExceptionCode ec = exceptionState.code();
-      m_requestCallback->sendFailure(
+      m_requestCallback->sendFailure(Response::Error(
           String::format("Could not clear object store '%s': %d",
-                         m_objectStoreName.utf8().data(), ec));
+                         m_objectStoreName.utf8().data(), ec)));
       return;
     }
     idbTransaction->addEventListener(
         EventTypeNames::complete,
         ClearObjectStoreListener::create(std::move(m_requestCallback)), false);
   }
 
   ClearObjectStoreCallback* getRequestCallback() override {
     return m_requestCallback.get();
   }
 
  private:
   const String m_objectStoreName;
   std::unique_ptr<ClearObjectStoreCallback> m_requestCallback;
 };
 
 void InspectorIndexedDBAgent::clearObjectStore(
     const String& securityOrigin,
     const String& databaseName,
     const String& objectStoreName,
     std::unique_ptr<ClearObjectStoreCallback> requestCallback) {
   LocalFrame* frame =
       m_inspectedFrames->frameWithSecurityOrigin(securityOrigin);
   ErrorString errorString;
-  Document* document = assertDocument(&errorString, frame);
+  Document* document = frame ? frame->document() : nullptr;
   if (!document) {
-    requestCallback->sendFailure(errorString);
+    requestCallback->sendFailure(Response::Error(noDocumentError));
     return;
   }
-  IDBFactory* idbFactory = assertIDBFactory(&errorString, document);
-  if (!idbFactory) {
-    requestCallback->sendFailure(errorString);
+  IDBFactory* idbFactory = nullptr;
+  Response response = assertIDBFactory(document, idbFactory);
+  if (!response.isSuccess()) {
+    requestCallback->sendFailure(response);
     return;
   }
 
   ScriptState* scriptState = ScriptState::forMainWorld(frame);
-  if (!scriptState)
+  if (!scriptState) {
+    requestCallback->sendFailure(Response::InternalError());
     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