[inspector_protocol] Support fall through.

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 52 matching lines @@
 
 using blink::protocol::Array;
 using blink::protocol::IndexedDB::DatabaseWithObjectStores;
 using blink::protocol::IndexedDB::DataEntry;
 using blink::protocol::IndexedDB::Key;
 using blink::protocol::IndexedDB::KeyPath;
 using blink::protocol::IndexedDB::KeyRange;
 using blink::protocol::IndexedDB::ObjectStore;
 using blink::protocol::IndexedDB::ObjectStoreIndex;
 
-typedef blink::protocol::BackendCallback RequestCallback;
 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;
 
 namespace blink {
@@ skipping 50 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 ExecutableWithDatabase : public RefCounted<ExecutableWithDatabase> {
+template <typename RequestCallback>
+class OpenDatabaseCallback;
+template <typename RequestCallback>
+class UpgradeDatabaseCallback;
+
+template <typename RequestCallback>
+class ExecutableWithDatabase
+    : public RefCounted<ExecutableWithDatabase<RequestCallback>> {
  public:
   ExecutableWithDatabase(ScriptState* scriptState)
       : m_scriptState(scriptState) {}
   virtual ~ExecutableWithDatabase() {}
-  void start(IDBFactory*, SecurityOrigin*, const String& databaseName);
+  void start(IDBFactory* idbFactory,
+             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.");
+      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 {
     return m_scriptState->getExecutionContext();
   }
   ScriptState* getScriptState() const { return m_scriptState.get(); }
 
  private:
   RefPtr<ScriptState> m_scriptState;
 };
 
+template <typename RequestCallback>
 class OpenDatabaseCallback final : public EventListener {
  public:
   static OpenDatabaseCallback* create(
-      ExecutableWithDatabase* executableWithDatabase) {
+      ExecutableWithDatabase<RequestCallback>* executableWithDatabase) {
     return new OpenDatabaseCallback(executableWithDatabase);
   }
 
   ~OpenDatabaseCallback() override {}
 
   bool operator==(const EventListener& other) const override {
     return this == &other;
   }
 
   void handleEvent(ExecutionContext* context, Event* event) override {
@@ skipping 14 matching lines @@
 
     IDBDatabase* idbDatabase = requestResult->idbDatabase();
     m_executableWithDatabase->execute(idbDatabase);
     V8PerIsolateData::from(
         m_executableWithDatabase->getScriptState()->isolate())
         ->runEndOfScopeTasks();
     idbDatabase->close();
   }
 
  private:
-  OpenDatabaseCallback(ExecutableWithDatabase* executableWithDatabase)
+  OpenDatabaseCallback(
+      ExecutableWithDatabase<RequestCallback>* executableWithDatabase)
       : EventListener(EventListener::CPPEventListenerType),
         m_executableWithDatabase(executableWithDatabase) {}
-  RefPtr<ExecutableWithDatabase> m_executableWithDatabase;
+  RefPtr<ExecutableWithDatabase<RequestCallback>> m_executableWithDatabase;
 };
 
+template <typename RequestCallback>
 class UpgradeDatabaseCallback final : public EventListener {
  public:
   static UpgradeDatabaseCallback* create(
-      ExecutableWithDatabase* executableWithDatabase) {
+      ExecutableWithDatabase<RequestCallback>* executableWithDatabase) {
     return new UpgradeDatabaseCallback(executableWithDatabase);
   }
 
   ~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.");
       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.");
   }
 
  private:
-  UpgradeDatabaseCallback(ExecutableWithDatabase* executableWithDatabase)
+  UpgradeDatabaseCallback(
+      ExecutableWithDatabase<RequestCallback>* executableWithDatabase)
       : EventListener(EventListener::CPPEventListenerType),
         m_executableWithDatabase(executableWithDatabase) {}
-  RefPtr<ExecutableWithDatabase> m_executableWithDatabase;
+  RefPtr<ExecutableWithDatabase<RequestCallback>> m_executableWithDatabase;
 };
 
-void ExecutableWithDatabase::start(IDBFactory* idbFactory,
-                                   SecurityOrigin*,
-                                   const String& databaseName) {
-  OpenDatabaseCallback* openCallback = OpenDatabaseCallback::create(this);
-  UpgradeDatabaseCallback* upgradeCallback =
-      UpgradeDatabaseCallback::create(this);
-  TrackExceptionState exceptionState;
-  IDBOpenDBRequest* idbOpenDBRequest =
-      idbFactory->open(getScriptState(), databaseName, exceptionState);
-  if (exceptionState.hadException()) {
-    getRequestCallback()->sendFailure("Could not open database.");
-    return;
-  }
-  idbOpenDBRequest->addEventListener(EventTypeNames::upgradeneeded,
-                                     upgradeCallback, false);
-  idbOpenDBRequest->addEventListener(EventTypeNames::success, openCallback,
-                                     false);
-}
-
 static IDBTransaction* transactionForDatabase(
     ScriptState* scriptState,
     IDBDatabase* idbDatabase,
     const String& objectStoreName,
     const String& mode = IndexedDBNames::readonly) {
   TrackExceptionState exceptionState;
   StringOrStringSequenceOrDOMStringList scope;
   scope.setString(objectStoreName);
   IDBTransaction* idbTransaction =
       idbDatabase->transaction(scriptState, scope, mode, exceptionState);
@@ skipping 45 matching lines @@
       keyPath->setArray(std::move(array));
       break;
     }
     default:
       ASSERT_NOT_REACHED();
   }
 
   return keyPath;
 }
 
