[IndexedDB] Refactoring to remove ref ptrs and host transaction ids.

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/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 12 matching lines @@
 #include "third_party/leveldatabase/env_chromium.h"
 
 namespace content {
 
 namespace {
 
 const int64_t kInactivityTimeoutPeriodSeconds = 60;
 
 // Helper for posting a task to call IndexedDBTransaction::Commit when we know
 // the transaction had no requests and therefore the commit must succeed.
-void CommitUnused(scoped_refptr<IndexedDBTransaction> transaction) {
+void CommitUnused(base::WeakPtr<IndexedDBTransaction> transaction) {
+  if (!transaction)
+    return;
   leveldb::Status status = transaction->Commit();
   DCHECK(status.ok());
 }
 
 // The database will be closed during this call.
 void ReportError(leveldb::Status status,
                  const scoped_refptr<IndexedDBDatabase> database,
                  IndexedDBFactory* factory) {
   DCHECK(!status.ok());
   if (status.IsCorruption()) {
@@ skipping 34 matching lines @@
 
 IndexedDBTransaction::AbortOperation IndexedDBTransaction::TaskStack::pop() {
   DCHECK(!stack_.empty());
   AbortOperation task = std::move(stack_.top());
   stack_.pop();
   return task;
 }
 
 IndexedDBTransaction::IndexedDBTransaction(
     int64_t id,
-    base::WeakPtr<IndexedDBConnection> connection,
+    IndexedDBConnection* connection,
     const std::set<int64_t>& object_store_ids,
     blink::WebIDBTransactionMode mode,
     IndexedDBBackingStore::Transaction* backing_store_transaction)
     : id_(id),
       object_store_ids_(object_store_ids),
       mode_(mode),
       connection_(std::move(connection)),
-      transaction_(backing_store_transaction) {
+      transaction_(backing_store_transaction),
+      ptr_factory_(this) {
   callbacks_ = connection_->callbacks();
   database_ = connection_->database();
 
-  database_->transaction_coordinator().DidCreateTransaction(this);
-
   diagnostics_.tasks_scheduled = 0;
   diagnostics_.tasks_completed = 0;
   diagnostics_.creation_time = base::Time::Now();
 }
 
 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_EQ(pending_preemptive_events_, 0);
   DCHECK(task_queue_.empty());
   DCHECK(abort_task_stack_.empty());
-  DCHECK(pending_observers_.empty());
   DCHECK(!processing_event_queue_);
 }
 
 void IndexedDBTransaction::ScheduleTask(blink::WebIDBTaskType type,
                                         Operation task) {
   DCHECK_NE(state_, COMMITTING);
   if (state_ == FINISHED)
     return;
 
   timeout_timer_.Stop();
@@ skipping 19 matching lines @@
   // Not started by the coordinator yet.
   if (state_ != STARTED)
     return;
 
   // A task is already posted.
   if (should_process_queue_)
     return;
 
   should_process_queue_ = true;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&IndexedDBTransaction::ProcessTaskQueue, this));
+      FROM_HERE, base::Bind(&IndexedDBTransaction::ProcessTaskQueue,
+                            ptr_factory_.GetWeakPtr()));
 }
 
 void IndexedDBTransaction::Abort() {
   Abort(IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                "Internal error (unknown cause)"));
 }
 
 void IndexedDBTransaction::Abort(const IndexedDBDatabaseError& error) {
   IDB_TRACE1("IndexedDBTransaction::Abort", "txn.id", id());
+  DCHECK(!processing_event_queue_);
   if (state_ == FINISHED)
     return;
 
-  // 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);
-
   timeout_timer_.Stop();
 
   state_ = FINISHED;
   should_process_queue_ = false;
 
   if (backing_store_transaction_begun_)
     transaction_->Rollback();
 
   // Run the abort tasks, if any.
   while (!abort_task_stack_.empty())
@@ skipping 12 matching lines @@
 
   // Transactions must also be marked as completed before the
   // front-end is notified, as the transaction completion unblocks
   // operations like closing connections.
   database_->transaction_coordinator().DidFinishTransaction(this);
 #ifndef NDEBUG
   DCHECK(!database_->transaction_coordinator().IsActive(this));
 #endif
 
   if (callbacks_.get())
-    callbacks_->OnAbort(id_, error);
+    callbacks_->OnAbort(*this, error);
 
   database_->TransactionFinished(this, false);
 
-  database_ = NULL;
-  connection_ = nullptr;
-  pending_observers_.clear();
+  // EraseTransaction will delete |this|.
+  connection_->EraseTransaction(id_);
 }
 
 bool IndexedDBTransaction::IsTaskQueueEmpty() const {
   return preemptive_task_queue_.empty() && task_queue_.empty();
 }
 
 bool IndexedDBTransaction::HasPendingTasks() const {
   return pending_preemptive_events_ || !IsTaskQueueEmpty();
 }
 
@@ skipping 10 matching lines @@
   DCHECK_EQ(CREATED, state_);
   state_ = STARTED;
   diagnostics_.start_time = base::Time::Now();
 
   if (!used_) {
     if (commit_pending_) {
       // The transaction has never had requests issued against it, but the
       // front-end previously requested a commit; do the commit now, but not
       // re-entrantly as that may renter the coordinator.
       base::ThreadTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(&CommitUnused, make_scoped_refptr(this)));
+          FROM_HERE, base::Bind(&CommitUnused, ptr_factory_.GetWeakPtr()));
     }
     return;
   }
 
   RunTasksIfStarted();
 }
 
 class BlobWriteCallbackImpl : public IndexedDBBackingStore::BlobWriteCallback {
  public:
   explicit BlobWriteCallbackImpl(
-      scoped_refptr<IndexedDBTransaction> transaction)
-      : transaction_(transaction) {}
-  void Run(bool succeeded) override {
-    transaction_->BlobWriteComplete(succeeded);
+      base::WeakPtr<IndexedDBTransaction> transaction)
+      : transaction_(std::move(transaction)) {}
+  leveldb::Status Run(bool succeeded, bool sync_call) override {
+    if (!transaction_)
+      return leveldb::Status::OK();
+    return transaction_->BlobWriteComplete(succeeded, sync_call);
   }
 
  protected:
   ~BlobWriteCallbackImpl() override {}
 
  private:
-  scoped_refptr<IndexedDBTransaction> transaction_;
+  base::WeakPtr<IndexedDBTransaction> transaction_;
 };
 
