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

   1 /*
   2  * Copyright (C) 2010 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  14  *     its contributors may be used to endorse or promote products derived
  15  *     from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include "config.h"
  30 #include "modules/webdatabase/InspectorDatabaseAgent.h"
  31
  32 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
  33 #include "core/frame/LocalFrame.h"
  34 #include "core/html/VoidCallback.h"
  35 #include "core/inspector/InspectorState.h"
  36 #include "core/loader/DocumentLoader.h"
  37 #include "core/page/Page.h"
  38 #include "modules/webdatabase/Database.h"
  39 #include "modules/webdatabase/InspectorDatabaseResource.h"
  40 #include "modules/webdatabase/SQLError.h"
  41 #include "modules/webdatabase/SQLResultSet.h"
  42 #include "modules/webdatabase/SQLResultSetRowList.h"
  43 #include "modules/webdatabase/SQLStatementCallback.h"
  44 #include "modules/webdatabase/SQLStatementErrorCallback.h"
  45 #include "modules/webdatabase/SQLTransaction.h"
  46 #include "modules/webdatabase/SQLTransactionCallback.h"
  47 #include "modules/webdatabase/SQLTransactionErrorCallback.h"
  48 #include "modules/webdatabase/sqlite/SQLValue.h"
  49 #include "platform/JSONValues.h"
  50 #include "wtf/Vector.h"
  51
  52 typedef blink::InspectorBackendDispatcher::DatabaseCommandHandler::ExecuteSQLCallback ExecuteSQLCallback;
  53
  54 namespace blink {
  55
  56 namespace DatabaseAgentState {
  57 static const char databaseAgentEnabled[] = "databaseAgentEnabled";
  58 };
  59
  60 namespace {
  61
  62 void reportTransactionFailed(ExecuteSQLCallback* requestCallback, SQLError* error)
  63 {
  64     RefPtr<TypeBuilder::Database::Error> errorObject = TypeBuilder::Database::Error::create()
  65         .setMessage(error->message())
  66         .setCode(error->code());
  67     requestCallback->sendSuccess(nullptr, nullptr, errorObject.release());
  68 }
  69
  70 class StatementCallback final : public SQLStatementCallback {
  71 public:
  72     static StatementCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
  73     {
  74         return new StatementCallback(requestCallback);
  75     }
  76
  77     virtual ~StatementCallback() { }
  78
  79     virtual void trace(Visitor* visitor)
  80     {
  81         visitor->trace(m_requestCallback);
  82         SQLStatementCallback::trace(visitor);
  83     }
  84
  85     virtual bool handleEvent(SQLTransaction*, SQLResultSet* resultSet) override
  86     {
  87         SQLResultSetRowList* rowList = resultSet->rows();
  88
  89         RefPtr<TypeBuilder::Array<String> > columnNames = TypeBuilder::Array<String>::create();
  90         const Vector<String>& columns = rowList->columnNames();
  91         for (size_t i = 0; i < columns.size(); ++i)
  92             columnNames->addItem(columns[i]);
  93
  94         RefPtr<TypeBuilder::Array<JSONValue> > values = TypeBuilder::Array<JSONValue>::create();
  95         const Vector<SQLValue>& data = rowList->values();
  96         for (size_t i = 0; i < data.size(); ++i) {
  97             const SQLValue& value = rowList->values()[i];
  98             switch (value.type()) {
  99             case SQLValue::StringValue: values->addItem(JSONString::create(value.string())); break;
 100             case SQLValue::NumberValue: values->addItem(JSONBasicValue::create(value.number())); break;
 101             case SQLValue::NullValue: values->addItem(JSONValue::null()); break;
 102             }
 103         }
 104         m_requestCallback->sendSuccess(columnNames.release(), values.release(), nullptr);
 105         return true;
 106     }
 107
 108 private:
 109     StatementCallback(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
 110         : m_requestCallback(requestCallback) { }
 111     RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback;
 112 };
 113
 114 class StatementErrorCallback final : public SQLStatementErrorCallback {
 115 public:
 116     static StatementErrorCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
 117     {
 118         return new StatementErrorCallback(requestCallback);
 119     }
 120
 121     virtual ~StatementErrorCallback() { }
 122
 123     virtual void trace(Visitor* visitor) override
 124     {
 125         visitor->trace(m_requestCallback);
 126         SQLStatementErrorCallback::trace(visitor);
 127     }
 128
 129     virtual bool handleEvent(SQLTransaction*, SQLError* error) override
 130     {
 131         reportTransactionFailed(m_requestCallback.get(), error);
 132         return true;
 133     }
 134
 135 private:
 136     StatementErrorCallback(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
 137         : m_requestCallback(requestCallback) { }
 138     RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback;
 139 };
 140
 141 class TransactionCallback final : public SQLTransactionCallback {
 142 public:
 143     static TransactionCallback* create(const String& sqlStatement, PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
 144     {
 145         return new TransactionCallback(sqlStatement, requestCallback);
 146     }
 147
 148     virtual ~TransactionCallback() { }
 149
 150     virtual void trace(Visitor* visitor) override
 151     {
 152         visitor->trace(m_requestCallback);
 153         SQLTransactionCallback::trace(visitor);
 154     }
 155
 156     virtual bool handleEvent(SQLTransaction* transaction) override
 157     {
 158         if (!m_requestCallback->isActive())
 159             return true;
 160
 161         Vector<SQLValue> sqlValues;
 162         SQLStatementCallback* callback = StatementCallback::create(m_requestCallback.get());
 163         SQLStatementErrorCallback* errorCallback = StatementErrorCallback::create(m_requestCallback.get());
 164         transaction->executeSQL(m_sqlStatement, sqlValues, callback, errorCallback, IGNORE_EXCEPTION);
 165         return true;
 166     }
 167 private:
 168     TransactionCallback(const String& sqlStatement, PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
 169         : m_sqlStatement(sqlStatement)
 170         , m_requestCallback(requestCallback) { }
 171     String m_sqlStatement;
 172     RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback;
 173 };
 174
 175 class TransactionErrorCallback final : public SQLTransactionErrorCallback {
 176 public:
 177     static TransactionErrorCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
 178     {
 179         return new TransactionErrorCallback(requestCallback);
 180     }
 181
 182     virtual ~TransactionErrorCallback() { }
 183
 184     virtual void trace(Visitor* visitor) override
 185     {
 186         visitor->trace(m_requestCallback);
 187         SQLTransactionErrorCallback::trace(visitor);
 188     }
 189
 190     virtual bool handleEvent(SQLError* error) override
 191     {
 192         reportTransactionFailed(m_requestCallback.get(), error);
 193         return true;
 194     }
 195 private:
 196     TransactionErrorCallback(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
 197         : m_requestCallback(requestCallback) { }
 198     RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback;
 199 };
 200
 201 class TransactionSuccessCallback final : public VoidCallback {
 202 public:
 203     static TransactionSuccessCallback* create()
 204     {
 205         return new TransactionSuccessCallback();
 206     }
 207
 208     virtual ~TransactionSuccessCallback() { }
 209
 210     virtual void handleEvent() override { }
 211
 212 private:
 213     TransactionSuccessCallback() { }
 214 };
 215
 216 } // namespace
 217
 218 void InspectorDatabaseAgent::didOpenDatabase(Database* database, const String& domain, const String& name, const String& version)
 219 {
 220     if (InspectorDatabaseResource* resource = findByFileName(database->fileName())) {
 221         resource->setDatabase(database);
 222         return;
 223     }
 224
 225     InspectorDatabaseResource* resource = InspectorDatabaseResource::create(database, domain, name, version);
 226     m_resources.set(resource->id(), resource);
 227     // Resources are only bound while visible.
 228     if (m_frontend && m_enabled)
 229         resource->bind(m_frontend);
 230 }
 231
 232 void InspectorDatabaseAgent::didCommitLoadForMainFrame()
 233 {
 234     m_resources.clear();
 235 }
 236
 237 InspectorDatabaseAgent::InspectorDatabaseAgent()
 238     : InspectorBaseAgent<InspectorDatabaseAgent>("Database")
 239     , m_frontend(0)
 240     , m_enabled(false)
 241 {
 242 }
 243
 244 InspectorDatabaseAgent::~InspectorDatabaseAgent()
 245 {
 246 }
 247
 248 void InspectorDatabaseAgent::setFrontend(InspectorFrontend* frontend)
 249 {
 250     m_frontend = frontend->database();
 251 }
 252
 253 void InspectorDatabaseAgent::clearFrontend()
 254 {
 255     m_frontend = 0;
 256     disable(0);
 257 }
 258
 259 void InspectorDatabaseAgent::enable(ErrorString*)
 260 {
 261     if (m_enabled)
 262         return;
 263     m_enabled = true;
 264     m_state->setBoolean(DatabaseAgentState::databaseAgentEnabled, m_enabled);
 265
 266     DatabaseResourcesHeapMap::iterator databasesEnd = m_resources.end();
 267     for (DatabaseResourcesHeapMap::iterator it = m_resources.begin(); it != databasesEnd; ++it)
 268         it->value->bind(m_frontend);
 269 }
 270
 271 void InspectorDatabaseAgent::disable(ErrorString*)
 272 {
 273     if (!m_enabled)
 274         return;
 275     m_enabled = false;
 276     m_state->setBoolean(DatabaseAgentState::databaseAgentEnabled, m_enabled);
 277 }
 278
 279 void InspectorDatabaseAgent::restore()
 280 {
 281     m_enabled = m_state->getBoolean(DatabaseAgentState::databaseAgentEnabled);
 282 }
 283
 284 void InspectorDatabaseAgent::getDatabaseTableNames(ErrorString* error, const String& databaseId, RefPtr<TypeBuilder::Array<String> >& names)
 285 {
 286     if (!m_enabled) {
 287         *error = "Database agent is not enabled";
 288         return;
 289     }
 290
 291     names = TypeBuilder::Array<String>::create();
 292
 293     Database* database = databaseForId(databaseId);
 294     if (database) {
 295         Vector<String> tableNames = database->tableNames();
 296         unsigned length = tableNames.size();
 297         for (unsigned i = 0; i < length; ++i)
 298             names->addItem(tableNames[i]);
 299     }
 300 }
 301
 302 void InspectorDatabaseAgent::executeSQL(ErrorString*, const String& databaseId, const String& query, PassRefPtrWillBeRawPtr<ExecuteSQLCallback> prpRequestCallback)
 303 {
 304     RefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback = prpRequestCallback;
 305
 306     if (!m_enabled) {
 307         requestCallback->sendFailure("Database agent is not enabled");
 308         return;
 309     }
 310
 311     Database* database = databaseForId(databaseId);
 312     if (!database) {
 313         requestCallback->sendFailure("Database not found");
 314         return;
 315     }
 316
 317     SQLTransactionCallback* callback = TransactionCallback::create(query, requestCallback.get());
 318     SQLTransactionErrorCallback* errorCallback = TransactionErrorCallback::create(requestCallback.get());
 319     VoidCallback* successCallback = TransactionSuccessCallback::create();
 320     database->transaction(callback, errorCallback, successCallback);
 321 }
 322
 323 InspectorDatabaseResource* InspectorDatabaseAgent::findByFileName(const String& fileName)
 324 {
 325     for (DatabaseResourcesHeapMap::iterator it = m_resources.begin(); it != m_resources.end(); ++it) {
 326         if (it->value->database()->fileName() == fileName)
 327             return it->value.get();
 328     }
 329     return 0;
 330 }
 331
 332 Database* InspectorDatabaseAgent::databaseForId(const String& databaseId)
 333 {
 334     DatabaseResourcesHeapMap::iterator it = m_resources.find(databaseId);
 335     if (it == m_resources.end())
 336         return 0;
 337     return it->value->database();
 338 }
 339
 340 void InspectorDatabaseAgent::trace(Visitor* visitor)
 341 {
 342 #if ENABLE(OILPAN)
 343     visitor->trace(m_resources);
 344 #endif
 345     InspectorBaseAgent::trace(visitor);
 346 }
 347
 348 } // namespace blink