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 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
60 namespace { | 60 namespace { |
61 | 61 |
62 void reportTransactionFailed(ExecuteSQLCallback* requestCallback, SQLError* erro
r) | 62 void reportTransactionFailed(ExecuteSQLCallback* requestCallback, SQLError* erro
r) |
63 { | 63 { |
64 RefPtr<TypeBuilder::Database::Error> errorObject = TypeBuilder::Database::Er
ror::create() | 64 RefPtr<TypeBuilder::Database::Error> errorObject = TypeBuilder::Database::Er
ror::create() |
65 .setMessage(error->message()) | 65 .setMessage(error->message()) |
66 .setCode(error->code()); | 66 .setCode(error->code()); |
67 requestCallback->sendSuccess(nullptr, nullptr, errorObject.release()); | 67 requestCallback->sendSuccess(nullptr, nullptr, errorObject.release()); |
68 } | 68 } |
69 | 69 |
70 class StatementCallback FINAL : public SQLStatementCallback { | 70 class StatementCallback final : public SQLStatementCallback { |
71 public: | 71 public: |
72 static StatementCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback>
requestCallback) | 72 static StatementCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback>
requestCallback) |
73 { | 73 { |
74 return new StatementCallback(requestCallback); | 74 return new StatementCallback(requestCallback); |
75 } | 75 } |
76 | 76 |
77 virtual ~StatementCallback() { } | 77 virtual ~StatementCallback() { } |
78 | 78 |
79 virtual void trace(Visitor* visitor) | 79 virtual void trace(Visitor* visitor) |
80 { | 80 { |
81 visitor->trace(m_requestCallback); | 81 visitor->trace(m_requestCallback); |
82 SQLStatementCallback::trace(visitor); | 82 SQLStatementCallback::trace(visitor); |
83 } | 83 } |
84 | 84 |
85 virtual bool handleEvent(SQLTransaction*, SQLResultSet* resultSet) OVERRIDE | 85 virtual bool handleEvent(SQLTransaction*, SQLResultSet* resultSet) override |
86 { | 86 { |
87 SQLResultSetRowList* rowList = resultSet->rows(); | 87 SQLResultSetRowList* rowList = resultSet->rows(); |
88 | 88 |
89 RefPtr<TypeBuilder::Array<String> > columnNames = TypeBuilder::Array<Str
ing>::create(); | 89 RefPtr<TypeBuilder::Array<String> > columnNames = TypeBuilder::Array<Str
ing>::create(); |
90 const Vector<String>& columns = rowList->columnNames(); | 90 const Vector<String>& columns = rowList->columnNames(); |
91 for (size_t i = 0; i < columns.size(); ++i) | 91 for (size_t i = 0; i < columns.size(); ++i) |
92 columnNames->addItem(columns[i]); | 92 columnNames->addItem(columns[i]); |
93 | 93 |
94 RefPtr<TypeBuilder::Array<JSONValue> > values = TypeBuilder::Array<JSONV
alue>::create(); | 94 RefPtr<TypeBuilder::Array<JSONValue> > values = TypeBuilder::Array<JSONV
alue>::create(); |
95 const Vector<SQLValue>& data = rowList->values(); | 95 const Vector<SQLValue>& data = rowList->values(); |
96 for (size_t i = 0; i < data.size(); ++i) { | 96 for (size_t i = 0; i < data.size(); ++i) { |
97 const SQLValue& value = rowList->values()[i]; | 97 const SQLValue& value = rowList->values()[i]; |
98 switch (value.type()) { | 98 switch (value.type()) { |
99 case SQLValue::StringValue: values->addItem(JSONString::create(value
.string())); break; | 99 case SQLValue::StringValue: values->addItem(JSONString::create(value
.string())); break; |
100 case SQLValue::NumberValue: values->addItem(JSONBasicValue::create(v
alue.number())); break; | 100 case SQLValue::NumberValue: values->addItem(JSONBasicValue::create(v
alue.number())); break; |
101 case SQLValue::NullValue: values->addItem(JSONValue::null()); break; | 101 case SQLValue::NullValue: values->addItem(JSONValue::null()); break; |
102 } | 102 } |
103 } | 103 } |
104 m_requestCallback->sendSuccess(columnNames.release(), values.release(),
nullptr); | 104 m_requestCallback->sendSuccess(columnNames.release(), values.release(),
nullptr); |
105 return true; | 105 return true; |
106 } | 106 } |
107 | 107 |
108 private: | 108 private: |
109 StatementCallback(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback
) | 109 StatementCallback(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback
) |
110 : m_requestCallback(requestCallback) { } | 110 : m_requestCallback(requestCallback) { } |
111 RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback; | 111 RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback; |
112 }; | 112 }; |
113 | 113 |
114 class StatementErrorCallback FINAL : public SQLStatementErrorCallback { | 114 class StatementErrorCallback final : public SQLStatementErrorCallback { |
115 public: | 115 public: |
116 static StatementErrorCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCallb
ack> requestCallback) | 116 static StatementErrorCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCallb
ack> requestCallback) |
117 { | 117 { |
118 return new StatementErrorCallback(requestCallback); | 118 return new StatementErrorCallback(requestCallback); |
119 } | 119 } |
120 | 120 |
121 virtual ~StatementErrorCallback() { } | 121 virtual ~StatementErrorCallback() { } |
122 | 122 |
123 virtual void trace(Visitor* visitor) OVERRIDE | 123 virtual void trace(Visitor* visitor) override |
124 { | 124 { |
125 visitor->trace(m_requestCallback); | 125 visitor->trace(m_requestCallback); |
126 SQLStatementErrorCallback::trace(visitor); | 126 SQLStatementErrorCallback::trace(visitor); |
127 } | 127 } |
128 | 128 |
129 virtual bool handleEvent(SQLTransaction*, SQLError* error) OVERRIDE | 129 virtual bool handleEvent(SQLTransaction*, SQLError* error) override |
130 { | 130 { |
131 reportTransactionFailed(m_requestCallback.get(), error); | 131 reportTransactionFailed(m_requestCallback.get(), error); |
132 return true; | 132 return true; |
133 } | 133 } |
134 | 134 |
135 private: | 135 private: |
136 StatementErrorCallback(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCal
lback) | 136 StatementErrorCallback(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCal
lback) |
137 : m_requestCallback(requestCallback) { } | 137 : m_requestCallback(requestCallback) { } |
138 RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback; | 138 RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback; |
139 }; | 139 }; |
140 | 140 |
141 class TransactionCallback FINAL : public SQLTransactionCallback { | 141 class TransactionCallback final : public SQLTransactionCallback { |
142 public: | 142 public: |
143 static TransactionCallback* create(const String& sqlStatement, PassRefPtrWil
lBeRawPtr<ExecuteSQLCallback> requestCallback) | 143 static TransactionCallback* create(const String& sqlStatement, PassRefPtrWil
lBeRawPtr<ExecuteSQLCallback> requestCallback) |
144 { | 144 { |
145 return new TransactionCallback(sqlStatement, requestCallback); | 145 return new TransactionCallback(sqlStatement, requestCallback); |
146 } | 146 } |
147 | 147 |
148 virtual ~TransactionCallback() { } | 148 virtual ~TransactionCallback() { } |
149 | 149 |
150 virtual void trace(Visitor* visitor) OVERRIDE | 150 virtual void trace(Visitor* visitor) override |
151 { | 151 { |
152 visitor->trace(m_requestCallback); | 152 visitor->trace(m_requestCallback); |
153 SQLTransactionCallback::trace(visitor); | 153 SQLTransactionCallback::trace(visitor); |
154 } | 154 } |
155 | 155 |
156 virtual bool handleEvent(SQLTransaction* transaction) OVERRIDE | 156 virtual bool handleEvent(SQLTransaction* transaction) override |
157 { | 157 { |
158 if (!m_requestCallback->isActive()) | 158 if (!m_requestCallback->isActive()) |
159 return true; | 159 return true; |
160 | 160 |
161 Vector<SQLValue> sqlValues; | 161 Vector<SQLValue> sqlValues; |
162 SQLStatementCallback* callback = StatementCallback::create(m_requestCall
back.get()); | 162 SQLStatementCallback* callback = StatementCallback::create(m_requestCall
back.get()); |
163 SQLStatementErrorCallback* errorCallback = StatementErrorCallback::creat
e(m_requestCallback.get()); | 163 SQLStatementErrorCallback* errorCallback = StatementErrorCallback::creat
e(m_requestCallback.get()); |
164 transaction->executeSQL(m_sqlStatement, sqlValues, callback, errorCallba
ck, IGNORE_EXCEPTION); | 164 transaction->executeSQL(m_sqlStatement, sqlValues, callback, errorCallba
ck, IGNORE_EXCEPTION); |
165 return true; | 165 return true; |
166 } | 166 } |
167 private: | 167 private: |
168 TransactionCallback(const String& sqlStatement, PassRefPtrWillBeRawPtr<Execu
teSQLCallback> requestCallback) | 168 TransactionCallback(const String& sqlStatement, PassRefPtrWillBeRawPtr<Execu
teSQLCallback> requestCallback) |
169 : m_sqlStatement(sqlStatement) | 169 : m_sqlStatement(sqlStatement) |
170 , m_requestCallback(requestCallback) { } | 170 , m_requestCallback(requestCallback) { } |
171 String m_sqlStatement; | 171 String m_sqlStatement; |
172 RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback; | 172 RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback; |
173 }; | 173 }; |
174 | 174 |
175 class TransactionErrorCallback FINAL : public SQLTransactionErrorCallback { | 175 class TransactionErrorCallback final : public SQLTransactionErrorCallback { |
176 public: | 176 public: |
177 static TransactionErrorCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCal
lback> requestCallback) | 177 static TransactionErrorCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCal
lback> requestCallback) |
178 { | 178 { |
179 return new TransactionErrorCallback(requestCallback); | 179 return new TransactionErrorCallback(requestCallback); |
180 } | 180 } |
181 | 181 |
182 virtual ~TransactionErrorCallback() { } | 182 virtual ~TransactionErrorCallback() { } |
183 | 183 |
184 virtual void trace(Visitor* visitor) OVERRIDE | 184 virtual void trace(Visitor* visitor) override |
185 { | 185 { |
186 visitor->trace(m_requestCallback); | 186 visitor->trace(m_requestCallback); |
187 SQLTransactionErrorCallback::trace(visitor); | 187 SQLTransactionErrorCallback::trace(visitor); |
188 } | 188 } |
189 | 189 |
190 virtual bool handleEvent(SQLError* error) OVERRIDE | 190 virtual bool handleEvent(SQLError* error) override |
191 { | 191 { |
192 reportTransactionFailed(m_requestCallback.get(), error); | 192 reportTransactionFailed(m_requestCallback.get(), error); |
193 return true; | 193 return true; |
194 } | 194 } |
195 private: | 195 private: |
196 TransactionErrorCallback(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestC
allback) | 196 TransactionErrorCallback(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestC
allback) |
197 : m_requestCallback(requestCallback) { } | 197 : m_requestCallback(requestCallback) { } |
198 RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback; | 198 RefPtrWillBeMember<ExecuteSQLCallback> m_requestCallback; |
199 }; | 199 }; |
200 | 200 |
201 class TransactionSuccessCallback FINAL : public VoidCallback { | 201 class TransactionSuccessCallback final : public VoidCallback { |
202 public: | 202 public: |
203 static TransactionSuccessCallback* create() | 203 static TransactionSuccessCallback* create() |
204 { | 204 { |
205 return new TransactionSuccessCallback(); | 205 return new TransactionSuccessCallback(); |
206 } | 206 } |
207 | 207 |
208 virtual ~TransactionSuccessCallback() { } | 208 virtual ~TransactionSuccessCallback() { } |
209 | 209 |
210 virtual void handleEvent() OVERRIDE { } | 210 virtual void handleEvent() override { } |
211 | 211 |
212 private: | 212 private: |
213 TransactionSuccessCallback() { } | 213 TransactionSuccessCallback() { } |
214 }; | 214 }; |
215 | 215 |
216 } // namespace | 216 } // namespace |
217 | 217 |
218 void InspectorDatabaseAgent::didOpenDatabase(Database* database, const String& d
omain, const String& name, const String& version) | 218 void InspectorDatabaseAgent::didOpenDatabase(Database* database, const String& d
omain, const String& name, const String& version) |
219 { | 219 { |
220 if (InspectorDatabaseResource* resource = findByFileName(database->fileName(
))) { | 220 if (InspectorDatabaseResource* resource = findByFileName(database->fileName(
))) { |
(...skipping 118 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
339 | 339 |
340 void InspectorDatabaseAgent::trace(Visitor* visitor) | 340 void InspectorDatabaseAgent::trace(Visitor* visitor) |
341 { | 341 { |
342 #if ENABLE(OILPAN) | 342 #if ENABLE(OILPAN) |
343 visitor->trace(m_resources); | 343 visitor->trace(m_resources); |
344 #endif | 344 #endif |
345 InspectorBaseAgent::trace(visitor); | 345 InspectorBaseAgent::trace(visitor); |
346 } | 346 } |
347 | 347 |
348 } // namespace blink | 348 } // namespace blink |
OLD | NEW |