-class DatabaseLoader final : public ExecutableWithDatabase {
+class DatabaseLoader final
+    : public ExecutableWithDatabase<RequestDatabaseCallback> {
  public:
   static PassRefPtr<DatabaseLoader> create(
       ScriptState* scriptState,
       std::unique_ptr<RequestDatabaseCallback> requestCallback) {
     return adoptRef(
         new DatabaseLoader(scriptState, std::move(requestCallback)));
   }
 
   ~DatabaseLoader() override {}
 
@@ skipping 36 matching lines @@
     std::unique_ptr<DatabaseWithObjectStores> result =
         DatabaseWithObjectStores::create()
             .setName(idbDatabase->name())
             .setVersion(idbDatabase->version())
             .setObjectStores(std::move(objectStores))
             .build();
 
     m_requestCallback->sendSuccess(std::move(result));
   }
 
-  RequestCallback* getRequestCallback() override {
+  RequestDatabaseCallback* getRequestCallback() override {
     return m_requestCallback.get();
   }
 
  private:
   DatabaseLoader(ScriptState* scriptState,
                  std::unique_ptr<RequestDatabaseCallback> requestCallback)
       : ExecutableWithDatabase(scriptState),
         m_requestCallback(std::move(requestCallback)) {}
   std::unique_ptr<RequestDatabaseCallback> m_requestCallback;
 };
@@ skipping 161 matching lines @@
   }
 
   v8_inspector::V8InspectorSession* m_v8Session;
   RefPtr<ScriptState> m_scriptState;
   std::unique_ptr<RequestDataCallback> m_requestCallback;
   int m_skipCount;
   unsigned m_pageSize;
   std::unique_ptr<Array<DataEntry>> m_result;
 };
 
-class DataLoader final : public ExecutableWithDatabase {
+class DataLoader final : public ExecutableWithDatabase<RequestDataCallback> {
  public:
   static PassRefPtr<DataLoader> create(
       v8_inspector::V8InspectorSession* v8Session,
       ScriptState* scriptState,
       std::unique_ptr<RequestDataCallback> requestCallback,
       const String& objectStoreName,
       const String& indexName,
       IDBKeyRange* idbKeyRange,
       int skipCount,
       unsigned pageSize) {
@@ skipping 32 matching lines @@
       idbRequest = idbObjectStore->openCursor(
           getScriptState(), m_idbKeyRange.get(), WebIDBCursorDirectionNext);
     }
     OpenCursorCallback* openCursorCallback = OpenCursorCallback::create(
         m_v8Session, getScriptState(), std::move(m_requestCallback),
         m_skipCount, m_pageSize);
     idbRequest->addEventListener(EventTypeNames::success, openCursorCallback,
                                  false);
   }
 
-  RequestCallback* getRequestCallback() override {
+  RequestDataCallback* getRequestCallback() override {
     return m_requestCallback.get();
   }
   DataLoader(v8_inspector::V8InspectorSession* v8Session,
              ScriptState* scriptState,
              std::unique_ptr<RequestDataCallback> requestCallback,
              const String& objectStoreName,
              const String& indexName,
              IDBKeyRange* idbKeyRange,
              int skipCount,
              unsigned pageSize)
@@ skipping 206 matching lines @@
 
  private:
   ClearObjectStoreListener(
       std::unique_ptr<ClearObjectStoreCallback> requestCallback)
       : EventListener(EventListener::CPPEventListenerType),
         m_requestCallback(std::move(requestCallback)) {}
 
   std::unique_ptr<ClearObjectStoreCallback> m_requestCallback;
 };
 
-class ClearObjectStore final : public ExecutableWithDatabase {
+class ClearObjectStore final
+    : public ExecutableWithDatabase<ClearObjectStoreCallback> {
  public:
   static PassRefPtr<ClearObjectStore> create(
       ScriptState* scriptState,
       const String& objectStoreName,
       std::unique_ptr<ClearObjectStoreCallback> requestCallback) {
     return adoptRef(new ClearObjectStore(scriptState, objectStoreName,
                                          std::move(requestCallback)));
   }
 
   ClearObjectStore(ScriptState* scriptState,
@@ skipping 26 matching lines @@
       m_requestCallback->sendFailure(
           String::format("Could not clear object store '%s': %d",
                          m_objectStoreName.utf8().data(), ec));
       return;
     }
     idbTransaction->addEventListener(
         EventTypeNames::complete,
         ClearObjectStoreListener::create(std::move(m_requestCallback)), false);
   }
 
-  RequestCallback* getRequestCallback() override {
+  ClearObjectStoreCallback* getRequestCallback() override {
     return m_requestCallback.get();
   }
 
  private:
   const String m_objectStoreName;
   std::unique_ptr<ClearObjectStoreCallback> m_requestCallback;
 };
 
 void InspectorIndexedDBAgent::clearObjectStore(
     const String& securityOrigin,
@@ skipping 23 matching lines @@
   clearObjectStore->start(idbFactory, document->getSecurityOrigin(),
                           databaseName);
 }
 
 DEFINE_TRACE(InspectorIndexedDBAgent) {
   visitor->trace(m_inspectedFrames);
   InspectorBaseAgent::trace(visitor);
 }
 
 }  // namespace blink