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

net/proxy/multi_threaded_proxy_resolver.cc

 // Copyright (c) 2012 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/proxy/multi_threaded_proxy_resolver.h"
 
 #include <deque>
 #include <utility>
 #include <vector>
 
@@ skipping 47 matching lines @@
   void Destroy();
 
   // Returns the outstanding job, or NULL.
   Job* outstanding_job() const { return outstanding_job_.get(); }
 
   ProxyResolver* resolver() { return resolver_.get(); }
 
   int thread_number() const { return thread_number_; }
 
   void set_resolver(scoped_ptr<ProxyResolver> resolver) {
-    resolver_ = resolver.Pass();
+    resolver_ = std::move(resolver);
   }
 
   void set_coordinator(Coordinator* coordinator) {
     DCHECK(coordinator);
     DCHECK(coordinator_);
     coordinator_ = coordinator;
   }
 
  private:
   friend class base::RefCountedThreadSafe<Executor>;
@@ skipping 176 matching lines @@
 
  protected:
   ~CreateResolverJob() override {}
 
  private:
   // Runs the completion callback on the origin thread.
   void RequestComplete(int result_code) {
     // The task may have been cancelled after it was started.
     if (!was_cancelled()) {
       DCHECK(executor());
-      executor()->set_resolver(resolver_.Pass());
+      executor()->set_resolver(std::move(resolver_));
     }
     OnJobCompleted();
   }
 
   const scoped_refptr<ProxyResolverScriptData> script_data_;
   ProxyResolverFactory* factory_;
   scoped_ptr<ProxyResolver> resolver_;
 };
 
 // MultiThreadedProxyResolver::GetProxyForURLJob ------------------------------
@@ skipping 140 matching lines @@
   DCHECK(!outstanding_job_.get());
 }
 
 // MultiThreadedProxyResolver --------------------------------------------------
 
 MultiThreadedProxyResolver::MultiThreadedProxyResolver(
     scoped_ptr<ProxyResolverFactory> resolver_factory,
     size_t max_num_threads,
     const scoped_refptr<ProxyResolverScriptData>& script_data,
     scoped_refptr<Executor> executor)
-    : resolver_factory_(resolver_factory.Pass()),
+    : resolver_factory_(std::move(resolver_factory)),
       max_num_threads_(max_num_threads),
       script_data_(script_data) {
   DCHECK(script_data_);
   executor->set_coordinator(this);
   executors_.push_back(executor);
 }
 
 MultiThreadedProxyResolver::~MultiThreadedProxyResolver() {
   DCHECK(CalledOnValidThread());
   // We will cancel all outstanding requests.
@@ skipping 106 matching lines @@
       public Executor::Coordinator {
  public:
   Job(MultiThreadedProxyResolverFactory* factory,
       const scoped_refptr<ProxyResolverScriptData>& script_data,
       scoped_ptr<ProxyResolver>* resolver,
       scoped_ptr<ProxyResolverFactory> resolver_factory,
       size_t max_num_threads,
       const CompletionCallback& callback)
       : factory_(factory),
         resolver_out_(resolver),
-        resolver_factory_(resolver_factory.Pass()),
+        resolver_factory_(std::move(resolver_factory)),
         max_num_threads_(max_num_threads),
         script_data_(script_data),
         executor_(new Executor(this, 0)),
         callback_(callback) {
     executor_->StartJob(
         new CreateResolverJob(script_data_, resolver_factory_.get()));
   }
 
   ~Job() override {
     if (factory_) {
@@ skipping 49 matching lines @@
 
 int MultiThreadedProxyResolverFactory::CreateProxyResolver(
     const scoped_refptr<ProxyResolverScriptData>& pac_script,
     scoped_ptr<ProxyResolver>* resolver,
     const CompletionCallback& callback,
     scoped_ptr<Request>* request) {
   scoped_ptr<Job> job(new Job(this, pac_script, resolver,
                               CreateProxyResolverFactory(), max_num_threads_,
                               callback));
   jobs_.insert(job.get());
-  *request = job.Pass();
+  *request = std::move(job);
   return ERR_IO_PENDING;
 }
 
 void MultiThreadedProxyResolverFactory::RemoveJob(
     MultiThreadedProxyResolverFactory::Job* job) {
   size_t erased = jobs_.erase(job);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace net