Convert Pass()→std::move() in mojo/services/

mojo/services/network/udp_socket_apptest.cc

 // Copyright 2014 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 <utility>
+
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "mojo/application/public/cpp/application_connection.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/application/public/cpp/application_test_base.h"
 #include "mojo/public/cpp/bindings/callback.h"
 #include "mojo/services/network/public/cpp/udp_socket_wrapper.h"
 #include "mojo/services/network/public/interfaces/network_service.mojom.h"
 #include "mojo/services/network/public/interfaces/udp_socket.mojom.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace service {
 namespace {
 
 NetAddressPtr GetLocalHostWithAnyPort() {
   NetAddressPtr addr(NetAddress::New());
   addr->family = NET_ADDRESS_FAMILY_IPV4;
   addr->ipv4 = NetAddressIPv4::New();
   addr->ipv4->port = 0;
   addr->ipv4->addr.resize(4);
   addr->ipv4->addr[0] = 127;
   addr->ipv4->addr[1] = 0;
   addr->ipv4->addr[2] = 0;
   addr->ipv4->addr[3] = 1;
 
-  return addr.Pass();
+  return addr;
 }
 
 Array<uint8_t> CreateTestMessage(uint8_t initial, size_t size) {
   Array<uint8_t> array(size);
   for (size_t i = 0; i < size; ++i)
     array[i] = static_cast<uint8_t>((i + initial) % 256);
-  return array.Pass();
+  return array;
 }
 
 template <typename CallbackType>
 class TestCallbackBase {
  public:
   TestCallbackBase() : state_(nullptr), run_loop_(nullptr), ran_(false) {}
 
   ~TestCallbackBase() {
     state_->set_test_callback(nullptr);
   }
@@ skipping 62 matching lines @@
 
   const NetworkErrorPtr& result() const { return result_; }
 
  private:
   struct State: public StateBase {
     ~State() override {}
 
     void Run(NetworkErrorPtr result) const override {
       if (test_callback_) {
         TestCallback* callback = static_cast<TestCallback*>(test_callback_);
-        callback->result_ = result.Pass();
+        callback->result_ = std::move(result);
       }
       NotifyRun();
     }
   };
 
   NetworkErrorPtr result_;
 };
 
 class TestCallbackWithAddressAndReceiver
     : public TestCallbackBase<
@@ skipping 11 matching lines @@
  private:
   struct State : public StateBase {
     ~State() override {}
 
     void Run(NetworkErrorPtr result,
              NetAddressPtr net_address,
              InterfaceRequest<UDPSocketReceiver> receiver) const override {
       if (test_callback_) {
         TestCallbackWithAddressAndReceiver* callback =
             static_cast<TestCallbackWithAddressAndReceiver*>(test_callback_);
-        callback->result_ = result.Pass();
-        callback->net_address_ = net_address.Pass();
-        callback->receiver_ = receiver.Pass();
+        callback->result_ = std::move(result);
+        callback->net_address_ = std::move(net_address);
+        callback->receiver_ = std::move(receiver);
       }
       NotifyRun();
     }
   };
 
   NetworkErrorPtr result_;
   NetAddressPtr net_address_;
   InterfaceRequest<UDPSocketReceiver> receiver_;
 };
 
 class TestCallbackWithAddress
     : public TestCallbackBase<Callback<void(NetworkErrorPtr, NetAddressPtr)>> {
  public:
   TestCallbackWithAddress() {
     Initialize(new State());
   }
   ~TestCallbackWithAddress() {}
 
   const NetworkErrorPtr& result() const { return result_; }
   const NetAddressPtr& net_address() const { return net_address_; }
 
  private:
   struct State : public StateBase {
     ~State() override {}
 
     void Run(NetworkErrorPtr result, NetAddressPtr net_address) const override {
       if (test_callback_) {
         TestCallbackWithAddress* callback =
             static_cast<TestCallbackWithAddress*>(test_callback_);
-        callback->result_ = result.Pass();
-        callback->net_address_ = net_address.Pass();
+        callback->result_ = std::move(result);
+        callback->net_address_ = std::move(net_address);
       }
       NotifyRun();
     }
   };
 
   NetworkErrorPtr result_;
   NetAddressPtr net_address_;
 };
 
 class TestCallbackWithUint32
