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

net/dns/host_resolver_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/dns/host_resolver_mojo.h"
 
 #include <string>
+#include <utility>
 
 #include "mojo/public/cpp/bindings/binding.h"
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/base/test_completion_callback.h"
 #include "net/dns/mojo_host_type_converters.h"
 #include "net/test/event_waiter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 11 matching lines @@
   void OnConnectionError();
 
  private:
   interfaces::HostResolverRequestClientPtr client_;
   const base::Closure error_callback_;
 };
 
 MockMojoHostResolverRequest::MockMojoHostResolverRequest(
     interfaces::HostResolverRequestClientPtr client,
     const base::Closure& error_callback)
-    : client_(client.Pass()), error_callback_(error_callback) {
+    : client_(std::move(client)), error_callback_(error_callback) {
   client_.set_connection_error_handler(base::Bind(
       &MockMojoHostResolverRequest::OnConnectionError, base::Unretained(this)));
 }
 
 void MockMojoHostResolverRequest::OnConnectionError() {
   error_callback_.Run();
 }
 
 struct HostResolverAction {
   enum Action {
     COMPLETE,
     DROP,
     RETAIN,
   };
 
   static scoped_ptr<HostResolverAction> ReturnError(Error error) {
     scoped_ptr<HostResolverAction> result(new HostResolverAction);
     result->error = error;
-    return result.Pass();
+    return result;
   }
 
   static scoped_ptr<HostResolverAction> ReturnResult(
       const AddressList& address_list) {
     scoped_ptr<HostResolverAction> result(new HostResolverAction);
     result->addresses = interfaces::AddressList::From(address_list);
-    return result.Pass();
+    return result;
   }
 
   static scoped_ptr<HostResolverAction> DropRequest() {
     scoped_ptr<HostResolverAction> result(new HostResolverAction);
     result->action = DROP;
-    return result.Pass();
+    return result;
   }
 
   static scoped_ptr<HostResolverAction> RetainRequest() {
     scoped_ptr<HostResolverAction> result(new HostResolverAction);
     result->action = RETAIN;
-    return result.Pass();
+    return result;
   }
 
   Action action = COMPLETE;
   interfaces::AddressListPtr addresses;
   Error error = OK;
 };
 
 class MockMojoHostResolver : public HostResolverMojo::Impl {
  public:
   explicit MockMojoHostResolver(
@@ skipping 20 matching lines @@
 MockMojoHostResolver::MockMojoHostResolver(
     const base::Closure& request_connection_error_callback)
     : request_connection_error_callback_(request_connection_error_callback) {
 }
 
 MockMojoHostResolver::~MockMojoHostResolver() {
   EXPECT_EQ(results_returned_, actions_.size());
 }
 
 void MockMojoHostResolver::AddAction(scoped_ptr<HostResolverAction> action) {
-  actions_.push_back(action.Pass());
+  actions_.push_back(std::move(action));
 }
 
 void MockMojoHostResolver::ResolveDns(
     interfaces::HostResolverRequestInfoPtr request_info,
     interfaces::HostResolverRequestClientPtr client) {
-  requests_received_.push_back(request_info.Pass());
+  requests_received_.push_back(std::move(request_info));
   ASSERT_LE(results_returned_, actions_.size());
   switch (actions_[results_returned_]->action) {
     case HostResolverAction::COMPLETE:
       client->ReportResult(actions_[results_returned_]->error,
-                           actions_[results_returned_]->addresses.Pass());
+                           std::move(actions_[results_returned_]->addresses));
       break;
     case HostResolverAction::RETAIN:
       requests_.push_back(make_scoped_ptr(new MockMojoHostResolverRequest(
-          client.Pass(), request_connection_error_callback_)));
+          std::move(client), request_connection_error_callback_)));
       break;
     case HostResolverAction::DROP:
       client.reset();
       break;
   }
   results_returned_++;
 }
 
 }  // namespace
 
@@ skipping 254 matching lines @@
   EXPECT_EQ(ERR_DNS_CACHE_MISS,
             resolver_->ResolveFromCache(request_info, &result, BoundNetLog()));
   EXPECT_TRUE(result.empty());
 }
 
 TEST_F(HostResolverMojoTest, GetHostCache) {
   EXPECT_TRUE(resolver_->GetHostCache());
 }
 
 }  // namespace net