1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_TRANSACTION_H_
6 #define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_TRANSACTION_H_
12 #include "base/basictypes.h"
13 #include "base/memory/ref_counted.h"
14 #include "base/memory/scoped_ptr.h"
15 #include "base/time/time.h"
16 #include "base/timer/timer.h"
17 #include "content/browser/indexed_db/indexed_db_backing_store.h"
18 #include "content/browser/indexed_db/indexed_db_database.h"
19 #include "content/browser/indexed_db/indexed_db_database_error.h"
20 #include "third_party/WebKit/public/platform/WebIDBTypes.h"
24 class BlobWriteCallbackImpl;
25 class IndexedDBCursor;
26 class IndexedDBDatabaseCallbacks;
28 class CONTENT_EXPORT IndexedDBTransaction
29 : public NON_EXPORTED_BASE(base::RefCounted<IndexedDBTransaction>) {
31 typedef base::Callback<void(IndexedDBTransaction*)> Operation;
35 scoped_refptr<IndexedDBDatabaseCallbacks> callbacks,
36 const std::set<int64>& object_store_ids,
37 blink::WebIDBTransactionMode,
38 IndexedDBDatabase* db,
39 IndexedDBBackingStore::Transaction* backing_store_transaction);
42 leveldb::Status Commit();
43 void Abort(const IndexedDBDatabaseError& error);
45 // Called by the transaction coordinator when this transaction is unblocked.
48 blink::WebIDBTransactionMode mode() const { return mode_; }
49 const std::set<int64>& scope() const { return object_store_ids_; }
51 void ScheduleTask(Operation task) {
52 ScheduleTask(blink::WebIDBTaskTypeNormal, task);
54 void ScheduleTask(blink::WebIDBTaskType, Operation task);
55 void ScheduleAbortTask(Operation abort_task);
56 void RegisterOpenCursor(IndexedDBCursor* cursor);
57 void UnregisterOpenCursor(IndexedDBCursor* cursor);
58 void AddPreemptiveEvent() { pending_preemptive_events_++; }
59 void DidCompletePreemptiveEvent() {
60 pending_preemptive_events_--;
61 DCHECK_GE(pending_preemptive_events_, 0);
63 IndexedDBBackingStore::Transaction* BackingStoreTransaction() {
64 return transaction_.get();
66 int64 id() const { return id_; }
68 IndexedDBDatabase* database() const { return database_; }
69 IndexedDBDatabaseCallbacks* connection() const { return callbacks_; }
72 CREATED, // Created, but not yet started by coordinator.
73 STARTED, // Started by the coordinator.
74 COMMITTING, // In the process of committing, possibly waiting for blobs
76 FINISHED, // Either aborted or committed.
79 State state() const { return state_; }
80 bool IsTimeoutTimerRunning() const { return timeout_timer_.IsRunning(); }
83 base::Time creation_time;
84 base::Time start_time;
89 const Diagnostics& diagnostics() const { return diagnostics_; }
92 friend class BlobWriteCallbackImpl;
94 FRIEND_TEST_ALL_PREFIXES(IndexedDBTransactionTestMode, AbortPreemptive);
95 FRIEND_TEST_ALL_PREFIXES(IndexedDBTransactionTest, Timeout);
96 FRIEND_TEST_ALL_PREFIXES(IndexedDBTransactionTest,
97 SchedulePreemptiveTask);
98 FRIEND_TEST_ALL_PREFIXES(IndexedDBTransactionTestMode,
101 friend class base::RefCounted<IndexedDBTransaction>;
102 virtual ~IndexedDBTransaction();
104 void RunTasksIfStarted();
106 bool IsTaskQueueEmpty() const;
107 bool HasPendingTasks() const;
109 void BlobWriteComplete(bool success);
110 void ProcessTaskQueue();
111 void CloseOpenCursors();
112 leveldb::Status CommitPhaseTwo();
116 const std::set<int64> object_store_ids_;
117 const blink::WebIDBTransactionMode mode_;
121 bool commit_pending_;
122 scoped_refptr<IndexedDBDatabaseCallbacks> callbacks_;
123 scoped_refptr<IndexedDBDatabase> database_;
129 bool empty() const { return queue_.empty(); }
130 void push(Operation task) { queue_.push(task); }
135 std::queue<Operation> queue_;
137 DISALLOW_COPY_AND_ASSIGN(TaskQueue);
144 bool empty() const { return stack_.empty(); }
145 void push(Operation task) { stack_.push(task); }
150 std::stack<Operation> stack_;
152 DISALLOW_COPY_AND_ASSIGN(TaskStack);
155 TaskQueue task_queue_;
156 TaskQueue preemptive_task_queue_;
157 TaskStack abort_task_stack_;
159 scoped_ptr<IndexedDBBackingStore::Transaction> transaction_;
160 bool backing_store_transaction_begun_;
162 bool should_process_queue_;
163 int pending_preemptive_events_;
165 std::set<IndexedDBCursor*> open_cursors_;
167 // This timer is started after requests have been processed. If no subsequent
168 // requests are processed before the timer fires, assume the script is
169 // unresponsive and abort to unblock the transaction queue.
170 base::OneShotTimer<IndexedDBTransaction> timeout_timer_;
172 Diagnostics diagnostics_;
175 } // namespace content
177 #endif // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_TRANSACTION_H_