DevTools: split protocol Dispatcher into Backend interface and the dispatcher itself.

third_party/WebKit/Source/modules/webdatabase/InspectorDatabaseAgent.cpp

 /*
  * Copyright (C) 2010 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 30 matching lines @@
 #include "modules/webdatabase/SQLResultSetRowList.h"
 #include "modules/webdatabase/SQLStatementCallback.h"
 #include "modules/webdatabase/SQLStatementErrorCallback.h"
 #include "modules/webdatabase/SQLTransaction.h"
 #include "modules/webdatabase/SQLTransactionCallback.h"
 #include "modules/webdatabase/SQLTransactionErrorCallback.h"
 #include "modules/webdatabase/sqlite/SQLValue.h"
 #include "platform/inspector_protocol/Values.h"
 #include "wtf/Vector.h"
 
-typedef blink::protocol::Dispatcher::DatabaseCommandHandler::ExecuteSQLCallback ExecuteSQLCallback;
+typedef blink::protocol::Backend::Database::ExecuteSQLCallback ExecuteSQLCallback;
 
 namespace blink {
 
 namespace DatabaseAgentState {
 static const char databaseAgentEnabled[] = "databaseAgentEnabled";
 };
 
 namespace {
 
 class ExecuteSQLCallbackWrapper : public RefCounted<ExecuteSQLCallbackWrapper> {
@@ skipping 147 matching lines @@
     ~TransactionSuccessCallback() override { }
 
     void handleEvent() override { }
 
 private:
     TransactionSuccessCallback() { }
 };
 
 } // namespace
 
-void InspectorDatabaseAgent::didOpenDatabase(Database* database, const String& domain, const String& name, const String& version)
+void InspectorDatabaseAgent::didOpenDatabase(blink::Database* database, const String& domain, const String& name, const String& version)
 {
     if (InspectorDatabaseResource* resource = findByFileName(database->fileName())) {
         resource->setDatabase(database);
         return;
     }
 
     InspectorDatabaseResource* resource = InspectorDatabaseResource::create(database, domain, name, version);
     m_resources.set(resource->id(), resource);
     // Resources are only bound while visible.
     if (frontend() && m_enabled)
@@ skipping 48 matching lines @@
 
 void InspectorDatabaseAgent::getDatabaseTableNames(ErrorString* error, const String& databaseId, OwnPtr<protocol::Array<String>>* names)
 {
     if (!m_enabled) {
         *error = "Database agent is not enabled";
         return;
     }
 
     *names = protocol::Array<String>::create();
 
-    Database* database = databaseForId(databaseId);
+    blink::Database* database = databaseForId(databaseId);
     if (database) {
         Vector<String> tableNames = database->tableNames();
         unsigned length = tableNames.size();
         for (unsigned i = 0; i < length; ++i)
             (*names)->addItem(tableNames[i]);
     }
 }
 
 void InspectorDatabaseAgent::executeSQL(ErrorString*, const String& databaseId, const String& query, PassOwnPtr<ExecuteSQLCallback> prpRequestCallback)
 {
     OwnPtr<ExecuteSQLCallback> requestCallback = prpRequestCallback;
 
     if (!m_enabled) {
         requestCallback->sendFailure("Database agent is not enabled");
         return;
     }
 
-    Database* database = databaseForId(databaseId);
+    blink::Database* database = databaseForId(databaseId);
     if (!database) {
         requestCallback->sendFailure("Database not found");
         return;
     }
 
     RefPtr<ExecuteSQLCallbackWrapper> wrapper = ExecuteSQLCallbackWrapper::create(requestCallback.release());
     SQLTransactionCallback* callback = TransactionCallback::create(query, wrapper);
     SQLTransactionErrorCallback* errorCallback = TransactionErrorCallback::create(wrapper);
     VoidCallback* successCallback = TransactionSuccessCallback::create();
     database->transaction(callback, errorCallback, successCallback);
 }
 
 InspectorDatabaseResource* InspectorDatabaseAgent::findByFileName(const String& fileName)
 {
     for (DatabaseResourcesHeapMap::iterator it = m_resources.begin(); it != m_resources.end(); ++it) {
         if (it->value->database()->fileName() == fileName)
             return it->value.get();
     }
     return 0;
 }
 
-Database* InspectorDatabaseAgent::databaseForId(const String& databaseId)
+blink::Database* InspectorDatabaseAgent::databaseForId(const String& databaseId)
 {
     DatabaseResourcesHeapMap::iterator it = m_resources.find(databaseId);
     if (it == m_resources.end())
         return 0;
     return it->value->database();
 }
 
 DEFINE_TRACE(InspectorDatabaseAgent)
 {
     visitor->trace(m_page);
     visitor->trace(m_resources);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink