content/browser/indexed_db/indexed_db_transaction.cc

   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.
   4
   5 #include "content/browser/indexed_db/indexed_db_transaction.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "content/browser/indexed_db/indexed_db_backing_store.h"
  12 #include "content/browser/indexed_db/indexed_db_cursor.h"
  13 #include "content/browser/indexed_db/indexed_db_database.h"
  14 #include "content/browser/indexed_db/indexed_db_database_callbacks.h"
  15 #include "content/browser/indexed_db/indexed_db_tracing.h"
  16 #include "content/browser/indexed_db/indexed_db_transaction_coordinator.h"
  17 #include "third_party/WebKit/public/platform/WebIDBDatabaseException.h"
  18 #include "third_party/leveldatabase/env_chromium.h"
  19
  20 namespace content {
  21
  22 const int64 kInactivityTimeoutPeriodSeconds = 60;
  23
  24 IndexedDBTransaction::TaskQueue::TaskQueue() {}
  25 IndexedDBTransaction::TaskQueue::~TaskQueue() { clear(); }
  26
  27 void IndexedDBTransaction::TaskQueue::clear() {
  28   while (!queue_.empty())
  29     queue_.pop();
  30 }
  31
  32 IndexedDBTransaction::Operation IndexedDBTransaction::TaskQueue::pop() {
  33   DCHECK(!queue_.empty());
  34   Operation task(queue_.front());
  35   queue_.pop();
  36   return task;
  37 }
  38
  39 IndexedDBTransaction::TaskStack::TaskStack() {}
  40 IndexedDBTransaction::TaskStack::~TaskStack() { clear(); }
  41
  42 void IndexedDBTransaction::TaskStack::clear() {
  43   while (!stack_.empty())
  44     stack_.pop();
  45 }
  46
  47 IndexedDBTransaction::Operation IndexedDBTransaction::TaskStack::pop() {
  48   DCHECK(!stack_.empty());
  49   Operation task(stack_.top());
  50   stack_.pop();
  51   return task;
  52 }
  53
  54 IndexedDBTransaction::IndexedDBTransaction(
  55     int64 id,
  56     scoped_refptr<IndexedDBDatabaseCallbacks> callbacks,
  57     const std::set<int64>& object_store_ids,
  58     blink::WebIDBTransactionMode mode,
  59     IndexedDBDatabase* database,
  60     IndexedDBBackingStore::Transaction* backing_store_transaction)
  61     : id_(id),
  62       object_store_ids_(object_store_ids),
  63       mode_(mode),
  64       used_(false),
  65       state_(CREATED),
  66       commit_pending_(false),
  67       callbacks_(callbacks),
  68       database_(database),
  69       transaction_(backing_store_transaction),
  70       backing_store_transaction_begun_(false),
  71       should_process_queue_(false),
  72       pending_preemptive_events_(0) {
  73   database_->transaction_coordinator().DidCreateTransaction(this);
  74
  75   diagnostics_.tasks_scheduled = 0;
  76   diagnostics_.tasks_completed = 0;
  77   diagnostics_.creation_time = base::Time::Now();
  78 }
  79
  80 IndexedDBTransaction::~IndexedDBTransaction() {
  81   // It shouldn't be possible for this object to get deleted until it's either
  82   // complete or aborted.
  83   DCHECK_EQ(state_, FINISHED);
  84   DCHECK(preemptive_task_queue_.empty());
  85   DCHECK_EQ(pending_preemptive_events_, 0);
  86   DCHECK(task_queue_.empty());
  87   DCHECK(abort_task_stack_.empty());
  88 }
  89
  90 void IndexedDBTransaction::ScheduleTask(blink::WebIDBTaskType type,
  91                                         Operation task) {
  92   DCHECK_NE(state_, COMMITTING);
  93   if (state_ == FINISHED)
  94     return;
  95
  96   timeout_timer_.Stop();
  97   used_ = true;
  98   if (type == blink::WebIDBTaskTypeNormal) {
  99     task_queue_.push(task);
 100     ++diagnostics_.tasks_scheduled;
 101   } else {
 102     preemptive_task_queue_.push(task);
 103   }
 104   RunTasksIfStarted();
 105 }
 106
 107 void IndexedDBTransaction::ScheduleAbortTask(Operation abort_task) {
 108   DCHECK_NE(FINISHED, state_);
 109   DCHECK(used_);
 110   abort_task_stack_.push(abort_task);
 111 }
 112
 113 void IndexedDBTransaction::RunTasksIfStarted() {
 114   DCHECK(used_);
 115
 116   // Not started by the coordinator yet.
 117   if (state_ != STARTED)
 118     return;
 119
 120   // A task is already posted.
 121   if (should_process_queue_)
 122     return;
 123
 124   should_process_queue_ = true;
 125   base::MessageLoop::current()->PostTask(
 126       FROM_HERE, base::Bind(&IndexedDBTransaction::ProcessTaskQueue, this));
 127 }
 128
 129 void IndexedDBTransaction::Abort() {
 130   Abort(IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
 131                                "Internal error (unknown cause)"));
 132 }
 133
 134 void IndexedDBTransaction::Abort(const IndexedDBDatabaseError& error) {
 135   IDB_TRACE1("IndexedDBTransaction::Abort", "txn.id", id());
 136   if (state_ == FINISHED)
 137     return;
 138
 139   // The last reference to this object may be released while performing the
 140   // abort steps below. We therefore take a self reference to keep ourselves
 141   // alive while executing this method.
 142   scoped_refptr<IndexedDBTransaction> protect(this);
 143
 144   timeout_timer_.Stop();
 145
 146   state_ = FINISHED;
 147   should_process_queue_ = false;
 148
 149   if (backing_store_transaction_begun_)
 150     transaction_->Rollback();
 151
 152   // Run the abort tasks, if any.
 153   while (!abort_task_stack_.empty())
 154     abort_task_stack_.pop().Run(NULL);
 155
 156   preemptive_task_queue_.clear();
 157   pending_preemptive_events_ = 0;
 158   task_queue_.clear();
 159
 160   // Backing store resources (held via cursors) must be released
 161   // before script callbacks are fired, as the script callbacks may
 162   // release references and allow the backing store itself to be
 163   // released, and order is critical.
 164   CloseOpenCursors();
 165   transaction_->Reset();
 166
 167   // Transactions must also be marked as completed before the
 168   // front-end is notified, as the transaction completion unblocks
 169   // operations like closing connections.
 170   database_->transaction_coordinator().DidFinishTransaction(this);
 171 #ifndef NDEBUG
 172   DCHECK(!database_->transaction_coordinator().IsActive(this));
 173 #endif
 174
 175   if (callbacks_.get())
 176     callbacks_->OnAbort(id_, error);
 177
 178   database_->TransactionFinished(this, false);
 179
 180   database_ = NULL;
 181 }
 182
 183 bool IndexedDBTransaction::IsTaskQueueEmpty() const {
 184   return preemptive_task_queue_.empty() && task_queue_.empty();
 185 }
 186
 187 bool IndexedDBTransaction::HasPendingTasks() const {
 188   return pending_preemptive_events_ || !IsTaskQueueEmpty();
 189 }
 190
 191 void IndexedDBTransaction::RegisterOpenCursor(IndexedDBCursor* cursor) {
 192   open_cursors_.insert(cursor);
 193 }
 194
 195 void IndexedDBTransaction::UnregisterOpenCursor(IndexedDBCursor* cursor) {
 196   open_cursors_.erase(cursor);
 197 }
 198
 199 void IndexedDBTransaction::Start() {
 200   // TransactionCoordinator has started this transaction.
 201   DCHECK_EQ(CREATED, state_);
 202   state_ = STARTED;
 203   diagnostics_.start_time = base::Time::Now();
 204
 205   if (!used_)
 206     return;
 207
 208   RunTasksIfStarted();
 209 }
 210
 211 class BlobWriteCallbackImpl : public IndexedDBBackingStore::BlobWriteCallback {
 212  public:
 213   explicit BlobWriteCallbackImpl(
 214       scoped_refptr<IndexedDBTransaction> transaction)
 215       : transaction_(transaction) {}
 216   void Run(bool succeeded) override {
 217     transaction_->BlobWriteComplete(succeeded);
 218   }
 219
 220  protected:
 221   ~BlobWriteCallbackImpl() override {}
 222
 223  private:
 224   scoped_refptr<IndexedDBTransaction> transaction_;
 225 };
 226
 227 void IndexedDBTransaction::BlobWriteComplete(bool success) {
 228   IDB_TRACE("IndexedDBTransaction::BlobWriteComplete");
 229   if (state_ == FINISHED)  // aborted
 230     return;
 231   DCHECK_EQ(state_, COMMITTING);
 232   if (success)
 233     CommitPhaseTwo();
 234   else
 235     Abort(IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionDataError,
 236                                  "Failed to write blobs."));
 237 }
 238
 239 leveldb::Status IndexedDBTransaction::Commit() {
 240   IDB_TRACE1("IndexedDBTransaction::Commit", "txn.id", id());
 241
 242   timeout_timer_.Stop();
 243
 244   // In multiprocess ports, front-end may have requested a commit but
 245   // an abort has already been initiated asynchronously by the
 246   // back-end.
 247   if (state_ == FINISHED)
 248     return leveldb::Status::OK();
 249   DCHECK_NE(state_, COMMITTING);
 250
 251   DCHECK(!used_ || state_ == STARTED);
 252   commit_pending_ = true;
 253
 254   // Front-end has requested a commit, but there may be tasks like
 255   // create_index which are considered synchronous by the front-end
 256   // but are processed asynchronously.
 257   if (HasPendingTasks())
 258     return leveldb::Status::OK();
 259
 260   state_ = COMMITTING;
 261
 262   leveldb::Status s;
 263   if (!used_) {
 264     s = CommitPhaseTwo();
 265   } else {
 266     scoped_refptr<IndexedDBBackingStore::BlobWriteCallback> callback(
 267         new BlobWriteCallbackImpl(this));
 268     // CommitPhaseOne will call the callback synchronously if there are no blobs
 269     // to write.
 270     s = transaction_->CommitPhaseOne(callback);
 271     if (!s.ok())
 272       Abort(IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionDataError,
 273                                    "Error processing blob journal."));
 274   }
 275
 276   return s;
 277 }
 278
 279 leveldb::Status IndexedDBTransaction::CommitPhaseTwo() {
 280   // Abort may have been called just as the blob write completed.
 281   if (state_ == FINISHED)
 282     return leveldb::Status::OK();
 283
 284   DCHECK_EQ(state_, COMMITTING);
 285
 286   // The last reference to this object may be released while performing the
 287   // commit steps below. We therefore take a self reference to keep ourselves
 288   // alive while executing this method.
 289   scoped_refptr<IndexedDBTransaction> protect(this);
 290
 291   state_ = FINISHED;
 292
 293   leveldb::Status s;
 294   bool committed;
 295   if (!used_) {
 296     committed = true;
 297   } else {
 298     s = transaction_->CommitPhaseTwo();
 299     committed = s.ok();
 300   }
 301
 302   // Backing store resources (held via cursors) must be released
 303   // before script callbacks are fired, as the script callbacks may
 304   // release references and allow the backing store itself to be
 305   // released, and order is critical.
 306   CloseOpenCursors();
 307   transaction_->Reset();
 308
 309   // Transactions must also be marked as completed before the
 310   // front-end is notified, as the transaction completion unblocks
 311   // operations like closing connections.
 312   database_->transaction_coordinator().DidFinishTransaction(this);
 313
 314   if (committed) {
 315     abort_task_stack_.clear();
 316     callbacks_->OnComplete(id_);
 317     database_->TransactionFinished(this, true);
 318   } else {
 319     while (!abort_task_stack_.empty())
 320       abort_task_stack_.pop().Run(NULL);
 321
 322     IndexedDBDatabaseError error;
 323     if (leveldb_env::IndicatesDiskFull(s)) {
 324       error = IndexedDBDatabaseError(
 325           blink::WebIDBDatabaseExceptionQuotaError,
 326           "Encountered disk full while committing transaction.");
 327     } else {
 328       error = IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
 329                                      "Internal error committing transaction.");
 330     }
 331     callbacks_->OnAbort(id_, error);
 332
 333     database_->TransactionFinished(this, false);
 334     database_->TransactionCommitFailed(s);
 335   }
 336
 337   database_ = NULL;
 338   return s;
 339 }
 340
 341 void IndexedDBTransaction::ProcessTaskQueue() {
 342   IDB_TRACE1("IndexedDBTransaction::ProcessTaskQueue", "txn.id", id());
 343
 344   // May have been aborted.
 345   if (!should_process_queue_)
 346     return;
 347
 348   DCHECK(!IsTaskQueueEmpty());
 349   should_process_queue_ = false;
 350
 351   if (!backing_store_transaction_begun_) {
 352     transaction_->Begin();
 353     backing_store_transaction_begun_ = true;
 354   }
 355
 356   // The last reference to this object may be released while performing the
 357   // tasks. Take take a self reference to keep this object alive so that
 358   // the loop termination conditions can be checked.
 359   scoped_refptr<IndexedDBTransaction> protect(this);
 360
 361   TaskQueue* task_queue =
 362       pending_preemptive_events_ ? &preemptive_task_queue_ : &task_queue_;
 363   while (!task_queue->empty() && state_ != FINISHED) {
 364     DCHECK_EQ(state_, STARTED);
 365     Operation task(task_queue->pop());
 366     task.Run(this);
 367     if (!pending_preemptive_events_) {
 368       DCHECK(diagnostics_.tasks_completed < diagnostics_.tasks_scheduled);
 369       ++diagnostics_.tasks_completed;
 370     }
 371
 372     // Event itself may change which queue should be processed next.
 373     task_queue =
 374         pending_preemptive_events_ ? &preemptive_task_queue_ : &task_queue_;
 375   }
 376
 377   // If there are no pending tasks, we haven't already committed/aborted,
 378   // and the front-end requested a commit, it is now safe to do so.
 379   if (!HasPendingTasks() && state_ != FINISHED && commit_pending_) {
 380     Commit();
 381     return;
 382   }
 383
 384   // The transaction may have been aborted while processing tasks.
 385   if (state_ == FINISHED)
 386     return;
 387
 388   DCHECK(state_ == STARTED);
 389
 390   // Otherwise, start a timer in case the front-end gets wedged and
 391   // never requests further activity. Read-only transactions don't
 392   // block other transactions, so don't time those out.
 393   if (mode_ != blink::WebIDBTransactionModeReadOnly) {
 394     timeout_timer_.Start(
 395         FROM_HERE,
 396         base::TimeDelta::FromSeconds(kInactivityTimeoutPeriodSeconds),
 397         base::Bind(&IndexedDBTransaction::Timeout, this));
 398   }
 399 }
 400
 401 void IndexedDBTransaction::Timeout() {
 402   Abort(IndexedDBDatabaseError(
 403       blink::WebIDBDatabaseExceptionTimeoutError,
 404       base::ASCIIToUTF16("Transaction timed out due to inactivity.")));
 405 }
 406
 407 void IndexedDBTransaction::CloseOpenCursors() {
 408   for (auto* cursor : open_cursors_)
 409     cursor->Close();
 410   open_cursors_.clear();
 411 }
 412
 413 }  // namespace content