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

net/proxy/proxy_resolver_factory_mojo_unittest.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 <list>
 #include <map>
 #include <queue>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "net/base/load_states.h"
@@ skipping 210 matching lines @@
 }
 
 void MockMojoProxyResolver::ClearBlockedClients() {
   blocked_clients_.clear();
 }
 
 void MockMojoProxyResolver::AddConnection(
     mojo::InterfaceRequest<interfaces::ProxyResolver> req) {
   if (binding_.is_bound())
     binding_.Close();
-  binding_.Bind(req.Pass());
+  binding_.Bind(std::move(req));
 }
 
 void MockMojoProxyResolver::GetProxyForUrl(
     const mojo::String& url,
     interfaces::ProxyResolverRequestClientPtr client) {
   ASSERT_FALSE(get_proxy_actions_.empty());
   GetProxyForUrlAction action = get_proxy_actions_.front();
   get_proxy_actions_.pop();
 
   EXPECT_EQ(action.expected_url.spec(), url.To<std::string>());
   client->Alert(url);
   client->OnError(12345, url);
   switch (action.action) {
     case GetProxyForUrlAction::COMPLETE: {
-      client->ReportResult(action.error, action.proxy_servers.Pass());
+      client->ReportResult(action.error, std::move(action.proxy_servers));
       break;
     }
     case GetProxyForUrlAction::DROP: {
       client.reset();
       break;
     }
     case GetProxyForUrlAction::DISCONNECT: {
       binding_.Close();
       break;
     }
     case GetProxyForUrlAction::WAIT_FOR_CLIENT_DISCONNECT: {
       ASSERT_FALSE(client.WaitForIncomingResponse());
       break;
     }
     case GetProxyForUrlAction::MAKE_DNS_REQUEST: {
       interfaces::HostResolverRequestInfoPtr request(
           interfaces::HostResolverRequestInfo::New());
       request->host = url;
       request->port = 12345;
       interfaces::HostResolverRequestClientPtr dns_client;
       mojo::GetProxy(&dns_client);
-      client->ResolveDns(request.Pass(), dns_client.Pass());
+      client->ResolveDns(std::move(request), std::move(dns_client));
       blocked_clients_.push_back(make_scoped_ptr(
           new interfaces::ProxyResolverRequestClientPtr(std::move(client))));
       break;
     }
   }
   WakeWaiter();
 }
 
 class Request {
  public:
@@ skipping 66 matching lines @@
   std::vector<scoped_ptr<interfaces::ProxyResolverFactoryRequestClientPtr>>
       blocked_clients_;
   std::vector<scoped_ptr<mojo::InterfaceRequest<interfaces::ProxyResolver>>>
       blocked_resolver_requests_;
   mojo::Binding<interfaces::ProxyResolverFactory> binding_;
 };
 
 MockMojoProxyResolverFactory::MockMojoProxyResolverFactory(
     MockMojoProxyResolver* resolver,
     mojo::InterfaceRequest<interfaces::ProxyResolverFactory> req)
-    : resolver_(resolver), binding_(this, req.Pass()) {
-}
+    : resolver_(resolver), binding_(this, std::move(req)) {}
 
 MockMojoProxyResolverFactory::~MockMojoProxyResolverFactory() {
   EXPECT_TRUE(create_resolver_actions_.empty())
       << "Actions remaining: " << create_resolver_actions_.size();
 }
 
 void MockMojoProxyResolverFactory::AddCreateProxyResolverAction(
     CreateProxyResolverAction action) {
   create_resolver_actions_.push(action);
 }
@@ skipping 21 matching lines @@
   ASSERT_FALSE(create_resolver_actions_.empty());
   CreateProxyResolverAction action = create_resolver_actions_.front();
   create_resolver_actions_.pop();
 
   EXPECT_EQ(action.expected_pac_script, pac_script.To<std::string>());
   client->Alert(pac_script);
   client->OnError(12345, pac_script);
   switch (action.action) {
     case CreateProxyResolverAction::COMPLETE: {
       if (action.error == OK)
-        resolver_->AddConnection(request.Pass());
+        resolver_->AddConnection(std::move(request));
       client->ReportResult(action.error);
       break;
     }
     case CreateProxyResolverAction::DROP_CLIENT: {
       // Save |request| so its pipe isn't closed.
       blocked_resolver_requests_.push_back(
           make_scoped_ptr(new mojo::InterfaceRequest<interfaces::ProxyResolver>(
               std::move(request))));
       break;
     }
@@ skipping 12 matching lines @@
       ASSERT_FALSE(client.WaitForIncomingResponse());
       break;
     }
     case CreateProxyResolverAction::MAKE_DNS_REQUEST: {
       interfaces::HostResolverRequestInfoPtr request(
           interfaces::HostResolverRequestInfo::New());
       request->host = pac_script;
       request->port = 12345;
       interfaces::HostResolverRequestClientPtr dns_client;
       mojo::GetProxy(&dns_client);
-      client->ResolveDns(request.Pass(), std::move(dns_client));
+      client->ResolveDns(std::move(request), std::move(dns_client));
       blocked_clients_.push_back(
           make_scoped_ptr(new interfaces::ProxyResolverFactoryRequestClientPtr(
               std::move(client))));
       break;
     }
   }
   WakeWaiter();
 }
 
 void DeleteResolverFactoryRequestCallback(
@@ skipping 67 matching lines @@
   }
 
   scoped_ptr<Request> MakeRequest(const GURL& url) {
     return make_scoped_ptr(new Request(proxy_resolver_mojo_.get(), url));
   }
 
   scoped_ptr<base::ScopedClosureRunner> CreateResolver(
       const mojo::String& pac_script,
       mojo::InterfaceRequest<interfaces::ProxyResolver> req,
       interfaces::ProxyResolverFactoryRequestClientPtr client) override {
-    factory_ptr_->CreateResolver(pac_script, req.Pass(), client.Pass());
+    factory_ptr_->CreateResolver(pac_script, std::move(req), std::move(client));
     return make_scoped_ptr(
         new base::ScopedClosureRunner(on_delete_callback_.closure()));
   }
 
   mojo::Array<interfaces::ProxyServerPtr> ProxyServersFromPacString(
       const std::string& pac_string) {
     ProxyInfo proxy_info;
     proxy_info.UsePacString(pac_string);
 
     return mojo::Array<interfaces::ProxyServerPtr>::From(
@@ skipping 347 matching lines @@
   mock_proxy_resolver_.ClearBlockedClients();
   request->WaitForResult();
 }
 
 TEST_F(ProxyResolverFactoryMojoTest, DeleteResolver) {
   CreateProxyResolver();
   proxy_resolver_mojo_.reset();
   on_delete_callback_.WaitForResult();
 }
 }  // namespace net