IndexedDB: Remove transaction timer, just post tasks

content/browser/indexed_db/indexed_db_transaction.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/indexed_db/indexed_db_transaction.h"
 
+#include "base/bind.h"
 #include "base/logging.h"
+#include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/indexed_db/indexed_db_backing_store.h"
 #include "content/browser/indexed_db/indexed_db_cursor.h"
 #include "content/browser/indexed_db/indexed_db_database.h"
 #include "content/browser/indexed_db/indexed_db_database_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_tracing.h"
 #include "content/browser/indexed_db/indexed_db_transaction_coordinator.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabaseException.h"
 
 namespace content {
@@ skipping 51 matching lines @@
     indexed_db::TransactionMode mode,
     IndexedDBDatabase* database)
     : id_(id),
       object_store_ids_(object_store_ids),
       mode_(mode),
       state_(UNUSED),
       commit_pending_(false),
       callbacks_(callbacks),
       database_(database),
       transaction_(database->BackingStore().get()),
+      should_process_queue_(false),
       pending_preemptive_events_(0) {
   database_->transaction_coordinator().DidCreateTransaction(this);
 }
 
 IndexedDBTransaction::~IndexedDBTransaction() {
   // It shouldn't be possible for this object to get deleted until it's either
   // complete or aborted.
   DCHECK_EQ(state_, FINISHED);
   DCHECK(preemptive_task_queue_.empty());
   DCHECK(task_queue_.empty());
   DCHECK(abort_task_stack_.empty());
 }
 
 void IndexedDBTransaction::ScheduleTask(IndexedDBDatabase::TaskType type,
                                         Operation* task,
                                         Operation* abort_task) {
   if (state_ == FINISHED)
     return;
 
   if (type == IndexedDBDatabase::NORMAL_TASK)
     task_queue_.push(task);
   else
     preemptive_task_queue_.push(task);
 
   if (abort_task)
     abort_task_stack_.push(abort_task);
 
-  if (state_ == UNUSED)
+  if (state_ == UNUSED) {
     Start();
-  else if (state_ == RUNNING && !task_timer_.IsRunning())
-    task_timer_.Start(FROM_HERE,
-                      base::TimeDelta::FromSeconds(0),
-                      this,
-                      &IndexedDBTransaction::TaskTimerFired);
+  } else if (state_ == RUNNING && !should_process_queue_) {
+    should_process_queue_ = true;
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&IndexedDBTransaction::ProcessTaskQueue, this));
+  }
 }
 
 void IndexedDBTransaction::Abort() {
   Abort(IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
                                "Internal error (unknown cause)"));
 }
 
 void IndexedDBTransaction::Abort(const IndexedDBDatabaseError& error) {
   IDB_TRACE("IndexedDBTransaction::Abort");
   if (state_ == FINISHED)
     return;
 
   bool was_running = state_ == RUNNING;
 
   // The last reference to this object may be released while performing the
   // abort steps below. We therefore take a self reference to keep ourselves
   // alive while executing this method.
   scoped_refptr<IndexedDBTransaction> protect(this);
 
   state_ = FINISHED;
-  task_timer_.Stop();
+  should_process_queue_ = false;
 
   if (was_running)
     transaction_.Rollback();
 
   // Run the abort tasks, if any.
   while (!abort_task_stack_.empty()) {
     scoped_ptr<Operation> task(abort_task_stack_.pop());
     task->Perform(0);
   }
   preemptive_task_queue_.clear();
@@ skipping 33 matching lines @@
 
 void IndexedDBTransaction::RegisterOpenCursor(IndexedDBCursor* cursor) {
   open_cursors_.insert(cursor);
 }
 
 void IndexedDBTransaction::UnregisterOpenCursor(IndexedDBCursor* cursor) {
   open_cursors_.erase(cursor);
 }
 
 void IndexedDBTransaction::Run() {
-  // TransactionCoordinator has started this transaction. Schedule a timer
-  // to process the first task.
+  // TransactionCoordinator has started this transaction.
   DCHECK(state_ == START_PENDING || state_ == RUNNING);
-  DCHECK(!task_timer_.IsRunning());
+  DCHECK(!should_process_queue_);
 
-  task_timer_.Start(FROM_HERE,
-                    base::TimeDelta::FromSeconds(0),
-                    this,
-                    &IndexedDBTransaction::TaskTimerFired);
+  should_process_queue_ = true;
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&IndexedDBTransaction::ProcessTaskQueue, this));
 }
 
 void IndexedDBTransaction::Start() {
   DCHECK_EQ(state_, UNUSED);
 
   state_ = START_PENDING;
   database_->transaction_coordinator().DidStartTransaction(this);
   database_->TransactionStarted(this);
 }
 
@@ skipping 48 matching lines @@
     callbacks_->OnAbort(
         id_,
         IndexedDBDatabaseError(WebKit::WebIDBDatabaseExceptionUnknownError,
                                "Internal error committing transaction."));
     database_->TransactionFinishedAndAbortFired(this);
   }
 
   database_ = NULL;
 }
 
-void IndexedDBTransaction::TaskTimerFired() {
-  IDB_TRACE("IndexedDBTransaction::TaskTimerFired");
+void IndexedDBTransaction::ProcessTaskQueue() {
+  IDB_TRACE("IndexedDBTransaction::ProcessTaskQueue");
+
+  // May have been aborted.
+  if (!should_process_queue_)
+    return;
+
   DCHECK(!IsTaskQueueEmpty());
+  should_process_queue_ = false;
 
   if (state_ == START_PENDING) {
     transaction_.Begin();
     state_ = RUNNING;
   }
 
   // The last reference to this object may be released while performing the
   // tasks. Take take a self reference to keep this object alive so that
   // the loop termination conditions can be checked.
   scoped_refptr<IndexedDBTransaction> protect(this);
@@ skipping 18 matching lines @@
 
 void IndexedDBTransaction::CloseOpenCursors() {
   for (std::set<IndexedDBCursor*>::iterator i = open_cursors_.begin();
        i != open_cursors_.end();
        ++i)
     (*i)->Close();
   open_cursors_.clear();
 }
 
 }  // namespace content