@@ skipping 39 matching lines @@
  private:
   struct State : public StateBase {
     ~State() override {}
 
     void Run(NetworkErrorPtr result,
              NetAddressPtr src_addr,
              Array<uint8_t> data) const override {
       if (test_callback_) {
         TestReceiveCallback* callback =
             static_cast<TestReceiveCallback*>(test_callback_);
-        callback->result_ = result.Pass();
-        callback->src_addr_ = src_addr.Pass();
-        callback->data_ = data.Pass();
+        callback->result_ = std::move(result);
+        callback->src_addr_ = std::move(src_addr);
+        callback->data_ = std::move(data);
       }
       NotifyRun();
     }
   };
 
   NetworkErrorPtr result_;
   NetAddressPtr src_addr_;
   Array<uint8_t> data_;
 };
 
@@ skipping 27 matching lines @@
     run_loop_ = &run_loop;
     run_loop.Run();
     run_loop_ = nullptr;
   }
 
  private:
   void OnReceived(NetworkErrorPtr result,
                   NetAddressPtr src_addr,
                   Array<uint8_t> data) override {
     ReceiveResult* entry = new ReceiveResult();
-    entry->result = result.Pass();
-    entry->addr = src_addr.Pass();
-    entry->data = data.Pass();
+    entry->result = std::move(result);
+    entry->addr = std::move(src_addr);
+    entry->data = std::move(data);
 
     results_.push(entry);
 
     if (results_.size() == expected_receive_count_ && run_loop_) {
       expected_receive_count_ = 0;
       run_loop_->Quit();
     }
   }
 
   base::RunLoop* run_loop_;
