Convert Pass()→std::move() in //content/browser

content/browser/indexed_db/indexed_db_database.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_database.h"
 
 #include <math.h>
 #include <limits>
 #include <set>
+#include <utility>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 52 matching lines @@
 
 // PendingUpgradeCall has a scoped_ptr<IndexedDBConnection> because it owns the
 // in-progress connection.
 class IndexedDBDatabase::PendingUpgradeCall {
  public:
   PendingUpgradeCall(scoped_refptr<IndexedDBCallbacks> callbacks,
                      scoped_ptr<IndexedDBConnection> connection,
                      int64_t transaction_id,
                      int64_t version)
       : callbacks_(callbacks),
-        connection_(connection.Pass()),
+        connection_(std::move(connection)),
         version_(version),
         transaction_id_(transaction_id) {}
   scoped_refptr<IndexedDBCallbacks> callbacks() const { return callbacks_; }
   // Takes ownership of the connection object.
   scoped_ptr<IndexedDBConnection> ReleaseConnection() WARN_UNUSED_RESULT {
-    return connection_.Pass();
+    return std::move(connection_);
   }
   int64_t version() const { return version_; }
   int64_t transaction_id() const { return transaction_id_; }
 
  private:
   scoped_refptr<IndexedDBCallbacks> callbacks_;
   scoped_ptr<IndexedDBConnection> connection_;
   int64_t version_;
   const int64_t transaction_id_;
 };
@@ skipping 134 matching lines @@
   return kMaxIDBMessageSizeInBytes;
 }
 
 scoped_ptr<IndexedDBConnection> IndexedDBDatabase::CreateConnection(
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
     int child_process_id) {
   scoped_ptr<IndexedDBConnection> connection(
       new IndexedDBConnection(this, database_callbacks));
   connections_.insert(connection.get());
   backing_store_->GrantChildProcessPermissions(child_process_id);
-  return connection.Pass();
+  return connection;
 }
 
 IndexedDBTransaction* IndexedDBDatabase::GetTransaction(
     int64_t transaction_id) const {
   TransactionMap::const_iterator trans_iterator =
       transactions_.find(transaction_id);
   if (trans_iterator == transactions_.end())
     return NULL;
   return trans_iterator->second;
 }
@@ skipping 690 matching lines @@
 
   if (!ValidateObjectStoreId(object_store_id))
     return;
 
   DCHECK(key);
   DCHECK(value);
   scoped_ptr<PutOperationParams> params(new PutOperationParams());
   params->object_store_id = object_store_id;
   params->value.swap(*value);
   params->handles.swap(*handles);
-  params->key = key.Pass();
+  params->key = std::move(key);
   params->put_mode = put_mode;
   params->callbacks = callbacks;
   params->index_keys = index_keys;
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::PutOperation, this, base::Passed(&params)));
 }
 
 void IndexedDBDatabase::PutOperation(scoped_ptr<PutOperationParams> params,
                                      IndexedDBTransaction* transaction) {
   IDB_TRACE1("IndexedDBDatabase::PutOperation", "txn.id", transaction->id());
@@ skipping 11 matching lines @@
       object_store.auto_increment && !params->key->IsValid()) {
     scoped_ptr<IndexedDBKey> auto_inc_key = GenerateKey(
         backing_store_.get(), transaction, id(), params->object_store_id);
     key_was_generated = true;
     if (!auto_inc_key->IsValid()) {
       params->callbacks->OnError(
           IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionConstraintError,
                                  "Maximum key generator value reached."));
       return;
     }
-    key = auto_inc_key.Pass();
+    key = std::move(auto_inc_key);
   } else {
-    key = params->key.Pass();
+    key = std::move(params->key);
   }
 
   DCHECK(key->IsValid());
 
   IndexedDBBackingStore::RecordIdentifier record_identifier;
   if (params->put_mode == blink::WebIDBPutModeAddOnly) {
     bool found = false;
     leveldb::Status s = backing_store_->KeyExistsInObjectStore(
         transaction->BackingStoreTransaction(),
         id(),
@@ skipping 227 matching lines @@
   IndexedDBTransaction* transaction = GetTransaction(transaction_id);
   if (!transaction)
     return;
 
   if (!ValidateObjectStoreIdAndOptionalIndexId(object_store_id, index_id))
     return;
 
   scoped_ptr<OpenCursorOperationParams> params(new OpenCursorOperationParams());
   params->object_store_id = object_store_id;
   params->index_id = index_id;
-  params->key_range = key_range.Pass();
+  params->key_range = std::move(key_range);
   params->direction = direction;
   params->cursor_type =
       key_only ? indexed_db::CURSOR_KEY_ONLY : indexed_db::CURSOR_KEY_AND_VALUE;
   params->task_type = task_type;
   params->callbacks = callbacks;
   transaction->ScheduleTask(base::Bind(
       &IndexedDBDatabase::OpenCursorOperation, this, base::Passed(&params)));
 }
 
 void IndexedDBDatabase::OpenCursorOperation(
@@ skipping 63 matching lines @@
     }
   }
 
   if (!backing_store_cursor) {
     // Why is Success being called?
     params->callbacks->OnSuccess(nullptr);
     return;
   }
 
   scoped_refptr<IndexedDBCursor> cursor =
