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

content/browser/indexed_db/indexed_db_cursor.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_cursor.h"
 
 #include <stddef.h>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "content/browser/indexed_db/indexed_db_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_database_error.h"
 #include "content/browser/indexed_db/indexed_db_tracing.h"
 #include "content/browser/indexed_db/indexed_db_transaction.h"
 #include "content/browser/indexed_db/indexed_db_value.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseException.h"
 
 namespace content {
+namespace {
+IndexedDBDatabaseError CreateCursorClosedError() {
+  return IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,

[jsbell, 2016/11/30 21:30:14]

Maybe add a comment that this should never be script visible: the cursor should
either be closed when it hits the end of the range (and script throws an error
before the call could be made), if the transaction has finished (ditto), or if
there's an incoming request from the front end but the transaction has aborted
on the back end; in that case the tx will already have sent an abort to the
request so this would be ignored.

[dmurph, 2016/11/30 23:13:07]

Done.

+                                "The cursor has been closed.");
+}
+
+leveldb::Status InvokeOrSucceed(base::WeakPtr<IndexedDBCursor> weak_cursor,
+                                IndexedDBTransaction::Operation operation,
+                                IndexedDBTransaction* transaction) {
+  if (weak_cursor)
+    return operation.Run(transaction);
+  return leveldb::Status::OK();
+}
+
+template <typename Functor, typename... Args>
+IndexedDBTransaction::Operation BindWeakOperation(

[jsbell, 2016/11/30 21:30:14]

Add a comment on usage here.

As an alternative to this, InvokeOrSucceed could take
std::unique_ptr<base::WeakPtr<IndexedDBCursor>> 

[dmurph, 2016/11/30 23:13:07]

Done.

+    Functor&& functor,
+    base::WeakPtr<IndexedDBCursor> weak_cursor,
+    Args&&... args) {
+  DCHECK(weak_cursor);
+  IndexedDBCursor* cursor_ptr = weak_cursor.get();
+  return base::Bind(
+      &InvokeOrSucceed, std::move(weak_cursor),
+      base::Bind(std::forward<Functor>(functor), base::Unretained(cursor_ptr),
+                 std::forward<Args>(args)...));
+}
+
+}  // namespace
 
 IndexedDBCursor::IndexedDBCursor(
     std::unique_ptr<IndexedDBBackingStore::Cursor> cursor,
     indexed_db::CursorType cursor_type,
     blink::WebIDBTaskType task_type,
     IndexedDBTransaction* transaction)
     : task_type_(task_type),
       cursor_type_(cursor_type),
       transaction_(transaction),
       cursor_(std::move(cursor)),
-      closed_(false) {
-  transaction_->RegisterOpenCursor(this);
-}
+      closed_(false),
+      ptr_factory_(this) {}
 
-IndexedDBCursor::~IndexedDBCursor() {
-  transaction_->UnregisterOpenCursor(this);
-}
+IndexedDBCursor::~IndexedDBCursor() {}
 
 void IndexedDBCursor::Continue(std::unique_ptr<IndexedDBKey> key,
                                std::unique_ptr<IndexedDBKey> primary_key,
                                scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE("IndexedDBCursor::Continue");
 
   if (closed_) {
-    callbacks->OnError(
-        IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
-                               "The cursor has been closed."));
+    callbacks->OnError(CreateCursorClosedError());
     return;
   }
 
   transaction_->ScheduleTask(
       task_type_,
-      base::Bind(&IndexedDBCursor::CursorIterationOperation,
-                 this,
-                 base::Passed(&key),
-                 base::Passed(&primary_key),
-                 callbacks));
+      BindWeakOperation(&IndexedDBCursor::CursorIterationOperation,
+                        ptr_factory_.GetWeakPtr(), base::Passed(&key),
+                        base::Passed(&primary_key), callbacks));
 }
 
 void IndexedDBCursor::Advance(uint32_t count,
                               scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE("IndexedDBCursor::Advance");
 
   if (closed_) {
-    callbacks->OnError(
-        IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
-                               "The cursor has been closed."));
+    callbacks->OnError(CreateCursorClosedError());
     return;
   }
 
   transaction_->ScheduleTask(
       task_type_,
-      base::Bind(
-          &IndexedDBCursor::CursorAdvanceOperation, this, count, callbacks));
+      BindWeakOperation(&IndexedDBCursor::CursorAdvanceOperation,
+                        ptr_factory_.GetWeakPtr(), count, callbacks));
+}
+
+void IndexedDBCursor::Close() {
+  IDB_TRACE("IndexedDBCursor::Close");
+  closed_ = true;
+  cursor_.reset();
+  saved_cursor_.reset();
+  transaction_ = nullptr;
+}
+
+void IndexedDBCursor::RemoveCursorFromTransaction() {
+  if (transaction_)
+    transaction_->UnregisterOpenCursor(this);
 }
 
 leveldb::Status IndexedDBCursor::CursorAdvanceOperation(
     uint32_t count,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* /*transaction*/) {
   IDB_TRACE("IndexedDBCursor::CursorAdvanceOperation");
   leveldb::Status s = leveldb::Status::OK();
 
   if (!cursor_ || !cursor_->Advance(count, &s)) {
@@ skipping 39 matching lines @@
   callbacks->OnSuccess(this->key(), this->primary_key(), Value());
   return s;
 }
 
 void IndexedDBCursor::PrefetchContinue(
     int number_to_fetch,
     scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE("IndexedDBCursor::PrefetchContinue");
 
   if (closed_) {
-    callbacks->OnError(
-        IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
-                               "The cursor has been closed."));
+    callbacks->OnError(CreateCursorClosedError());
     return;
   }
 
   transaction_->ScheduleTask(
       task_type_,
-      base::Bind(&IndexedDBCursor::CursorPrefetchIterationOperation,
-                 this,
-                 number_to_fetch,
-                 callbacks));
+      BindWeakOperation(&IndexedDBCursor::CursorPrefetchIterationOperation,
+                        ptr_factory_.GetWeakPtr(), number_to_fetch, callbacks));
 }
 
 leveldb::Status IndexedDBCursor::CursorPrefetchIterationOperation(
     int number_to_fetch,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     IndexedDBTransaction* /*transaction*/) {
   IDB_TRACE("IndexedDBCursor::CursorPrefetchIterationOperation");
   leveldb::Status s = leveldb::Status::OK();
 
   std::vector<IndexedDBKey> found_keys;
@@ skipping 76 matching lines @@
     DCHECK_GT(used_prefetches, 0);
     for (int i = 0; i < used_prefetches - 1; ++i) {
       bool ok = cursor_->Continue(&s);
       DCHECK(ok);
     }
   }
 
   return s;
 }
 
-void IndexedDBCursor::Close() {
-  IDB_TRACE("IndexedDBCursor::Close");
-  closed_ = true;
-  cursor_.reset();
-  saved_cursor_.reset();
-}
-
 }  // namespace content