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

net/ssl/channel_id_service.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/channel_id_service.h"
 
 #include <algorithm>
 #include <limits>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 68 matching lines @@
     int* error) {
   scoped_ptr<ChannelIDStore::ChannelID> result;
 
   base::TimeTicks start = base::TimeTicks::Now();
   base::Time creation_time = base::Time::Now();
   scoped_ptr<crypto::ECPrivateKey> key(crypto::ECPrivateKey::Create());
 
   if (!key) {
     DLOG(ERROR) << "Unable to create channel ID key pair";
     *error = ERR_KEY_GENERATION_FAILED;
-    return result.Pass();
+    return result;
   }
 
   result.reset(new ChannelIDStore::ChannelID(server_identifier, creation_time,
-                                             key.Pass()));
+                                             std::move(key)));
   UMA_HISTOGRAM_CUSTOM_TIMES("DomainBoundCerts.GenerateCertTime",
                              base::TimeTicks::Now() - start,
                              base::TimeDelta::FromMilliseconds(1),
                              base::TimeDelta::FromMinutes(5),
                              50);
   *error = OK;
-  return result.Pass();
+  return result;
 }
 
 }  // namespace
 
 // ChannelIDServiceWorker runs on a worker thread and takes care of the
 // blocking process of performing key generation. Will take care of deleting
 // itself once Start() is called.
 class ChannelIDServiceWorker {
  public:
   typedef base::Callback<void(
@@ skipping 57 matching lines @@
 
   ~ChannelIDServiceJob() { DCHECK(requests_.empty()); }
 
   void AddRequest(ChannelIDService::Request* request,
                   bool create_if_missing = false) {
     create_if_missing_ |= create_if_missing;
     requests_.push_back(request);
   }
 
   void HandleResult(int error, scoped_ptr<crypto::ECPrivateKey> key) {
-    PostAll(error, key.Pass());
+    PostAll(error, std::move(key));
   }
 
   bool CreateIfMissing() const { return create_if_missing_; }
 
   void CancelRequest(ChannelIDService::Request* req) {
     auto it = std::find(requests_.begin(), requests_.end(), req);
     if (it != requests_.end())
       requests_.erase(it);
   }
 
  private:
   void PostAll(int error, scoped_ptr<crypto::ECPrivateKey> key) {
     std::vector<ChannelIDService::Request*> requests;
     requests_.swap(requests);
 
     for (std::vector<ChannelIDService::Request*>::iterator i = requests.begin();
          i != requests.end(); i++) {
       scoped_ptr<crypto::ECPrivateKey> key_copy;
       if (key)
         key_copy.reset(key->Copy());
-      (*i)->Post(error, key_copy.Pass());
+      (*i)->Post(error, std::move(key_copy));
     }
   }
 
   std::vector<ChannelIDService::Request*> requests_;
   bool create_if_missing_;
 };
 
 // static
 const char ChannelIDService::kEPKIPassword[] = "";
 
@@ skipping 50 matching lines @@
     case ERR_INSUFFICIENT_RESOURCES:
       RecordGetChannelIDResult(WORKER_FAILURE);
       break;
     default:
       RecordGetChannelIDResult(ASYNC_FAILURE_UNKNOWN);
       break;
   }
   service_ = NULL;
   DCHECK(!callback_.is_null());
   if (key)
-    *key_ = key.Pass();
+    *key_ = std::move(key);
   // Running the callback might delete |this| (e.g. the callback cleans up
   // resources created for the request), so we can't touch any of our
   // members afterwards. Reset callback_ first.
   base::ResetAndReturn(&callback_).Run(error);
 }
 
 ChannelIDService::ChannelIDService(
     ChannelIDStore* channel_id_store,
     const scoped_refptr<base::TaskRunner>& task_runner)
     : channel_id_store_(channel_id_store),
@@ skipping 117 matching lines @@
   j = inflight_.find(server_identifier);
   if (j == inflight_.end()) {
     NOTREACHED();
     return;
   }
 
   if (err == OK) {
     // Async DB lookup found a valid channel ID.
     key_store_hits_++;
     // ChannelIDService::Request::Post will do the histograms and stuff.
-    HandleResult(OK, server_identifier, key.Pass());
+    HandleResult(OK, server_identifier, std::move(key));
     return;
   }
   // Async lookup failed or the channel ID was missing. Return the error
   // directly, unless the channel ID was missing and a request asked to create
   // one.
   if (err != ERR_FILE_NOT_FOUND || !j->second->CreateIfMissing()) {
-    HandleResult(err, server_identifier, key.Pass());
+    HandleResult(err, server_identifier, std::move(key));
     return;
   }
   // At least one request asked to create a channel ID => start generating a new
   // one.
   workers_created_++;
   ChannelIDServiceWorker* worker = new ChannelIDServiceWorker(
       server_identifier,
       base::Bind(&ChannelIDService::GeneratedChannelID,
                  weak_ptr_factory_.GetWeakPtr()));
   if (!worker->Start(task_runner_)) {
     // TODO(rkn): Log to the NetLog.
     LOG(ERROR) << "ChannelIDServiceWorker couldn't be started.";
     HandleResult(ERR_INSUFFICIENT_RESOURCES, server_identifier, nullptr);
   }
 }
 
 ChannelIDStore* ChannelIDService::GetChannelIDStore() {
   return channel_id_store_.get();
 }
 
 void ChannelIDService::GeneratedChannelID(
     const std::string& server_identifier,
     int error,
     scoped_ptr<ChannelIDStore::ChannelID> channel_id) {
   DCHECK(CalledOnValidThread());
 
   scoped_ptr<crypto::ECPrivateKey> key;
   if (error == OK) {
     key.reset(channel_id->key()->Copy());
-    channel_id_store_->SetChannelID(channel_id.Pass());
+    channel_id_store_->SetChannelID(std::move(channel_id));
   }
-  HandleResult(error, server_identifier, key.Pass());
+  HandleResult(error, server_identifier, std::move(key));
 }
 
 void ChannelIDService::HandleResult(int error,
                                     const std::string& server_identifier,
                                     scoped_ptr<crypto::ECPrivateKey> key) {
   DCHECK(CalledOnValidThread());
 
   std::map<std::string, ChannelIDServiceJob*>::iterator j;
   j = inflight_.find(server_identifier);
   if (j == inflight_.end()) {
     NOTREACHED();
     return;
   }
   ChannelIDServiceJob* job = j->second;
   inflight_.erase(j);
 
-  job->HandleResult(error, key.Pass());
+  job->HandleResult(error, std::move(key));
   delete job;
 }
 
 bool ChannelIDService::JoinToInFlightRequest(
     const base::TimeTicks& request_start,
     const std::string& domain,
     scoped_ptr<crypto::ECPrivateKey>* key,
     bool create_if_missing,
     const CompletionCallback& callback,
     Request* out_req) {
@@ skipping 47 matching lines @@
   }
 
   return err;
 }
 
 int ChannelIDService::channel_id_count() {
   return channel_id_store_->GetChannelIDCount();
 }
 
 }  // namespace net