OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 2010 Google Inc. All rights reserved. | 2 * Copyright (C) 2010 Google Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions | 5 * modification, are permitted provided that the following conditions |
6 * are met: | 6 * are met: |
7 * | 7 * |
8 * 1. Redistributions of source code must retain the above copyright | 8 * 1. Redistributions of source code must retain the above copyright |
9 * notice, this list of conditions and the following disclaimer. | 9 * notice, this list of conditions and the following disclaimer. |
10 * 2. Redistributions in binary form must reproduce the above copyright | 10 * 2. Redistributions in binary form must reproduce the above copyright |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
51 typedef blink::protocol::Dispatcher::DatabaseCommandHandler::ExecuteSQLCallback
ExecuteSQLCallback; | 51 typedef blink::protocol::Dispatcher::DatabaseCommandHandler::ExecuteSQLCallback
ExecuteSQLCallback; |
52 | 52 |
53 namespace blink { | 53 namespace blink { |
54 | 54 |
55 namespace DatabaseAgentState { | 55 namespace DatabaseAgentState { |
56 static const char databaseAgentEnabled[] = "databaseAgentEnabled"; | 56 static const char databaseAgentEnabled[] = "databaseAgentEnabled"; |
57 }; | 57 }; |
58 | 58 |
59 namespace { | 59 namespace { |
60 | 60 |
61 void reportTransactionFailed(ExecuteSQLCallback* requestCallback, SQLError* erro
r) | 61 class ExecuteSQLCallbackWrapper : public RefCounted<ExecuteSQLCallbackWrapper> { |
62 { | 62 public: |
63 OwnPtr<protocol::Database::Error> errorObject = protocol::Database::Error::c
reate() | 63 static PassRefPtr<ExecuteSQLCallbackWrapper> create(PassOwnPtr<ExecuteSQLCal
lback> callback) { return adoptRef(new ExecuteSQLCallbackWrapper(callback)); } |
64 .setMessage(error->message()) | 64 ~ExecuteSQLCallbackWrapper() { } |
65 .setCode(error->code()).build(); | 65 ExecuteSQLCallback* get() { return m_callback.get(); } |
66 requestCallback->sendSuccess(Maybe<protocol::Array<String>>(), Maybe<protoco
l::Array<protocol::Value>>(), errorObject.release()); | 66 |
67 } | 67 void reportTransactionFailed(SQLError* error) |
| 68 { |
| 69 OwnPtr<protocol::Database::Error> errorObject = protocol::Database::Erro
r::create() |
| 70 .setMessage(error->message()) |
| 71 .setCode(error->code()).build(); |
| 72 m_callback->sendSuccess(Maybe<protocol::Array<String>>(), Maybe<protocol
::Array<protocol::Value>>(), errorObject.release()); |
| 73 } |
| 74 |
| 75 private: |
| 76 explicit ExecuteSQLCallbackWrapper(PassOwnPtr<ExecuteSQLCallback> callback)
: m_callback(callback) { } |
| 77 OwnPtr<ExecuteSQLCallback> m_callback; |
| 78 }; |
68 | 79 |
69 class StatementCallback final : public SQLStatementCallback { | 80 class StatementCallback final : public SQLStatementCallback { |
70 public: | 81 public: |
71 static StatementCallback* create(PassRefPtr<ExecuteSQLCallback> requestCallb
ack) | 82 static StatementCallback* create(PassRefPtr<ExecuteSQLCallbackWrapper> reque
stCallback) |
72 { | 83 { |
73 return new StatementCallback(requestCallback); | 84 return new StatementCallback(requestCallback); |
74 } | 85 } |
75 | 86 |
76 ~StatementCallback() override { } | 87 ~StatementCallback() override { } |
77 | 88 |
78 DEFINE_INLINE_VIRTUAL_TRACE() | 89 DEFINE_INLINE_VIRTUAL_TRACE() |
79 { | 90 { |
80 SQLStatementCallback::trace(visitor); | 91 SQLStatementCallback::trace(visitor); |
81 } | 92 } |
(...skipping 10 matching lines...) Expand all Loading... |
92 OwnPtr<protocol::Array<protocol::Value>> values = protocol::Array<protoc
ol::Value>::create(); | 103 OwnPtr<protocol::Array<protocol::Value>> values = protocol::Array<protoc
ol::Value>::create(); |
93 const Vector<SQLValue>& data = rowList->values(); | 104 const Vector<SQLValue>& data = rowList->values(); |
94 for (size_t i = 0; i < data.size(); ++i) { | 105 for (size_t i = 0; i < data.size(); ++i) { |
95 const SQLValue& value = rowList->values()[i]; | 106 const SQLValue& value = rowList->values()[i]; |
96 switch (value.getType()) { | 107 switch (value.getType()) { |
97 case SQLValue::StringValue: values->addItem(protocol::StringValue::c
reate(value.string())); break; | 108 case SQLValue::StringValue: values->addItem(protocol::StringValue::c
reate(value.string())); break; |
98 case SQLValue::NumberValue: values->addItem(protocol::FundamentalVal
ue::create(value.number())); break; | 109 case SQLValue::NumberValue: values->addItem(protocol::FundamentalVal
ue::create(value.number())); break; |
99 case SQLValue::NullValue: values->addItem(protocol::Value::null());
break; | 110 case SQLValue::NullValue: values->addItem(protocol::Value::null());
break; |
100 } | 111 } |
101 } | 112 } |
102 m_requestCallback->sendSuccess(columnNames.release(), values.release(),
Maybe<protocol::Database::Error>()); | 113 m_requestCallback->get()->sendSuccess(columnNames.release(), values.rele
ase(), Maybe<protocol::Database::Error>()); |
103 return true; | 114 return true; |
104 } | 115 } |
105 | 116 |
106 private: | 117 private: |
107 StatementCallback(PassRefPtr<ExecuteSQLCallback> requestCallback) | 118 StatementCallback(PassRefPtr<ExecuteSQLCallbackWrapper> requestCallback) : m
_requestCallback(requestCallback) { } |
108 : m_requestCallback(requestCallback) { } | 119 RefPtr<ExecuteSQLCallbackWrapper> m_requestCallback; |
109 RefPtr<ExecuteSQLCallback> m_requestCallback; | |
110 }; | 120 }; |
111 | 121 |
112 class StatementErrorCallback final : public SQLStatementErrorCallback { | 122 class StatementErrorCallback final : public SQLStatementErrorCallback { |
113 public: | 123 public: |
114 static StatementErrorCallback* create(PassRefPtr<ExecuteSQLCallback> request
Callback) | 124 static StatementErrorCallback* create(PassRefPtr<ExecuteSQLCallbackWrapper>
requestCallback) |
115 { | 125 { |
116 return new StatementErrorCallback(requestCallback); | 126 return new StatementErrorCallback(requestCallback); |
117 } | 127 } |
118 | 128 |
119 ~StatementErrorCallback() override { } | 129 ~StatementErrorCallback() override { } |
120 | 130 |
121 DEFINE_INLINE_VIRTUAL_TRACE() | 131 DEFINE_INLINE_VIRTUAL_TRACE() |
122 { | 132 { |
123 SQLStatementErrorCallback::trace(visitor); | 133 SQLStatementErrorCallback::trace(visitor); |
124 } | 134 } |
125 | 135 |
126 bool handleEvent(SQLTransaction*, SQLError* error) override | 136 bool handleEvent(SQLTransaction*, SQLError* error) override |
127 { | 137 { |
128 reportTransactionFailed(m_requestCallback.get(), error); | 138 m_requestCallback->reportTransactionFailed(error); |
129 return true; | 139 return true; |
130 } | 140 } |
131 | 141 |
132 private: | 142 private: |
133 StatementErrorCallback(PassRefPtr<ExecuteSQLCallback> requestCallback) | 143 StatementErrorCallback(PassRefPtr<ExecuteSQLCallbackWrapper> requestCallback
) : m_requestCallback(requestCallback) { } |
134 : m_requestCallback(requestCallback) { } | 144 RefPtr<ExecuteSQLCallbackWrapper> m_requestCallback; |
135 RefPtr<ExecuteSQLCallback> m_requestCallback; | |
136 }; | 145 }; |
137 | 146 |
138 class TransactionCallback final : public SQLTransactionCallback { | 147 class TransactionCallback final : public SQLTransactionCallback { |
139 public: | 148 public: |
140 static TransactionCallback* create(const String& sqlStatement, PassRefPtr<Ex
ecuteSQLCallback> requestCallback) | 149 static TransactionCallback* create(const String& sqlStatement, PassRefPtr<Ex
ecuteSQLCallbackWrapper> requestCallback) |
141 { | 150 { |
142 return new TransactionCallback(sqlStatement, requestCallback); | 151 return new TransactionCallback(sqlStatement, requestCallback); |
143 } | 152 } |
144 | 153 |
145 ~TransactionCallback() override { } | 154 ~TransactionCallback() override { } |
146 | 155 |
147 DEFINE_INLINE_VIRTUAL_TRACE() | 156 DEFINE_INLINE_VIRTUAL_TRACE() |
148 { | 157 { |
149 SQLTransactionCallback::trace(visitor); | 158 SQLTransactionCallback::trace(visitor); |
150 } | 159 } |
151 | 160 |
152 bool handleEvent(SQLTransaction* transaction) override | 161 bool handleEvent(SQLTransaction* transaction) override |
153 { | 162 { |
154 if (!m_requestCallback->isActive()) | |
155 return true; | |
156 | |
157 Vector<SQLValue> sqlValues; | 163 Vector<SQLValue> sqlValues; |
158 SQLStatementCallback* callback = StatementCallback::create(m_requestCall
back.get()); | 164 SQLStatementCallback* callback = StatementCallback::create(m_requestCall
back); |
159 SQLStatementErrorCallback* errorCallback = StatementErrorCallback::creat
e(m_requestCallback.get()); | 165 SQLStatementErrorCallback* errorCallback = StatementErrorCallback::creat
e(m_requestCallback); |
160 transaction->executeSQL(m_sqlStatement, sqlValues, callback, errorCallba
ck, IGNORE_EXCEPTION); | 166 transaction->executeSQL(m_sqlStatement, sqlValues, callback, errorCallba
ck, IGNORE_EXCEPTION); |
161 return true; | 167 return true; |
162 } | 168 } |
163 private: | 169 private: |
164 TransactionCallback(const String& sqlStatement, PassRefPtr<ExecuteSQLCallbac
k> requestCallback) | 170 TransactionCallback(const String& sqlStatement, PassRefPtr<ExecuteSQLCallbac
kWrapper> requestCallback) |
165 : m_sqlStatement(sqlStatement) | 171 : m_sqlStatement(sqlStatement) |
166 , m_requestCallback(requestCallback) { } | 172 , m_requestCallback(requestCallback) { } |
167 String m_sqlStatement; | 173 String m_sqlStatement; |
168 RefPtr<ExecuteSQLCallback> m_requestCallback; | 174 RefPtr<ExecuteSQLCallbackWrapper> m_requestCallback; |
169 }; | 175 }; |
170 | 176 |
171 class TransactionErrorCallback final : public SQLTransactionErrorCallback { | 177 class TransactionErrorCallback final : public SQLTransactionErrorCallback { |
172 public: | 178 public: |
173 static TransactionErrorCallback* create(PassRefPtr<ExecuteSQLCallback> reque
stCallback) | 179 static TransactionErrorCallback* create(PassRefPtr<ExecuteSQLCallbackWrapper
> requestCallback) |
174 { | 180 { |
175 return new TransactionErrorCallback(requestCallback); | 181 return new TransactionErrorCallback(requestCallback); |
176 } | 182 } |
177 | 183 |
178 ~TransactionErrorCallback() override { } | 184 ~TransactionErrorCallback() override { } |
179 | 185 |
180 DEFINE_INLINE_VIRTUAL_TRACE() | 186 DEFINE_INLINE_VIRTUAL_TRACE() |
181 { | 187 { |
182 SQLTransactionErrorCallback::trace(visitor); | 188 SQLTransactionErrorCallback::trace(visitor); |
183 } | 189 } |
184 | 190 |
185 bool handleEvent(SQLError* error) override | 191 bool handleEvent(SQLError* error) override |
186 { | 192 { |
187 reportTransactionFailed(m_requestCallback.get(), error); | 193 m_requestCallback->reportTransactionFailed(error); |
188 return true; | 194 return true; |
189 } | 195 } |
190 private: | 196 private: |
191 TransactionErrorCallback(PassRefPtr<ExecuteSQLCallback> requestCallback) | 197 TransactionErrorCallback(PassRefPtr<ExecuteSQLCallbackWrapper> requestCallba
ck) |
192 : m_requestCallback(requestCallback) { } | 198 : m_requestCallback(requestCallback) { } |
193 RefPtr<ExecuteSQLCallback> m_requestCallback; | 199 RefPtr<ExecuteSQLCallbackWrapper> m_requestCallback; |
194 }; | 200 }; |
195 | 201 |
196 class TransactionSuccessCallback final : public VoidCallback { | 202 class TransactionSuccessCallback final : public VoidCallback { |
197 public: | 203 public: |
198 static TransactionSuccessCallback* create() | 204 static TransactionSuccessCallback* create() |
199 { | 205 { |
200 return new TransactionSuccessCallback(); | 206 return new TransactionSuccessCallback(); |
201 } | 207 } |
202 | 208 |
203 ~TransactionSuccessCallback() override { } | 209 ~TransactionSuccessCallback() override { } |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
281 | 287 |
282 Database* database = databaseForId(databaseId); | 288 Database* database = databaseForId(databaseId); |
283 if (database) { | 289 if (database) { |
284 Vector<String> tableNames = database->tableNames(); | 290 Vector<String> tableNames = database->tableNames(); |
285 unsigned length = tableNames.size(); | 291 unsigned length = tableNames.size(); |
286 for (unsigned i = 0; i < length; ++i) | 292 for (unsigned i = 0; i < length; ++i) |
287 (*names)->addItem(tableNames[i]); | 293 (*names)->addItem(tableNames[i]); |
288 } | 294 } |
289 } | 295 } |
290 | 296 |
291 void InspectorDatabaseAgent::executeSQL(ErrorString*, const String& databaseId,
const String& query, PassRefPtr<ExecuteSQLCallback> prpRequestCallback) | 297 void InspectorDatabaseAgent::executeSQL(ErrorString*, const String& databaseId,
const String& query, PassOwnPtr<ExecuteSQLCallback> prpRequestCallback) |
292 { | 298 { |
293 RefPtr<ExecuteSQLCallback> requestCallback = prpRequestCallback; | 299 OwnPtr<ExecuteSQLCallback> requestCallback = prpRequestCallback; |
294 | 300 |
295 if (!m_enabled) { | 301 if (!m_enabled) { |
296 requestCallback->sendFailure("Database agent is not enabled"); | 302 requestCallback->sendFailure("Database agent is not enabled"); |
297 return; | 303 return; |
298 } | 304 } |
299 | 305 |
300 Database* database = databaseForId(databaseId); | 306 Database* database = databaseForId(databaseId); |
301 if (!database) { | 307 if (!database) { |
302 requestCallback->sendFailure("Database not found"); | 308 requestCallback->sendFailure("Database not found"); |
303 return; | 309 return; |
304 } | 310 } |
305 | 311 |
306 SQLTransactionCallback* callback = TransactionCallback::create(query, reques
tCallback.get()); | 312 RefPtr<ExecuteSQLCallbackWrapper> wrapper = ExecuteSQLCallbackWrapper::creat
e(requestCallback.release()); |
307 SQLTransactionErrorCallback* errorCallback = TransactionErrorCallback::creat
e(requestCallback.get()); | 313 SQLTransactionCallback* callback = TransactionCallback::create(query, wrappe
r); |
| 314 SQLTransactionErrorCallback* errorCallback = TransactionErrorCallback::creat
e(wrapper); |
308 VoidCallback* successCallback = TransactionSuccessCallback::create(); | 315 VoidCallback* successCallback = TransactionSuccessCallback::create(); |
309 database->transaction(callback, errorCallback, successCallback); | 316 database->transaction(callback, errorCallback, successCallback); |
310 } | 317 } |
311 | 318 |
312 InspectorDatabaseResource* InspectorDatabaseAgent::findByFileName(const String&
fileName) | 319 InspectorDatabaseResource* InspectorDatabaseAgent::findByFileName(const String&
fileName) |
313 { | 320 { |
314 for (DatabaseResourcesHeapMap::iterator it = m_resources.begin(); it != m_re
sources.end(); ++it) { | 321 for (DatabaseResourcesHeapMap::iterator it = m_resources.begin(); it != m_re
sources.end(); ++it) { |
315 if (it->value->database()->fileName() == fileName) | 322 if (it->value->database()->fileName() == fileName) |
316 return it->value.get(); | 323 return it->value.get(); |
317 } | 324 } |
318 return 0; | 325 return 0; |
319 } | 326 } |
320 | 327 |
321 Database* InspectorDatabaseAgent::databaseForId(const String& databaseId) | 328 Database* InspectorDatabaseAgent::databaseForId(const String& databaseId) |
322 { | 329 { |
323 DatabaseResourcesHeapMap::iterator it = m_resources.find(databaseId); | 330 DatabaseResourcesHeapMap::iterator it = m_resources.find(databaseId); |
324 if (it == m_resources.end()) | 331 if (it == m_resources.end()) |
325 return 0; | 332 return 0; |
326 return it->value->database(); | 333 return it->value->database(); |
327 } | 334 } |
328 | 335 |
329 DEFINE_TRACE(InspectorDatabaseAgent) | 336 DEFINE_TRACE(InspectorDatabaseAgent) |
330 { | 337 { |
331 visitor->trace(m_page); | 338 visitor->trace(m_page); |
332 visitor->trace(m_resources); | 339 visitor->trace(m_resources); |
333 InspectorBaseAgent::trace(visitor); | 340 InspectorBaseAgent::trace(visitor); |
334 } | 341 } |
335 | 342 |
336 } // namespace blink | 343 } // namespace blink |
OLD | NEW |