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

mojo/public/cpp/bindings/tests/associated_interface_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 <algorithm>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread.h"
 #include "mojo/message_pump/message_pump_mojo.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
 #include "mojo/public/cpp/bindings/associated_group.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr_info.h"
 #include "mojo/public/cpp/bindings/associated_interface_request.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/lib/multiplex_router.h"
 #include "mojo/public/interfaces/bindings/tests/test_associated_interfaces.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 namespace {
 
 using mojo::internal::AssociatedInterfacePtrInfoHelper;
 using mojo::internal::AssociatedInterfaceRequestHelper;
 using mojo::internal::MultiplexRouter;
 using mojo::internal::ScopedInterfaceEndpointHandle;
 
 class IntegerSenderImpl : public IntegerSender {
  public:
   explicit IntegerSenderImpl(AssociatedInterfaceRequest<IntegerSender> request)
-      : binding_(this, request.Pass()) {}
+      : binding_(this, std::move(request)) {}
 
   ~IntegerSenderImpl() override {}
 
   void set_notify_send_method_called(
       const base::Callback<void(int32_t)>& callback) {
     notify_send_method_called_ = callback;
   }
 
   void Echo(int32_t value, const EchoCallback& callback) override {
     callback.Run(value);
   }
   void Send(int32_t value) override { notify_send_method_called_.Run(value); }
 
   AssociatedBinding<IntegerSender>* binding() { return &binding_; }
 
   void set_connection_error_handler(const Closure& handler) {
     binding_.set_connection_error_handler(handler);
   }
 
  private:
   AssociatedBinding<IntegerSender> binding_;
   base::Callback<void(int32_t)> notify_send_method_called_;
 };
 
 class IntegerSenderConnectionImpl : public IntegerSenderConnection {
  public:
   explicit IntegerSenderConnectionImpl(
       InterfaceRequest<IntegerSenderConnection> request)
-      : binding_(this, request.Pass()) {}
+      : binding_(this, std::move(request)) {}
 
   ~IntegerSenderConnectionImpl() override {}
 
   void GetSender(AssociatedInterfaceRequest<IntegerSender> sender) override {
-    IntegerSenderImpl* sender_impl = new IntegerSenderImpl(sender.Pass());
+    IntegerSenderImpl* sender_impl = new IntegerSenderImpl(std::move(sender));
     sender_impl->set_connection_error_handler(
         [sender_impl]() { delete sender_impl; });
   }
 
   void AsyncGetSender(const AsyncGetSenderCallback& callback) override {
     AssociatedInterfaceRequest<IntegerSender> request;
     AssociatedInterfacePtrInfo<IntegerSender> ptr_info;
     binding_.associated_group()->CreateAssociatedInterface(
         AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
-    GetSender(request.Pass());
-    callback.Run(ptr_info.Pass());
+    GetSender(std::move(request));
+    callback.Run(std::move(ptr_info));
   }
 
   Binding<IntegerSenderConnection>* binding() { return &binding_; }
 
  private:
   Binding<IntegerSenderConnection> binding_;
 };
 
 class AssociatedInterfaceTest : public testing::Test {
  public:
   AssociatedInterfaceTest() : loop_(common::MessagePumpMojo::Create()) {}
   ~AssociatedInterfaceTest() override { loop_.RunUntilIdle(); }
 
   void PumpMessages() { loop_.RunUntilIdle(); }
 
   template <typename T>
   AssociatedInterfacePtrInfo<T> EmulatePassingAssociatedPtrInfo(
       AssociatedInterfacePtrInfo<T> ptr_info,
       scoped_refptr<MultiplexRouter> target) {
     ScopedInterfaceEndpointHandle handle =
         AssociatedInterfacePtrInfoHelper::PassHandle(&ptr_info);
     CHECK(!handle.is_local());
 
     ScopedInterfaceEndpointHandle new_handle =
         target->CreateLocalEndpointHandle(handle.release());
 
     AssociatedInterfacePtrInfo<T> result;
-    AssociatedInterfacePtrInfoHelper::SetHandle(&result, new_handle.Pass());
+    AssociatedInterfacePtrInfoHelper::SetHandle(&result, std::move(new_handle));
     result.set_version(ptr_info.version());
-    return result.Pass();
+    return std::move(result);
   }
 
   template <typename T>
   AssociatedInterfaceRequest<T> EmulatePassingAssociatedRequest(
       AssociatedInterfaceRequest<T> request,
       scoped_refptr<MultiplexRouter> target) {
     ScopedInterfaceEndpointHandle handle =
         AssociatedInterfaceRequestHelper::PassHandle(&request);
     CHECK(!handle.is_local());
 
     ScopedInterfaceEndpointHandle new_handle =
         target->CreateLocalEndpointHandle(handle.release());
 
     AssociatedInterfaceRequest<T> result;
-    AssociatedInterfaceRequestHelper::SetHandle(&result, new_handle.Pass());
-    return result.Pass();
+    AssociatedInterfaceRequestHelper::SetHandle(&result, std::move(new_handle));
+    return std::move(result);
   }
 
   // Okay to call from any thread.
   void QuitRunLoop(base::RunLoop* run_loop) {
     if (loop_.task_runner()->BelongsToCurrentThread()) {
       run_loop->Quit();
     } else {
       loop_.PostTask(
           FROM_HERE,
           base::Bind(&AssociatedInterfaceTest::QuitRunLoop,
                      base::Unretained(this), base::Unretained(run_loop)));
     }
   }
 
  private:
   base::MessageLoop loop_;
 };
 
 TEST_F(AssociatedInterfaceTest, InterfacesAtBothEnds) {
   // Bind to the same pipe two associated interfaces, whose implementation lives
   // at different ends. Test that the two don't interfere with each other.
 
   MessagePipe pipe;
   scoped_refptr<MultiplexRouter> router0(
-      new MultiplexRouter(true, pipe.handle0.Pass()));
+      new MultiplexRouter(true, std::move(pipe.handle0)));
   scoped_refptr<MultiplexRouter> router1(
-      new MultiplexRouter(false, pipe.handle1.Pass()));
+      new MultiplexRouter(false, std::move(pipe.handle1)));
 
   AssociatedInterfaceRequest<IntegerSender> request;
   AssociatedInterfacePtrInfo<IntegerSender> ptr_info;
 
   router0->CreateAssociatedGroup()->CreateAssociatedInterface(
       AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
-  ptr_info = EmulatePassingAssociatedPtrInfo(ptr_info.Pass(), router1);
+  ptr_info = EmulatePassingAssociatedPtrInfo(std::move(ptr_info), router1);
 
-  IntegerSenderImpl impl0(request.Pass());
+  IntegerSenderImpl impl0(std::move(request));
   AssociatedInterfacePtr<IntegerSender> ptr0;
-  ptr0.Bind(ptr_info.Pass());
+  ptr0.Bind(std::move(ptr_info));
 
   router0->CreateAssociatedGroup()->CreateAssociatedInterface(
       AssociatedGroup::WILL_PASS_REQUEST, &ptr_info, &request);
-  request = EmulatePassingAssociatedRequest(request.Pass(), router1);
+  request = EmulatePassingAssociatedRequest(std::move(request), router1);
 
-  IntegerSenderImpl impl1(request.Pass());
+  IntegerSenderImpl impl1(std::move(request));
   AssociatedInterfacePtr<IntegerSender> ptr1;
-  ptr1.Bind(ptr_info.Pass());
+  ptr1.Bind(std::move(ptr_info));
 
   bool ptr0_callback_run = false;
   ptr0->Echo(123, [&ptr0_callback_run](int32_t value) {
     EXPECT_EQ(123, value);
     ptr0_callback_run = true;
   });
 
   bool ptr1_callback_run = false;
   ptr1->Echo(456, [&ptr1_callback_run](int32_t value) {
     EXPECT_EQ(456, value);
@@ skipping 32 matching lines @@
         base::Bind(&common::MessagePumpMojo::Create);
     sender_thread_.StartWithOptions(thread_options);
   }
 
   // The following three methods are called on the corresponding sender thread.
   void SetUp(AssociatedInterfacePtrInfo<IntegerSender> ptr_info,
              TestSender* next_sender,
              int32_t max_value_to_send) {
     CHECK(sender_thread_.task_runner()->BelongsToCurrentThread());
 
-    ptr_.Bind(ptr_info.Pass());
+    ptr_.Bind(std::move(ptr_info));
     next_sender_ = next_sender ? next_sender : this;
     max_value_to_send_ = max_value_to_send;
   }
 
   void Send(int32_t value) {
     CHECK(sender_thread_.task_runner()->BelongsToCurrentThread());
 
     if (value > max_value_to_send_)
       return;
 
@@ skipping 28 matching lines @@
         base::Bind(&common::MessagePumpMojo::Create);
     receiver_thread_.StartWithOptions(thread_options);
   }
 
   void SetUp(AssociatedInterfaceRequest<IntegerSender> request0,
              AssociatedInterfaceRequest<IntegerSender> request1,
              int32_t max_value_to_receive,
              const base::Closure& notify_finish) {
     CHECK(receiver_thread_.task_runner()->BelongsToCurrentThread());
 
-    impl0_.reset(new IntegerSenderImpl(request0.Pass()));
+    impl0_.reset(new IntegerSenderImpl(std::move(request0)));
     impl0_->set_notify_send_method_called(
         base::Bind(&TestReceiver::SendMethodCalled, base::Unretained(this)));
-    impl1_.reset(new IntegerSenderImpl(request1.Pass()));
+    impl1_.reset(new IntegerSenderImpl(std::move(request1)));
     impl1_->set_notify_send_method_called(
         base::Bind(&TestReceiver::SendMethodCalled, base::Unretained(this)));
 
     max_value_to_receive_ = max_value_to_receive;
     notify_finish_ = notify_finish;
   }
 
   void TearDown() {
     CHECK(receiver_thread_.task_runner()->BelongsToCurrentThread());
 
@@ skipping 54 matching lines @@
 };
 
 TEST_F(AssociatedInterfaceTest, MultiThreadAccess) {
   // Set up four associated interfaces on a message pipe. Use the inteface
   // pointers on four threads in parallel; run the interface implementations on
   // two threads. Test that multi-threaded access works.
 
   const int32_t kMaxValue = 1000;
   MessagePipe pipe;
   scoped_refptr<MultiplexRouter> router0(
-      new MultiplexRouter(true, pipe.handle0.Pass()));
+      new MultiplexRouter(true, std::move(pipe.handle0)));
   scoped_refptr<MultiplexRouter> router1(
-      new MultiplexRouter(false, pipe.handle1.Pass()));
+      new MultiplexRouter(false, std::move(pipe.handle1)));
 
   AssociatedInterfaceRequest<IntegerSender> requests[4];
   AssociatedInterfacePtrInfo<IntegerSender> ptr_infos[4];
 
   for (size_t i = 0; i < 4; ++i) {
     router0->CreateAssociatedGroup()->CreateAssociatedInterface(
         AssociatedGroup::WILL_PASS_PTR, &ptr_infos[i], &requests[i]);
     ptr_infos[i] =
-        EmulatePassingAssociatedPtrInfo(ptr_infos[i].Pass(), router1);
+        EmulatePassingAssociatedPtrInfo(std::move(ptr_infos[i]), router1);
   }
 
   TestSender senders[4];
   for (size_t i = 0; i < 4; ++i) {
     senders[i].sender_thread()->task_runner()->PostTask(
         FROM_HERE, base::Bind(&TestSender::SetUp, base::Unretained(&senders[i]),
                               base::Passed(&ptr_infos[i]), nullptr,
                               static_cast<int32_t>(kMaxValue * (i + 1) / 4)));
   }
 
@@ skipping 57 matching lines @@
 
 TEST_F(AssociatedInterfaceTest, FIFO) {
   // Set up four associated interfaces on a message pipe. Use the inteface
   // pointers on four threads; run the interface implementations on two threads.
   // Take turns to make calls using the four pointers. Test that FIFO-ness is
   // preserved.
 
   const int32_t kMaxValue = 100;
   MessagePipe pipe;
   scoped_refptr<MultiplexRouter> router0(
-      new MultiplexRouter(true, pipe.handle0.Pass()));
+      new MultiplexRouter(true, std::move(pipe.handle0)));
   scoped_refptr<MultiplexRouter> router1(
-      new MultiplexRouter(false, pipe.handle1.Pass()));
+      new MultiplexRouter(false, std::move(pipe.handle1)));
 
   AssociatedInterfaceRequest<IntegerSender> requests[4];
   AssociatedInterfacePtrInfo<IntegerSender> ptr_infos[4];
 
   for (size_t i = 0; i < 4; ++i) {
     router0->CreateAssociatedGroup()->CreateAssociatedInterface(
         AssociatedGroup::WILL_PASS_PTR, &ptr_infos[i], &requests[i]);
     ptr_infos[i] =
-        EmulatePassingAssociatedPtrInfo(ptr_infos[i].Pass(), router1);
+        EmulatePassingAssociatedPtrInfo(std::move(ptr_infos[i]), router1);
   }
 
   TestSender senders[4];
   for (size_t i = 0; i < 4; ++i) {
     senders[i].sender_thread()->task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&TestSender::SetUp, base::Unretained(&senders[i]),
                    base::Passed(&ptr_infos[i]),
                    base::Unretained(&senders[(i + 1) % 4]), kMaxValue));
   }
@@ skipping 55 matching lines @@
       GetProxy(&sender0, connection_ptr.associated_group()));
 
   int32_t echoed_value = 0;
   sender0->Echo(123, [&echoed_value](int32_t value) { echoed_value = value; });
   PumpMessages();
   EXPECT_EQ(123, echoed_value);
 
   IntegerSenderAssociatedPtr sender1;
   connection_ptr->AsyncGetSender(
       [&sender1](AssociatedInterfacePtrInfo<IntegerSender> ptr_info) {
-        sender1.Bind(ptr_info.Pass());
+        sender1.Bind(std::move(ptr_info));
       });
   PumpMessages();
   EXPECT_TRUE(sender1);
 
   sender1->Echo(456, [&echoed_value](int32_t value) { echoed_value = value; });
   PumpMessages();
   EXPECT_EQ(456, echoed_value);
 }
 
 TEST_F(AssociatedInterfaceTest, BindingWaitAndPauseWhenNoAssociatedInterfaces) {
@@ skipping 16 matching lines @@
 
   // The previous wait has dispatched the GetSender request message, therefore
   // an associated interface has been set up on the pipe. It is not allowed to
   // wait or pause.
   EXPECT_TRUE(connection.binding()->HasAssociatedInterfaces());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo