OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/indexed_db/indexed_db_transaction.h" | 5 #include "content/browser/indexed_db/indexed_db_transaction.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/logging.h" | 8 #include "base/logging.h" |
9 #include "base/message_loop/message_loop.h" | 9 #include "base/message_loop/message_loop.h" |
10 #include "base/strings/utf_string_conversions.h" | 10 #include "base/strings/utf_string_conversions.h" |
(...skipping 25 matching lines...) Expand all Loading... |
36 backing_store_ = new IndexedDBFakeBackingStore(); | 36 backing_store_ = new IndexedDBFakeBackingStore(); |
37 CreateDB(); | 37 CreateDB(); |
38 } | 38 } |
39 | 39 |
40 void CreateDB() { | 40 void CreateDB() { |
41 // DB is created here instead of the constructor to workaround a | 41 // DB is created here instead of the constructor to workaround a |
42 // "peculiarity of C++". More info at | 42 // "peculiarity of C++". More info at |
43 // https://code.google.com/p/googletest/wiki/FAQ#My_compiler_complains_that_
a_constructor_(or_destructor)_cannot | 43 // https://code.google.com/p/googletest/wiki/FAQ#My_compiler_complains_that_
a_constructor_(or_destructor)_cannot |
44 leveldb::Status s; | 44 leveldb::Status s; |
45 db_ = IndexedDBDatabase::Create(base::ASCIIToUTF16("db"), | 45 db_ = IndexedDBDatabase::Create(base::ASCIIToUTF16("db"), |
46 backing_store_, | 46 backing_store_.get(), |
47 factory_, | 47 factory_.get(), |
48 IndexedDBDatabase::Identifier(), | 48 IndexedDBDatabase::Identifier(), |
49 &s); | 49 &s); |
50 ASSERT_TRUE(s.ok()); | 50 ASSERT_TRUE(s.ok()); |
51 } | 51 } |
52 | 52 |
53 void RunPostedTasks() { message_loop_.RunUntilIdle(); } | 53 void RunPostedTasks() { message_loop_.RunUntilIdle(); } |
54 void DummyOperation(IndexedDBTransaction* transaction) {} | 54 void DummyOperation(IndexedDBTransaction* transaction) {} |
55 void AbortableOperation(AbortObserver* observer, | 55 void AbortableOperation(AbortObserver* observer, |
56 IndexedDBTransaction* transaction) { | 56 IndexedDBTransaction* transaction) { |
57 transaction->ScheduleAbortTask( | 57 transaction->ScheduleAbortTask( |
(...skipping 22 matching lines...) Expand all Loading... |
80 | 80 |
81 TEST_F(IndexedDBTransactionTest, Timeout) { | 81 TEST_F(IndexedDBTransactionTest, Timeout) { |
82 const int64 id = 0; | 82 const int64 id = 0; |
83 const std::set<int64> scope; | 83 const std::set<int64> scope; |
84 const leveldb::Status commit_success = leveldb::Status::OK(); | 84 const leveldb::Status commit_success = leveldb::Status::OK(); |
85 scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction( | 85 scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction( |
86 id, | 86 id, |
87 new MockIndexedDBDatabaseCallbacks(), | 87 new MockIndexedDBDatabaseCallbacks(), |
88 scope, | 88 scope, |
89 blink::WebIDBTransactionModeReadWrite, | 89 blink::WebIDBTransactionModeReadWrite, |
90 db_, | 90 db_.get(), |
91 new IndexedDBFakeBackingStore::FakeTransaction(commit_success)); | 91 new IndexedDBFakeBackingStore::FakeTransaction(commit_success)); |
92 db_->TransactionCreated(transaction); | 92 db_->TransactionCreated(transaction.get()); |
93 | 93 |
94 // No conflicting transactions, so coordinator will start it immediately: | 94 // No conflicting transactions, so coordinator will start it immediately: |
95 EXPECT_EQ(IndexedDBTransaction::STARTED, transaction->state()); | 95 EXPECT_EQ(IndexedDBTransaction::STARTED, transaction->state()); |
96 EXPECT_FALSE(transaction->IsTimeoutTimerRunning()); | 96 EXPECT_FALSE(transaction->IsTimeoutTimerRunning()); |
97 EXPECT_EQ(0, transaction->diagnostics().tasks_scheduled); | 97 EXPECT_EQ(0, transaction->diagnostics().tasks_scheduled); |
98 EXPECT_EQ(0, transaction->diagnostics().tasks_completed); | 98 EXPECT_EQ(0, transaction->diagnostics().tasks_completed); |
99 | 99 |
100 // Schedule a task - timer won't be started until it's processed. | 100 // Schedule a task - timer won't be started until it's processed. |
101 transaction->ScheduleTask(base::Bind( | 101 transaction->ScheduleTask(base::Bind( |
102 &IndexedDBTransactionTest::DummyOperation, base::Unretained(this))); | 102 &IndexedDBTransactionTest::DummyOperation, base::Unretained(this))); |
(...skipping 21 matching lines...) Expand all Loading... |
124 | 124 |
125 TEST_F(IndexedDBTransactionTest, NoTimeoutReadOnly) { | 125 TEST_F(IndexedDBTransactionTest, NoTimeoutReadOnly) { |
126 const int64 id = 0; | 126 const int64 id = 0; |
127 const std::set<int64> scope; | 127 const std::set<int64> scope; |
128 const leveldb::Status commit_success = leveldb::Status::OK(); | 128 const leveldb::Status commit_success = leveldb::Status::OK(); |
129 scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction( | 129 scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction( |
130 id, | 130 id, |
131 new MockIndexedDBDatabaseCallbacks(), | 131 new MockIndexedDBDatabaseCallbacks(), |
132 scope, | 132 scope, |
133 blink::WebIDBTransactionModeReadOnly, | 133 blink::WebIDBTransactionModeReadOnly, |
134 db_, | 134 db_.get(), |
135 new IndexedDBFakeBackingStore::FakeTransaction(commit_success)); | 135 new IndexedDBFakeBackingStore::FakeTransaction(commit_success)); |
136 db_->TransactionCreated(transaction); | 136 db_->TransactionCreated(transaction.get()); |
137 | 137 |
138 // No conflicting transactions, so coordinator will start it immediately: | 138 // No conflicting transactions, so coordinator will start it immediately: |
139 EXPECT_EQ(IndexedDBTransaction::STARTED, transaction->state()); | 139 EXPECT_EQ(IndexedDBTransaction::STARTED, transaction->state()); |
140 EXPECT_FALSE(transaction->IsTimeoutTimerRunning()); | 140 EXPECT_FALSE(transaction->IsTimeoutTimerRunning()); |
141 | 141 |
142 // Schedule a task - timer won't be started until it's processed. | 142 // Schedule a task - timer won't be started until it's processed. |
143 transaction->ScheduleTask(base::Bind( | 143 transaction->ScheduleTask(base::Bind( |
144 &IndexedDBTransactionTest::DummyOperation, base::Unretained(this))); | 144 &IndexedDBTransactionTest::DummyOperation, base::Unretained(this))); |
145 EXPECT_FALSE(transaction->IsTimeoutTimerRunning()); | 145 EXPECT_FALSE(transaction->IsTimeoutTimerRunning()); |
146 | 146 |
147 // Transaction is read-only, so no need to time it out. | 147 // Transaction is read-only, so no need to time it out. |
148 RunPostedTasks(); | 148 RunPostedTasks(); |
149 EXPECT_FALSE(transaction->IsTimeoutTimerRunning()); | 149 EXPECT_FALSE(transaction->IsTimeoutTimerRunning()); |
150 | 150 |
151 // Clean up to avoid leaks. | 151 // Clean up to avoid leaks. |
152 transaction->Abort(); | 152 transaction->Abort(); |
153 EXPECT_EQ(IndexedDBTransaction::FINISHED, transaction->state()); | 153 EXPECT_EQ(IndexedDBTransaction::FINISHED, transaction->state()); |
154 EXPECT_FALSE(transaction->IsTimeoutTimerRunning()); | 154 EXPECT_FALSE(transaction->IsTimeoutTimerRunning()); |
155 } | 155 } |
156 | 156 |
157 TEST_P(IndexedDBTransactionTestMode, ScheduleNormalTask) { | 157 TEST_P(IndexedDBTransactionTestMode, ScheduleNormalTask) { |
158 const int64 id = 0; | 158 const int64 id = 0; |
159 const std::set<int64> scope; | 159 const std::set<int64> scope; |
160 const leveldb::Status commit_success = leveldb::Status::OK(); | 160 const leveldb::Status commit_success = leveldb::Status::OK(); |
161 scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction( | 161 scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction( |
162 id, | 162 id, |
163 new MockIndexedDBDatabaseCallbacks(), | 163 new MockIndexedDBDatabaseCallbacks(), |
164 scope, | 164 scope, |
165 GetParam(), | 165 GetParam(), |
166 db_, | 166 db_.get(), |
167 new IndexedDBFakeBackingStore::FakeTransaction(commit_success)); | 167 new IndexedDBFakeBackingStore::FakeTransaction(commit_success)); |
168 | 168 |
169 EXPECT_FALSE(transaction->HasPendingTasks()); | 169 EXPECT_FALSE(transaction->HasPendingTasks()); |
170 EXPECT_TRUE(transaction->IsTaskQueueEmpty()); | 170 EXPECT_TRUE(transaction->IsTaskQueueEmpty()); |
171 EXPECT_TRUE(transaction->task_queue_.empty()); | 171 EXPECT_TRUE(transaction->task_queue_.empty()); |
172 EXPECT_TRUE(transaction->preemptive_task_queue_.empty()); | 172 EXPECT_TRUE(transaction->preemptive_task_queue_.empty()); |
173 EXPECT_EQ(0, transaction->diagnostics().tasks_scheduled); | 173 EXPECT_EQ(0, transaction->diagnostics().tasks_scheduled); |
174 EXPECT_EQ(0, transaction->diagnostics().tasks_completed); | 174 EXPECT_EQ(0, transaction->diagnostics().tasks_completed); |
175 | 175 |
176 db_->TransactionCreated(transaction); | 176 db_->TransactionCreated(transaction.get()); |
177 | 177 |
178 EXPECT_FALSE(transaction->HasPendingTasks()); | 178 EXPECT_FALSE(transaction->HasPendingTasks()); |
179 EXPECT_TRUE(transaction->IsTaskQueueEmpty()); | 179 EXPECT_TRUE(transaction->IsTaskQueueEmpty()); |
180 EXPECT_TRUE(transaction->task_queue_.empty()); | 180 EXPECT_TRUE(transaction->task_queue_.empty()); |
181 EXPECT_TRUE(transaction->preemptive_task_queue_.empty()); | 181 EXPECT_TRUE(transaction->preemptive_task_queue_.empty()); |
182 | 182 |
183 transaction->ScheduleTask( | 183 transaction->ScheduleTask( |
184 blink::WebIDBTaskTypeNormal, | 184 blink::WebIDBTaskTypeNormal, |
185 base::Bind(&IndexedDBTransactionTest::DummyOperation, | 185 base::Bind(&IndexedDBTransactionTest::DummyOperation, |
186 base::Unretained(this))); | 186 base::Unretained(this))); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
218 | 218 |
219 TEST_F(IndexedDBTransactionTest, SchedulePreemptiveTask) { | 219 TEST_F(IndexedDBTransactionTest, SchedulePreemptiveTask) { |
220 const int64 id = 0; | 220 const int64 id = 0; |
221 const std::set<int64> scope; | 221 const std::set<int64> scope; |
222 const leveldb::Status commit_failure = leveldb::Status::Corruption("Ouch."); | 222 const leveldb::Status commit_failure = leveldb::Status::Corruption("Ouch."); |
223 scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction( | 223 scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction( |
224 id, | 224 id, |
225 new MockIndexedDBDatabaseCallbacks(), | 225 new MockIndexedDBDatabaseCallbacks(), |
226 scope, | 226 scope, |
227 blink::WebIDBTransactionModeVersionChange, | 227 blink::WebIDBTransactionModeVersionChange, |
228 db_, | 228 db_.get(), |
229 new IndexedDBFakeBackingStore::FakeTransaction(commit_failure)); | 229 new IndexedDBFakeBackingStore::FakeTransaction(commit_failure)); |
230 | 230 |
231 EXPECT_FALSE(transaction->HasPendingTasks()); | 231 EXPECT_FALSE(transaction->HasPendingTasks()); |
232 EXPECT_TRUE(transaction->IsTaskQueueEmpty()); | 232 EXPECT_TRUE(transaction->IsTaskQueueEmpty()); |
233 EXPECT_TRUE(transaction->task_queue_.empty()); | 233 EXPECT_TRUE(transaction->task_queue_.empty()); |
234 EXPECT_TRUE(transaction->preemptive_task_queue_.empty()); | 234 EXPECT_TRUE(transaction->preemptive_task_queue_.empty()); |
235 EXPECT_EQ(0, transaction->diagnostics().tasks_scheduled); | 235 EXPECT_EQ(0, transaction->diagnostics().tasks_scheduled); |
236 EXPECT_EQ(0, transaction->diagnostics().tasks_completed); | 236 EXPECT_EQ(0, transaction->diagnostics().tasks_completed); |
237 | 237 |
238 db_->TransactionCreated(transaction); | 238 db_->TransactionCreated(transaction.get()); |
239 | 239 |
240 EXPECT_FALSE(transaction->HasPendingTasks()); | 240 EXPECT_FALSE(transaction->HasPendingTasks()); |
241 EXPECT_TRUE(transaction->IsTaskQueueEmpty()); | 241 EXPECT_TRUE(transaction->IsTaskQueueEmpty()); |
242 EXPECT_TRUE(transaction->task_queue_.empty()); | 242 EXPECT_TRUE(transaction->task_queue_.empty()); |
243 EXPECT_TRUE(transaction->preemptive_task_queue_.empty()); | 243 EXPECT_TRUE(transaction->preemptive_task_queue_.empty()); |
244 | 244 |
245 transaction->ScheduleTask( | 245 transaction->ScheduleTask( |
246 blink::WebIDBTaskTypePreemptive, | 246 blink::WebIDBTaskTypePreemptive, |
247 base::Bind(&IndexedDBTransactionTest::DummyOperation, | 247 base::Bind(&IndexedDBTransactionTest::DummyOperation, |
248 base::Unretained(this))); | 248 base::Unretained(this))); |
(...skipping 30 matching lines...) Expand all Loading... |
279 | 279 |
280 TEST_P(IndexedDBTransactionTestMode, AbortTasks) { | 280 TEST_P(IndexedDBTransactionTestMode, AbortTasks) { |
281 const int64 id = 0; | 281 const int64 id = 0; |
282 const std::set<int64> scope; | 282 const std::set<int64> scope; |
283 const leveldb::Status commit_failure = leveldb::Status::Corruption("Ouch."); | 283 const leveldb::Status commit_failure = leveldb::Status::Corruption("Ouch."); |
284 scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction( | 284 scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction( |
285 id, | 285 id, |
286 new MockIndexedDBDatabaseCallbacks(), | 286 new MockIndexedDBDatabaseCallbacks(), |
287 scope, | 287 scope, |
288 GetParam(), | 288 GetParam(), |
289 db_, | 289 db_.get(), |
290 new IndexedDBFakeBackingStore::FakeTransaction(commit_failure)); | 290 new IndexedDBFakeBackingStore::FakeTransaction(commit_failure)); |
291 db_->TransactionCreated(transaction); | 291 db_->TransactionCreated(transaction.get()); |
292 | 292 |
293 AbortObserver observer; | 293 AbortObserver observer; |
294 transaction->ScheduleTask( | 294 transaction->ScheduleTask( |
295 base::Bind(&IndexedDBTransactionTest::AbortableOperation, | 295 base::Bind(&IndexedDBTransactionTest::AbortableOperation, |
296 base::Unretained(this), | 296 base::Unretained(this), |
297 base::Unretained(&observer))); | 297 base::Unretained(&observer))); |
298 | 298 |
299 // Pump the message loop so that the transaction completes all pending tasks, | 299 // Pump the message loop so that the transaction completes all pending tasks, |
300 // otherwise it will defer the commit. | 300 // otherwise it will defer the commit. |
301 base::MessageLoop::current()->RunUntilIdle(); | 301 base::MessageLoop::current()->RunUntilIdle(); |
302 | 302 |
303 EXPECT_FALSE(observer.abort_task_called()); | 303 EXPECT_FALSE(observer.abort_task_called()); |
304 transaction->Commit(); | 304 transaction->Commit(); |
305 EXPECT_TRUE(observer.abort_task_called()); | 305 EXPECT_TRUE(observer.abort_task_called()); |
306 EXPECT_EQ(IndexedDBTransaction::FINISHED, transaction->state()); | 306 EXPECT_EQ(IndexedDBTransaction::FINISHED, transaction->state()); |
307 EXPECT_FALSE(transaction->IsTimeoutTimerRunning()); | 307 EXPECT_FALSE(transaction->IsTimeoutTimerRunning()); |
308 } | 308 } |
309 | 309 |
310 TEST_P(IndexedDBTransactionTestMode, AbortPreemptive) { | 310 TEST_P(IndexedDBTransactionTestMode, AbortPreemptive) { |
311 const int64 id = 0; | 311 const int64 id = 0; |
312 const std::set<int64> scope; | 312 const std::set<int64> scope; |
313 const leveldb::Status commit_success = leveldb::Status::OK(); | 313 const leveldb::Status commit_success = leveldb::Status::OK(); |
314 scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction( | 314 scoped_refptr<IndexedDBTransaction> transaction = new IndexedDBTransaction( |
315 id, | 315 id, |
316 new MockIndexedDBDatabaseCallbacks(), | 316 new MockIndexedDBDatabaseCallbacks(), |
317 scope, | 317 scope, |
318 GetParam(), | 318 GetParam(), |
319 db_, | 319 db_.get(), |
320 new IndexedDBFakeBackingStore::FakeTransaction(commit_success)); | 320 new IndexedDBFakeBackingStore::FakeTransaction(commit_success)); |
321 db_->TransactionCreated(transaction); | 321 db_->TransactionCreated(transaction.get()); |
322 | 322 |
323 // No conflicting transactions, so coordinator will start it immediately: | 323 // No conflicting transactions, so coordinator will start it immediately: |
324 EXPECT_EQ(IndexedDBTransaction::STARTED, transaction->state()); | 324 EXPECT_EQ(IndexedDBTransaction::STARTED, transaction->state()); |
325 EXPECT_FALSE(transaction->IsTimeoutTimerRunning()); | 325 EXPECT_FALSE(transaction->IsTimeoutTimerRunning()); |
326 | 326 |
327 transaction->ScheduleTask( | 327 transaction->ScheduleTask( |
328 blink::WebIDBTaskTypePreemptive, | 328 blink::WebIDBTaskTypePreemptive, |
329 base::Bind(&IndexedDBTransactionTest::DummyOperation, | 329 base::Bind(&IndexedDBTransactionTest::DummyOperation, |
330 base::Unretained(this))); | 330 base::Unretained(this))); |
331 EXPECT_EQ(0, transaction->pending_preemptive_events_); | 331 EXPECT_EQ(0, transaction->pending_preemptive_events_); |
(...skipping 28 matching lines...) Expand all Loading... |
360 | 360 |
361 static const blink::WebIDBTransactionMode kTestModes[] = { | 361 static const blink::WebIDBTransactionMode kTestModes[] = { |
362 blink::WebIDBTransactionModeReadOnly, blink::WebIDBTransactionModeReadWrite, | 362 blink::WebIDBTransactionModeReadOnly, blink::WebIDBTransactionModeReadWrite, |
363 blink::WebIDBTransactionModeVersionChange}; | 363 blink::WebIDBTransactionModeVersionChange}; |
364 | 364 |
365 INSTANTIATE_TEST_CASE_P(IndexedDBTransactions, | 365 INSTANTIATE_TEST_CASE_P(IndexedDBTransactions, |
366 IndexedDBTransactionTestMode, | 366 IndexedDBTransactionTestMode, |
367 ::testing::ValuesIn(kTestModes)); | 367 ::testing::ValuesIn(kTestModes)); |
368 | 368 |
369 } // namespace content | 369 } // namespace content |
OLD | NEW |