Convert Pass()→std::move() in //net

net/ssl/default_channel_id_store.cc

 // Copyright 2014 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 "net/ssl/default_channel_id_store.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "crypto/ec_private_key.h"
 #include "net/base/net_errors.h"
 
 namespace net {
 
 // --------------------------------------------------------------------------
 // Task
@@ skipping 44 matching lines @@
 }
 
 void DefaultChannelIDStore::GetChannelIDTask::Run(
     DefaultChannelIDStore* store) {
   scoped_ptr<crypto::ECPrivateKey> key_result;
   int err = store->GetChannelID(server_identifier_, &key_result,
                                 GetChannelIDCallback());
   DCHECK(err != ERR_IO_PENDING);
 
   InvokeCallback(base::Bind(callback_, err, server_identifier_,
-                            base::Passed(key_result.Pass())));
+                            base::Passed(std::move(key_result))));
 }
 
 // --------------------------------------------------------------------------
 // SetChannelIDTask
 class DefaultChannelIDStore::SetChannelIDTask
     : public DefaultChannelIDStore::Task {
  public:
   SetChannelIDTask(scoped_ptr<ChannelID> channel_id);
   ~SetChannelIDTask() override;
   void Run(DefaultChannelIDStore* store) override;
 
  private:
   scoped_ptr<ChannelID> channel_id_;
 };
 
 DefaultChannelIDStore::SetChannelIDTask::SetChannelIDTask(
     scoped_ptr<ChannelID> channel_id)
-    : channel_id_(channel_id.Pass()) {
-}
+    : channel_id_(std::move(channel_id)) {}
 
 DefaultChannelIDStore::SetChannelIDTask::~SetChannelIDTask() {
 }
 
 void DefaultChannelIDStore::SetChannelIDTask::Run(
     DefaultChannelIDStore* store) {
-  store->SyncSetChannelID(channel_id_.Pass());
+  store->SyncSetChannelID(std::move(channel_id_));
 }
 
 // --------------------------------------------------------------------------
 // DeleteChannelIDTask
 class DefaultChannelIDStore::DeleteChannelIDTask
     : public DefaultChannelIDStore::Task {
  public:
   DeleteChannelIDTask(const std::string& server_identifier,
                       const base::Closure& callback);
   ~DeleteChannelIDTask() override;
@@ skipping 120 matching lines @@
   if (it == channel_ids_.end())
     return ERR_FILE_NOT_FOUND;
 
   ChannelID* channel_id = it->second;
   key_result->reset(channel_id->key()->Copy());
 
   return OK;
 }
 
 void DefaultChannelIDStore::SetChannelID(scoped_ptr<ChannelID> channel_id) {
-  auto task = new SetChannelIDTask(channel_id.Pass());
+  auto task = new SetChannelIDTask(std::move(channel_id));
   RunOrEnqueueTask(scoped_ptr<Task>(task));
 }
 
 void DefaultChannelIDStore::DeleteChannelID(
     const std::string& server_identifier,
     const base::Closure& callback) {
   RunOrEnqueueTask(scoped_ptr<Task>(
       new DeleteChannelIDTask(server_identifier, callback)));
 }
 
@@ skipping 81 matching lines @@
   for (scoped_ptr<Task>& i : waiting_tasks_)
     i->Run(this);
   waiting_tasks_.clear();
 }
 
 void DefaultChannelIDStore::SyncSetChannelID(scoped_ptr<ChannelID> channel_id) {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded_);
 
   InternalDeleteChannelID(channel_id->server_identifier());
-  InternalInsertChannelID(channel_id.Pass());
+  InternalInsertChannelID(std::move(channel_id));
 }
 
 void DefaultChannelIDStore::SyncDeleteChannelID(
     const std::string& server_identifier) {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded_);
   InternalDeleteChannelID(server_identifier);
 }
 
 void DefaultChannelIDStore::SyncDeleteAllCreatedBetween(
@@ skipping 24 matching lines @@
   for (ChannelIDMap::iterator it = channel_ids_.begin();
        it != channel_ids_.end(); ++it)
     channel_id_list->push_back(*it->second);
 }
 
 void DefaultChannelIDStore::EnqueueTask(scoped_ptr<Task> task) {
   DCHECK(CalledOnValidThread());
   DCHECK(!loaded_);
   if (waiting_tasks_.empty())
     waiting_tasks_start_time_ = base::TimeTicks::Now();
-  waiting_tasks_.push_back(task.Pass());
+  waiting_tasks_.push_back(std::move(task));
 }
 
 void DefaultChannelIDStore::RunOrEnqueueTask(scoped_ptr<Task> task) {
   DCHECK(CalledOnValidThread());
   InitIfNecessary();
 
   if (!loaded_) {
-    EnqueueTask(task.Pass());
+    EnqueueTask(std::move(task));
     return;
   }
 
   task->Run(this);
 }
 
 void DefaultChannelIDStore::InternalDeleteChannelID(
     const std::string& server_identifier) {
   DCHECK(CalledOnValidThread());
   DCHECK(loaded_);
@@ skipping 18 matching lines @@
     store_->AddChannelID(*(channel_id.get()));
   const std::string& server_identifier = channel_id->server_identifier();
   channel_ids_[server_identifier] = channel_id.release();
 }
 
 DefaultChannelIDStore::PersistentStore::PersistentStore() {}
 
 DefaultChannelIDStore::PersistentStore::~PersistentStore() {}
 
 }  // namespace net