@@ skipping 77 matching lines @@
   EXPECT_GT(callback9.result(), 0u);
 }
 
 TEST_F(UDPSocketAppTest, TestReadWrite) {
   TestCallbackWithAddressAndReceiver callback1;
   socket_->Bind(GetLocalHostWithAnyPort(), callback1.callback());
   callback1.WaitForResult();
   ASSERT_EQ(net::OK, callback1.result()->code);
   ASSERT_NE(0u, callback1.net_address()->ipv4->port);
 
-  receiver_binding_.Bind(callback1.receiver().Pass());
+  receiver_binding_.Bind(std::move(callback1.receiver()));
 
   NetAddressPtr server_addr = callback1.net_address().Clone();
 
   UDPSocketPtr client_socket;
   network_service_->CreateUDPSocket(GetProxy(&client_socket));
 
   TestCallbackWithAddressAndReceiver callback2;
   client_socket->Bind(GetLocalHostWithAnyPort(), callback2.callback());
   callback2.WaitForResult();
   ASSERT_EQ(net::OK, callback2.result()->code);
@@ skipping 27 matching lines @@
   }
 }
 
 TEST_F(UDPSocketAppTest, TestConnectedReadWrite) {
   TestCallbackWithAddressAndReceiver callback1;
   socket_->Bind(GetLocalHostWithAnyPort(), callback1.callback());
   callback1.WaitForResult();
   ASSERT_EQ(net::OK, callback1.result()->code);
   ASSERT_NE(0u, callback1.net_address()->ipv4->port);
 
-  receiver_binding_.Bind(callback1.receiver().Pass());
+  receiver_binding_.Bind(std::move(callback1.receiver()));
 
   NetAddressPtr server_addr = callback1.net_address().Clone();
 
   UDPSocketPtr client_socket;
   network_service_->CreateUDPSocket(GetProxy(&client_socket));
 
   TestCallbackWithAddressAndReceiver callback2;
   client_socket->Connect(server_addr.Clone(), callback2.callback());
   callback2.WaitForResult();
   ASSERT_EQ(net::OK, callback2.result()->code);
   ASSERT_NE(0u, callback2.net_address()->ipv4->port);
 
   UDPSocketReceiverImpl client_socket_receiver;
   Binding<UDPSocketReceiver> client_receiver_binding(
-      &client_socket_receiver, callback2.receiver().Pass());
+      &client_socket_receiver, std::move(callback2.receiver()));
 
   NetAddressPtr client_addr = callback2.net_address().Clone();
 
   const size_t kDatagramCount = 6;
   const size_t kDatagramSize = 255;
 
   // Test send using a connected socket.
   socket_->ReceiveMore(kDatagramCount);
 
   for (size_t i = 0; i < kDatagramCount; ++i) {
@@ skipping 36 matching lines @@
     client_socket_receiver.results()->pop();
 
     EXPECT_EQ(static_cast<int>(kDatagramSize), result->result->code);
     EXPECT_FALSE(result->addr);
     EXPECT_TRUE(result->data.Equals(
         CreateTestMessage(static_cast<uint8_t>(i), kDatagramSize)));
   }
 }
 
 TEST_F(UDPSocketAppTest, TestWrapperReadWrite) {
-  UDPSocketWrapper socket(socket_.Pass(), 4, 4);
+  UDPSocketWrapper socket(std::move(socket_), 4, 4);
 
   TestCallbackWithAddress callback1;
   socket.Bind(GetLocalHostWithAnyPort(), callback1.callback());
   callback1.WaitForResult();
   ASSERT_EQ(net::OK, callback1.result()->code);
   ASSERT_NE(0u, callback1.net_address()->ipv4->port);
 
   NetAddressPtr server_addr = callback1.net_address().Clone();
 
   UDPSocketPtr raw_client_socket;
   network_service_->CreateUDPSocket(GetProxy(&raw_client_socket));
-  UDPSocketWrapper client_socket(raw_client_socket.Pass(), 4, 4);
+  UDPSocketWrapper client_socket(std::move(raw_client_socket), 4, 4);
 
   TestCallbackWithAddress callback2;
   client_socket.Bind(GetLocalHostWithAnyPort(), callback2.callback());
   callback2.WaitForResult();
   ASSERT_EQ(net::OK, callback2.result()->code);
   ASSERT_NE(0u, callback2.net_address()->ipv4->port);
 
   NetAddressPtr client_addr = callback2.net_address().Clone();
 
   const size_t kDatagramCount = 16;
@@ skipping 19 matching lines @@
       EXPECT_EQ(static_cast<int>(kDatagramSize),
                 receive_callbacks[j].result()->code);
       EXPECT_TRUE(receive_callbacks[j].src_addr().Equals(client_addr));
       EXPECT_TRUE(receive_callbacks[j].data().Equals(
           CreateTestMessage(static_cast<uint8_t>(j), kDatagramSize)));
     }
   }
 }
 
 TEST_F(UDPSocketAppTest, TestWrapperConnectedReadWrite) {
-  UDPSocketWrapper socket(socket_.Pass(), 4, 4);
+  UDPSocketWrapper socket(std::move(socket_), 4, 4);
 
   TestCallbackWithAddress callback1;
   socket.Bind(GetLocalHostWithAnyPort(), callback1.callback());
   callback1.WaitForResult();
   ASSERT_EQ(net::OK, callback1.result()->code);
   ASSERT_NE(0u, callback1.net_address()->ipv4->port);
 
   NetAddressPtr server_addr = callback1.net_address().Clone();
 
   UDPSocketPtr raw_client_socket;
   network_service_->CreateUDPSocket(GetProxy(&raw_client_socket));
-  UDPSocketWrapper client_socket(raw_client_socket.Pass(), 4, 4);
+  UDPSocketWrapper client_socket(std::move(raw_client_socket), 4, 4);
 
   TestCallbackWithAddress callback2;
-  client_socket.Connect(server_addr.Pass(), callback2.callback());
+  client_socket.Connect(std::move(server_addr), callback2.callback());
   callback2.WaitForResult();
   ASSERT_EQ(net::OK, callback2.result()->code);
   ASSERT_NE(0u, callback2.net_address()->ipv4->port);
 
   NetAddressPtr client_addr = callback2.net_address().Clone();
 
   const size_t kDatagramCount = 16;
   const size_t kDatagramSize = 255;
 
   // Test send using a connected socket.
@@ skipping 44 matching lines @@
                 receive_callbacks[j].result()->code);
       EXPECT_FALSE(receive_callbacks[j].src_addr());
       EXPECT_TRUE(receive_callbacks[j].data().Equals(
           CreateTestMessage(static_cast<uint8_t>(j), kDatagramSize)));
     }
   }
 }
 
 }  // namespace service
 }  // namespace mojo