[DevTools] Provide a way to delete Indexed DBs

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 59 matching lines @@
 using blink::protocol::IndexedDB::ObjectStoreIndex;
 
 typedef blink::protocol::IndexedDB::Backend::RequestDatabaseNamesCallback
     RequestDatabaseNamesCallback;
 typedef blink::protocol::IndexedDB::Backend::RequestDatabaseCallback
     RequestDatabaseCallback;
 typedef blink::protocol::IndexedDB::Backend::RequestDataCallback
     RequestDataCallback;
 typedef blink::protocol::IndexedDB::Backend::ClearObjectStoreCallback
     ClearObjectStoreCallback;
+typedef blink::protocol::IndexedDB::Backend::DeleteDatabaseCallback
+    DeleteDatabaseCallback;
 
 namespace blink {
 
 namespace IndexedDBAgentState {
 static const char indexedDBAgentEnabled[] = "indexedDBAgentEnabled";
 };
 
 namespace {
 
 static const char kIndexedDBObjectGroup[] = "indexeddb";
@@ skipping 44 matching lines @@
   GetDatabaseNamesCallback(
       std::unique_ptr<RequestDatabaseNamesCallback> requestCallback,
       const String& securityOrigin)
       : EventListener(EventListener::CPPEventListenerType),
         m_requestCallback(std::move(requestCallback)),
         m_securityOrigin(securityOrigin) {}
   std::unique_ptr<RequestDatabaseNamesCallback> m_requestCallback;
   String m_securityOrigin;
 };
 
+class DeleteCallback final : public EventListener {
+  WTF_MAKE_NONCOPYABLE(DeleteCallback);
+
+ public:
+  static DeleteCallback* create(
+      std::unique_ptr<DeleteDatabaseCallback> requestCallback,
+      const String& securityOrigin) {
+    return new DeleteCallback(std::move(requestCallback), securityOrigin);
+  }
+
+  ~DeleteCallback() 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(
+          Response::Error("Failed to delete database."));
+      return;
+    }
+    m_requestCallback->sendSuccess();
+  }
+
+  DEFINE_INLINE_VIRTUAL_TRACE() { EventListener::trace(visitor); }
+
+ private:
+  DeleteCallback(std::unique_ptr<DeleteDatabaseCallback> requestCallback,
+                 const String& securityOrigin)
+      : EventListener(EventListener::CPPEventListenerType),
+        m_requestCallback(std::move(requestCallback)),
+        m_securityOrigin(securityOrigin) {}
+  std::unique_ptr<DeleteDatabaseCallback> m_requestCallback;
+  String m_securityOrigin;
+};
+
 template <typename RequestCallback>
 class OpenDatabaseCallback;
 template <typename RequestCallback>
 class UpgradeDatabaseCallback;
 
 template <typename RequestCallback>
 class ExecutableWithDatabase
     : public RefCounted<ExecutableWithDatabase<RequestCallback>> {
  public:
   ExecutableWithDatabase(ScriptState* scriptState)
@@ skipping 790 matching lines @@
     return;
   }
 
   ScriptState::Scope scope(scriptState);
   RefPtr<ClearObjectStore> clearObjectStore = ClearObjectStore::create(
       scriptState, objectStoreName, std::move(requestCallback));
   clearObjectStore->start(idbFactory, document->getSecurityOrigin(),
                           databaseName);
 }
 
+void InspectorIndexedDBAgent::deleteDatabase(
+    const String& securityOrigin,
+    const String& databaseName,
+    std::unique_ptr<DeleteDatabaseCallback> requestCallback) {
+  LocalFrame* frame =
+      m_inspectedFrames->frameWithSecurityOrigin(securityOrigin);
+  Document* document = frame ? frame->document() : nullptr;
+  if (!document) {
+    requestCallback->sendFailure(Response::Error(kNoDocumentError));
+    return;
+  }
+  IDBFactory* idbFactory = nullptr;
+  Response response = assertIDBFactory(document, idbFactory);
+  if (!response.isSuccess()) {
+    requestCallback->sendFailure(response);
+    return;
+  }
+
+  ScriptState* scriptState = ScriptState::forMainWorld(frame);
+  if (!scriptState) {
+    requestCallback->sendFailure(Response::InternalError());
+    return;
+  }
+  ScriptState::Scope scope(scriptState);
+  DummyExceptionStateForTesting exceptionState;
+  IDBRequest* idbRequest = idbFactory->closeConnectionsAndDeleteDatabase(
+      scriptState, databaseName, exceptionState);
+  if (exceptionState.hadException()) {
+    requestCallback->sendFailure(Response::Error("Could not delete database."));
+    return;
+  }
+  idbRequest->addEventListener(
+      EventTypeNames::success,
+      DeleteCallback::create(std::move(requestCallback),
+                             document->getSecurityOrigin()->toRawString()),
+      false);
+}
+
 DEFINE_TRACE(InspectorIndexedDBAgent) {
   visitor->trace(m_inspectedFrames);
   InspectorBaseAgent::trace(visitor);
 }
 
 }  // namespace blink