-      new IndexedDBCursor(backing_store_cursor.Pass(),
-                          params->cursor_type,
-                          params->task_type,
-                          transaction);
+      new IndexedDBCursor(std::move(backing_store_cursor), params->cursor_type,
+                          params->task_type, transaction);
   params->callbacks->OnSuccess(
       cursor, cursor->key(), cursor->primary_key(), cursor->Value());
 }
 
 void IndexedDBDatabase::Count(int64_t transaction_id,
                               int64_t object_store_id,
                               int64_t index_id,
                               scoped_ptr<IndexedDBKeyRange> key_range,
                               scoped_refptr<IndexedDBCallbacks> callbacks) {
   IDB_TRACE1("IndexedDBDatabase::Count", "txn.id", transaction_id);
@@ skipping 207 matching lines @@
       base::Bind(&IndexedDBDatabase::VersionChangeAbortOperation,
                  this,
                  metadata_.version,
                  metadata_.int_version));
   metadata_.int_version = version;
   metadata_.version = kNoStringVersion;
 
   DCHECK(!pending_second_half_open_);
   pending_second_half_open_.reset(
       new PendingSuccessCall(callbacks, connection.get(), version));
-  callbacks->OnUpgradeNeeded(old_version, connection.Pass(), metadata());
+  callbacks->OnUpgradeNeeded(old_version, std::move(connection), metadata());
 }
 
 void IndexedDBDatabase::TransactionFinished(IndexedDBTransaction* transaction,
                                             bool committed) {
   IDB_TRACE1("IndexedDBTransaction::TransactionFinished", "txn.id", id());
   DCHECK(transactions_.find(transaction->id()) != transactions_.end());
   DCHECK_EQ(transactions_[transaction->id()], transaction);
   transactions_.erase(transaction->id());
 
   if (transaction->mode() == blink::WebIDBTransactionModeVersionChange) {
     if (pending_second_half_open_) {
       if (committed) {
         DCHECK_EQ(pending_second_half_open_->version(), metadata_.int_version);
         DCHECK(metadata_.id != kInvalidId);
 
         // Connection was already minted for OnUpgradeNeeded callback.
         scoped_ptr<IndexedDBConnection> connection;
-        pending_second_half_open_->callbacks()->OnSuccess(connection.Pass(),
+        pending_second_half_open_->callbacks()->OnSuccess(std::move(connection),
                                                           this->metadata());
       } else {
         pending_second_half_open_->callbacks()->OnError(
             IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionAbortError,
                                    "Version change transaction was aborted in "
                                    "upgradeneeded event handler."));
       }
       pending_second_half_open_.reset();
     }
 
@@ skipping 32 matching lines @@
 
 size_t IndexedDBDatabase::PendingDeleteCount() const {
   return pending_delete_calls_.size();
 }
 
 void IndexedDBDatabase::ProcessPendingCalls() {
   if (pending_run_version_change_transaction_call_ && ConnectionCount() == 1) {
     DCHECK(pending_run_version_change_transaction_call_->version() >
            metadata_.int_version);
     scoped_ptr<PendingUpgradeCall> pending_call =
-        pending_run_version_change_transaction_call_.Pass();
+        std::move(pending_run_version_change_transaction_call_);
     RunVersionChangeTransactionFinal(pending_call->callbacks(),
                                      pending_call->ReleaseConnection(),
                                      pending_call->transaction_id(),
                                      pending_call->version());
     DCHECK_EQ(1u, ConnectionCount());
     // Fall through would be a no-op, since transaction must complete
     // asynchronously.
     DCHECK(IsDeleteDatabaseBlocked());
     DCHECK(IsOpenConnectionBlocked());
     return;
@@ skipping 179 matching lines @@
       if (iter != connection.get()) {
         iter->callbacks()->OnVersionChange(metadata_.int_version,
                                            requested_version);
       }
     }
     // OnBlocked will be fired at the request when one of the other
     // connections acks that the OnVersionChange was ignored.
 
     DCHECK(!pending_run_version_change_transaction_call_);
     pending_run_version_change_transaction_call_.reset(new PendingUpgradeCall(
-        callbacks, connection.Pass(), transaction_id, requested_version));
+        callbacks, std::move(connection), transaction_id, requested_version));
     return;
   }
-  RunVersionChangeTransactionFinal(
-      callbacks, connection.Pass(), transaction_id, requested_version);
+  RunVersionChangeTransactionFinal(callbacks, std::move(connection),
+                                   transaction_id, requested_version);
 }
 
 void IndexedDBDatabase::RunVersionChangeTransactionFinal(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_ptr<IndexedDBConnection> connection,
     int64_t transaction_id,
     int64_t requested_version) {
   std::vector<int64_t> object_store_ids;
   CreateTransaction(transaction_id,
                     connection.get(),
@@ skipping 144 matching lines @@
     const base::string16& previous_version,
     int64_t previous_int_version,
     IndexedDBTransaction* transaction) {
   DCHECK(!transaction);
   IDB_TRACE("IndexedDBDatabase::VersionChangeAbortOperation");
   metadata_.version = previous_version;
   metadata_.int_version = previous_int_version;
 }
 
 }  // namespace content