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

net/proxy/proxy_resolver_v8_tracing.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 "net/proxy/proxy_resolver_v8_tracing.h"
 
 #include <map>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
@@ skipping 306 matching lines @@
   // The number of outstanding (non-cancelled) jobs.
   int num_outstanding_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyResolverV8TracingImpl);
 };
 
 Job::Job(const Job::Params* params,
          scoped_ptr<ProxyResolverV8Tracing::Bindings> bindings)
     : origin_runner_(base::ThreadTaskRunnerHandle::Get()),
       params_(params),
-      bindings_(bindings.Pass()),
+      bindings_(std::move(bindings)),
       event_(true, false),
       last_num_dns_(0),
       pending_dns_(NULL) {
   CheckIsOnOriginThread();
 }
 
 void Job::StartCreateV8Resolver(
     const scoped_refptr<ProxyResolverScriptData>& script_data,
     scoped_ptr<ProxyResolverV8>* resolver,
     const CompletionCallback& callback) {
@@ skipping 201 matching lines @@
 }
 
 int Job::ExecuteProxyResolver() {
   int result = ERR_UNEXPECTED;  // Initialized to silence warnings.
 
   switch (operation_) {
     case CREATE_V8_RESOLVER: {
       scoped_ptr<ProxyResolverV8> resolver;
       result = ProxyResolverV8::Create(script_data_, this, &resolver);
       if (result == OK)
-        *resolver_out_ = resolver.Pass();
+        *resolver_out_ = std::move(resolver);
       break;
     }
     case GET_PROXY_FOR_URL: {
       result = v8_resolver()->GetProxyForURL(
           url_,
           // Important: Do not write directly into |user_results_|, since if the
           // request were to be cancelled from the origin thread, must guarantee
           // that |user_results_| is not accessed anymore.
           &results_, this);
       break;
@@ skipping 342 matching lines @@
       VLOG(1) << "PAC-error: " << "line: " << line_number << ": " << message;
 
     bindings_->OnError(line_number, message);
   }
 }
 
 ProxyResolverV8TracingImpl::ProxyResolverV8TracingImpl(
     scoped_ptr<base::Thread> thread,
     scoped_ptr<ProxyResolverV8> resolver,
     scoped_ptr<Job::Params> job_params)
-    : thread_(thread.Pass()),
-      v8_resolver_(resolver.Pass()),
-      job_params_(job_params.Pass()),
+    : thread_(std::move(thread)),
+      v8_resolver_(std::move(resolver)),
+      job_params_(std::move(job_params)),
       num_outstanding_callbacks_(0) {
   job_params_->num_outstanding_callbacks = &num_outstanding_callbacks_;
 }
 
 ProxyResolverV8TracingImpl::~ProxyResolverV8TracingImpl() {
   // Note, all requests should have been cancelled.
   CHECK_EQ(0, num_outstanding_callbacks_);
 
   // Join the worker thread. See http://crbug.com/69710.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   thread_.reset();
 }
 
 void ProxyResolverV8TracingImpl::GetProxyForURL(
     const GURL& url,
     ProxyInfo* results,
     const CompletionCallback& callback,
     ProxyResolver::RequestHandle* request,
     scoped_ptr<Bindings> bindings) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
 
-  scoped_refptr<Job> job = new Job(job_params_.get(), bindings.Pass());
+  scoped_refptr<Job> job = new Job(job_params_.get(), std::move(bindings));
 
   if (request)
     *request = job.get();
 
   job->StartGetProxyForURL(url, results, callback);
 }
 
 void ProxyResolverV8TracingImpl::CancelRequest(
     ProxyResolver::RequestHandle request) {
   Job* job = reinterpret_cast<Job*>(request);
@@ skipping 40 matching lines @@
         thread_(new base::Thread("Proxy Resolver")),
         resolver_out_(resolver_out),
         callback_(callback),
         num_outstanding_callbacks_(0) {
     // Start up the thread.
     base::Thread::Options options;
     options.timer_slack = base::TIMER_SLACK_MAXIMUM;
     CHECK(thread_->StartWithOptions(options));
     job_params_.reset(
         new Job::Params(thread_->task_runner(), &num_outstanding_callbacks_));
-    create_resolver_job_ = new Job(job_params_.get(), bindings.Pass());
+    create_resolver_job_ = new Job(job_params_.get(), std::move(bindings));
     create_resolver_job_->StartCreateV8Resolver(
         pac_script, &v8_resolver_,
         base::Bind(
             &ProxyResolverV8TracingFactoryImpl::CreateJob::OnV8ResolverCreated,
             base::Unretained(this)));
   }
 
   ~CreateJob() override {
     if (factory_) {
       factory_->RemoveJob(this);
@@ skipping 10 matching lines @@
     create_resolver_job_ = nullptr;
     StopWorkerThread();
   }
 
  private:
   void OnV8ResolverCreated(int error) {
     DCHECK(factory_);
     if (error == OK) {
       job_params_->v8_resolver = v8_resolver_.get();
       resolver_out_->reset(new ProxyResolverV8TracingImpl(
-          thread_.Pass(), v8_resolver_.Pass(), job_params_.Pass()));
+          std::move(thread_), std::move(v8_resolver_), std::move(job_params_)));
     } else {
       StopWorkerThread();
     }
 
     factory_->RemoveJob(this);
     factory_ = nullptr;
     create_resolver_job_ = nullptr;
     callback_.Run(error);
   }
 
@@ skipping 24 matching lines @@
   }
 }
 
 void ProxyResolverV8TracingFactoryImpl::CreateProxyResolverV8Tracing(
     const scoped_refptr<ProxyResolverScriptData>& pac_script,
     scoped_ptr<ProxyResolverV8Tracing::Bindings> bindings,
     scoped_ptr<ProxyResolverV8Tracing>* resolver,
     const CompletionCallback& callback,
     scoped_ptr<ProxyResolverFactory::Request>* request) {
   scoped_ptr<CreateJob> job(
-      new CreateJob(this, bindings.Pass(), pac_script, resolver, callback));
+      new CreateJob(this, std::move(bindings), pac_script, resolver, callback));
   jobs_.insert(job.get());
-  *request = job.Pass();
+  *request = std::move(job);
 }
 
 void ProxyResolverV8TracingFactoryImpl::RemoveJob(
     ProxyResolverV8TracingFactoryImpl::CreateJob* job) {
   size_t erased = jobs_.erase(job);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace
 
 // static
 scoped_ptr<ProxyResolverV8TracingFactory>
 ProxyResolverV8TracingFactory::Create() {
   return make_scoped_ptr(new ProxyResolverV8TracingFactoryImpl());
 }
 
 }  // namespace net