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

net/proxy/proxy_resolver_factory_mojo.cc

 // Copyright 2015 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_factory_mojo.h"
 
 #include <set>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_checker.h"
 #include "base/values.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/common/url_type_converters.h"
 #include "mojo/public/cpp/bindings/binding.h"
@@ skipping 12 matching lines @@
 namespace net {
 namespace {
 
 scoped_ptr<base::Value> NetLogErrorCallback(
     int line_number,
     const base::string16* message,
     NetLogCaptureMode /* capture_mode */) {
   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("line_number", line_number);
   dict->SetString("message", *message);
-  return dict.Pass();
+  return std::move(dict);
 }
 
 // A mixin that forwards logging to (Bound)NetLog and ProxyResolverErrorObserver
 // and DNS requests to a MojoHostResolverImpl, which is implemented in terms of
 // a HostResolver.
 template <typename ClientInterface>
 class ClientMixin : public ClientInterface {
  public:
   ClientMixin(HostResolver* host_resolver,
               ProxyResolverErrorObserver* error_observer,
@@ skipping 18 matching lines @@
     auto callback = base::Bind(&NetLogErrorCallback, line_number, &message_str);
     bound_net_log_.AddEvent(NetLog::TYPE_PAC_JAVASCRIPT_ERROR, callback);
     if (net_log_)
       net_log_->AddGlobalEntry(NetLog::TYPE_PAC_JAVASCRIPT_ERROR, callback);
     if (error_observer_)
       error_observer_->OnPACScriptError(line_number, message_str);
   }
 
   void ResolveDns(interfaces::HostResolverRequestInfoPtr request_info,
                   interfaces::HostResolverRequestClientPtr client) override {
-    host_resolver_.Resolve(request_info.Pass(), client.Pass());
+    host_resolver_.Resolve(std::move(request_info), std::move(client));
   }
 
  protected:
   bool dns_request_in_progress() {
     return host_resolver_.request_in_progress();
   }
 
  private:
   MojoHostResolverImpl host_resolver_;
   ProxyResolverErrorObserver* const error_observer_;
@@ skipping 105 matching lines @@
       resolver_(resolver),
       url_(url),
       results_(results),
       callback_(callback),
       binding_(this) {
   interfaces::ProxyResolverRequestClientPtr client_ptr;
   binding_.Bind(mojo::GetProxy(&client_ptr));
   binding_.set_connection_error_handler(base::Bind(
       &ProxyResolverMojo::Job::OnConnectionError, base::Unretained(this)));
   resolver_->mojo_proxy_resolver_ptr_->GetProxyForUrl(mojo::String::From(url_),
-                                                      client_ptr.Pass());
+                                                      std::move(client_ptr));
 }
 
 ProxyResolverMojo::Job::~Job() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!callback_.is_null())
     callback_.Run(ERR_PAC_SCRIPT_TERMINATED);
 }
 
 void ProxyResolverMojo::Job::Cancel() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 28 matching lines @@
   resolver_->RemoveJob(this);
   callback.Run(error);
 }
 
 ProxyResolverMojo::ProxyResolverMojo(
     interfaces::ProxyResolverPtr resolver_ptr,
     HostResolver* host_resolver,
     scoped_ptr<base::ScopedClosureRunner> on_delete_callback_runner,
     scoped_ptr<ProxyResolverErrorObserver> error_observer,
     NetLog* net_log)
-    : mojo_proxy_resolver_ptr_(resolver_ptr.Pass()),
+    : mojo_proxy_resolver_ptr_(std::move(resolver_ptr)),
       host_resolver_(host_resolver),
-      error_observer_(error_observer.Pass()),
+      error_observer_(std::move(error_observer)),
       net_log_(net_log),
-      on_delete_callback_runner_(on_delete_callback_runner.Pass()) {
+      on_delete_callback_runner_(std::move(on_delete_callback_runner)) {
   mojo_proxy_resolver_ptr_.set_connection_error_handler(base::Bind(
       &ProxyResolverMojo::OnConnectionError, base::Unretained(this)));
 }
 
 ProxyResolverMojo::~ProxyResolverMojo() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // All pending requests should have been cancelled.
   DCHECK(pending_jobs_.empty());
 }
 
@@ skipping 62 matching lines @@
       scoped_ptr<ProxyResolverErrorObserver> error_observer)
       : ClientMixin<interfaces::ProxyResolverFactoryRequestClient>(
             factory->host_resolver_,
             error_observer.get(),
             factory->net_log_,
             BoundNetLog()),
         factory_(factory),
         resolver_(resolver),
         callback_(callback),
         binding_(this),
-        error_observer_(error_observer.Pass()) {
+        error_observer_(std::move(error_observer)) {
     interfaces::ProxyResolverFactoryRequestClientPtr client_ptr;
     binding_.Bind(mojo::GetProxy(&client_ptr));
     on_delete_callback_runner_ = factory_->mojo_proxy_factory_->CreateResolver(
         mojo::String::From(pac_script->utf16()), mojo::GetProxy(&resolver_ptr_),
-        client_ptr.Pass());
+        std::move(client_ptr));
     resolver_ptr_.set_connection_error_handler(
         base::Bind(&ProxyResolverFactoryMojo::Job::OnConnectionError,
                    base::Unretained(this)));
     binding_.set_connection_error_handler(
         base::Bind(&ProxyResolverFactoryMojo::Job::OnConnectionError,
                    base::Unretained(this)));
   }
 
   void OnConnectionError() { ReportResult(ERR_PAC_SCRIPT_TERMINATED); }
 
  private:
   void ReportResult(int32_t error) override {
     resolver_ptr_.set_connection_error_handler(mojo::Closure());
     binding_.set_connection_error_handler(mojo::Closure());
     if (error == OK) {
-      resolver_->reset(
-          new ProxyResolverMojo(resolver_ptr_.Pass(), factory_->host_resolver_,
-                                on_delete_callback_runner_.Pass(),
-                                error_observer_.Pass(), factory_->net_log_));
+      resolver_->reset(new ProxyResolverMojo(
+          std::move(resolver_ptr_), factory_->host_resolver_,
+          std::move(on_delete_callback_runner_), std::move(error_observer_),
+          factory_->net_log_));
     }
     on_delete_callback_runner_.reset();
     callback_.Run(error);
   }
 
   ProxyResolverFactoryMojo* const factory_;
   scoped_ptr<ProxyResolver>* resolver_;
   const CompletionCallback callback_;
   interfaces::ProxyResolverPtr resolver_ptr_;
   mojo::Binding<interfaces::ProxyResolverFactoryRequestClient> binding_;
@@ skipping 28 matching lines @@
     return ERR_PAC_SCRIPT_FAILED;
   }
   request->reset(new Job(this, pac_script, resolver, callback,
                          error_observer_factory_.is_null()
                              ? nullptr
                              : error_observer_factory_.Run()));
   return ERR_IO_PENDING;
 }
 
 }  // namespace net