-void IndexedDBTransaction::BlobWriteComplete(bool success) {
+leveldb::Status IndexedDBTransaction::BlobWriteComplete(bool success,
+                                                        bool sync_call) {
   IDB_TRACE("IndexedDBTransaction::BlobWriteComplete");
   if (state_ == FINISHED)  // aborted
-    return;
+    return leveldb::Status::OK();
   DCHECK_EQ(state_, COMMITTING);
 
   if (!success) {
     Abort(IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionDataError,
                                  "Failed to write blobs."));
-    return;
+    return leveldb::Status::OK();
   }
-  // Save the database as |this| can be destroyed in the next line.
+  // Save the database as |this| can be destroyed in the next line. We also make
+  // sure to handle the error if we're not being called synchronously.
   scoped_refptr<IndexedDBDatabase> database = database_;
   leveldb::Status s = CommitPhaseTwo();
-  if (!s.ok())
+  if (!s.ok() && !sync_call)
     ReportError(s, database, database->factory());
+  return s;
 }
 
 leveldb::Status IndexedDBTransaction::Commit() {
   IDB_TRACE1("IndexedDBTransaction::Commit", "txn.id", id());
 
   timeout_timer_.Stop();
 
   // In multiprocess ports, front-end may have requested a commit but
   // an abort has already been initiated asynchronously by the
   // back-end.
@@ skipping 16 matching lines @@
   if (HasPendingTasks())
     return leveldb::Status::OK();
 
   state_ = COMMITTING;
 
   leveldb::Status s;
   if (!used_) {
     s = CommitPhaseTwo();
   } else {
     scoped_refptr<IndexedDBBackingStore::BlobWriteCallback> callback(
-        new BlobWriteCallbackImpl(this));
+        new BlobWriteCallbackImpl(ptr_factory_.GetWeakPtr()));
     // CommitPhaseOne will call the callback synchronously if there are no blobs
     // to write.
     s = transaction_->CommitPhaseOne(callback);
-    if (!s.ok())
-      Abort(IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionDataError,
-                                   "Error processing blob journal."));
   }
 
   return s;
 }
 
 leveldb::Status IndexedDBTransaction::CommitPhaseTwo() {
   // Abort may have been called just as the blob write completed.
   if (state_ == FINISHED)
     return leveldb::Status::OK();
 
   DCHECK_EQ(state_, COMMITTING);
 
-  // The last reference to this object may be released while performing the
-  // commit steps below. We therefore take a self reference to keep ourselves
-  // alive while executing this method.
-  scoped_refptr<IndexedDBTransaction> protect(this);
-
   state_ = FINISHED;
 
   leveldb::Status s;
   bool committed;
   if (!used_) {
     committed = true;
   } else {
     s = transaction_->CommitPhaseTwo();
     committed = s.ok();
   }
@@ skipping 16 matching lines @@
     // SendObservations must be called before OnComplete to ensure consistency
     // of callbacks at renderer.
     if (!connection_changes_map_.empty()) {
       database_->SendObservations(std::move(connection_changes_map_));
       connection_changes_map_.clear();
     }
     {
       IDB_TRACE1(
           "IndexedDBTransaction::CommitPhaseTwo.TransactionCompleteCallbacks",
           "txn.id", id());
-      callbacks_->OnComplete(id_);
+      callbacks_->OnComplete(*this);
     }
     if (!pending_observers_.empty() && connection_) {
       connection_->ActivatePendingObservers(std::move(pending_observers_));
       pending_observers_.clear();
     }
 
     database_->TransactionFinished(this, true);
+    // EraseTransaction will delete |this|.
+    connection_->EraseTransaction(id_);
+    return s;
   } else {
     while (!abort_task_stack_.empty())
       abort_task_stack_.pop().Run();
 
     IndexedDBDatabaseError error;
     if (leveldb_env::IndicatesDiskFull(s)) {
       error = IndexedDBDatabaseError(
           blink::WebIDBDatabaseExceptionQuotaError,
           "Encountered disk full while committing transaction.");
     } else {
       error = IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                      "Internal error committing transaction.");
     }
