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

net/proxy/proxy_resolver_v8_tracing_wrapper.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_v8_tracing_wrapper.h"
 
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/values.h"
 #include "net/base/net_errors.h"
 #include "net/log/net_log.h"
 #include "net/proxy/proxy_resolver_error_observer.h"
 
 namespace net {
 namespace {
 
 // Returns event parameters for a PAC error message (line number + message).
 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);
 }
 
 class BindingsImpl : public ProxyResolverV8Tracing::Bindings {
  public:
   BindingsImpl(ProxyResolverErrorObserver* error_observer,
                HostResolver* host_resolver,
                NetLog* net_log,
                const BoundNetLog& bound_net_log)
       : error_observer_(error_observer),
         host_resolver_(host_resolver),
@@ skipping 63 matching lines @@
   scoped_ptr<ProxyResolverErrorObserver> error_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyResolverV8TracingWrapper);
 };
 
 ProxyResolverV8TracingWrapper::ProxyResolverV8TracingWrapper(
     scoped_ptr<ProxyResolverV8Tracing> resolver_impl,
     NetLog* net_log,
     HostResolver* host_resolver,
     scoped_ptr<ProxyResolverErrorObserver> error_observer)
-    : resolver_impl_(resolver_impl.Pass()),
+    : resolver_impl_(std::move(resolver_impl)),
       net_log_(net_log),
       host_resolver_(host_resolver),
-      error_observer_(error_observer.Pass()) {
-}
+      error_observer_(std::move(error_observer)) {}
 
 int ProxyResolverV8TracingWrapper::GetProxyForURL(
     const GURL& url,
     ProxyInfo* results,
     const CompletionCallback& callback,
     RequestHandle* request,
     const BoundNetLog& net_log) {
   resolver_impl_->GetProxyForURL(
       url, results, callback, request,
       make_scoped_ptr(new BindingsImpl(error_observer_.get(), host_resolver_,
@@ skipping 53 matching lines @@
 }
 
 void ProxyResolverFactoryV8TracingWrapper::OnProxyResolverCreated(
     scoped_ptr<scoped_ptr<ProxyResolverV8Tracing>> v8_resolver,
     scoped_ptr<ProxyResolver>* resolver,
     const CompletionCallback& callback,
     scoped_ptr<ProxyResolverErrorObserver> error_observer,
     int error) {
   if (error == OK) {
     resolver->reset(new ProxyResolverV8TracingWrapper(
-        v8_resolver->Pass(), net_log_, host_resolver_, error_observer.Pass()));
+        std::move(*v8_resolver), net_log_, host_resolver_,
+        std::move(error_observer)));
   }
   callback.Run(error);
 }
 
 }  // namespace net