-    callbacks_->OnAbort(id_, error);
-
+    callbacks_->OnAbort(*this, error);
     database_->TransactionFinished(this, false);
   }
-
-  database_ = NULL;
   return s;
 }
 
 void IndexedDBTransaction::ProcessTaskQueue() {
   IDB_TRACE1("IndexedDBTransaction::ProcessTaskQueue", "txn.id", id());
 
   DCHECK(!processing_event_queue_);
 
   // May have been aborted.
   if (!should_process_queue_)
     return;
 
   processing_event_queue_ = true;
 
   DCHECK(!IsTaskQueueEmpty());
   should_process_queue_ = false;
 
   if (!backing_store_transaction_begun_) {
     transaction_->Begin();
     backing_store_transaction_begun_ = true;
   }
 
-  // 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);
-
   TaskQueue* task_queue =
       pending_preemptive_events_ ? &preemptive_task_queue_ : &task_queue_;
   while (!task_queue->empty() && state_ != FINISHED) {
     DCHECK_EQ(state_, STARTED);
     Operation task(task_queue->pop());
     leveldb::Status result = task.Run(this);
     if (!pending_preemptive_events_) {
       DCHECK(diagnostics_.tasks_completed < diagnostics_.tasks_scheduled);
       ++diagnostics_.tasks_completed;
     }
     if (!result.ok()) {
       processing_event_queue_ = false;
-      if (!result.ok())
-        ReportError(result, database_, database_->factory());
+      ReportError(result, database_, database_->factory());
       return;
     }
 
     // Event itself may change which queue should be processed next.
     task_queue =
         pending_preemptive_events_ ? &preemptive_task_queue_ : &task_queue_;
   }
 
   // If there are no pending tasks, we haven't already committed/aborted,
   // and the front-end requested a commit, it is now safe to do so.
   if (!HasPendingTasks() && state_ != FINISHED && commit_pending_) {
+    processing_event_queue_ = false;
+    // This can delete |this|.
     leveldb::Status result = Commit();
-    processing_event_queue_ = false;
     if (!result.ok())
       ReportError(result, database_, database_->factory());
     return;
   }
 
   // The transaction may have been aborted while processing tasks.
   if (state_ == FINISHED) {
     processing_event_queue_ = false;
     return;
   }
 
   DCHECK(state_ == STARTED);
 
   // Otherwise, start a timer in case the front-end gets wedged and
   // never requests further activity. Read-only transactions don't
   // block other transactions, so don't time those out.
   if (mode_ != blink::WebIDBTransactionModeReadOnly) {
-    timeout_timer_.Start(FROM_HERE, GetInactivityTimeout(),
-                         base::Bind(&IndexedDBTransaction::Timeout, this));
+    timeout_timer_.Start(
+        FROM_HERE, GetInactivityTimeout(),
+        base::Bind(&IndexedDBTransaction::Timeout, ptr_factory_.GetWeakPtr()));
   }
   processing_event_queue_ = false;
 }
 
 base::TimeDelta IndexedDBTransaction::GetInactivityTimeout() const {
   return base::TimeDelta::FromSeconds(kInactivityTimeoutPeriodSeconds);
 }
 
 void IndexedDBTransaction::Timeout() {
   Abort(IndexedDBDatabaseError(
@@ skipping 42 matching lines @@
 void IndexedDBTransaction::RecordObserverForLastObservation(
     int32_t connection_id,
     int32_t observer_id) {
   auto it = connection_changes_map_.find(connection_id);
   DCHECK(it != connection_changes_map_.end());
   it->second->observation_index_map[observer_id].push_back(
       it->second->observations.size() - 1);
 }
 
 }  // namespace content