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

mojo/public/cpp/bindings/tests/interface_ptr_unittest.cc

 // Copyright 2013 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/message_loop/message_loop.h"
 #include "mojo/message_pump/message_pump_mojo.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/public/interfaces/bindings/tests/math_calculator.mojom.h"
 #include "mojo/public/interfaces/bindings/tests/sample_interfaces.mojom.h"
 #include "mojo/public/interfaces/bindings/tests/sample_service.mojom.h"
 #include "mojo/public/interfaces/bindings/tests/scoping.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 19 matching lines @@
 template <typename Method, typename Class>
 RunnableImpl<Method, Class> MakeRunnable(Method method, Class object) {
   return RunnableImpl<Method, Class>(method, object);
 }
 
 typedef mojo::Callback<void(double)> CalcCallback;
 
 class MathCalculatorImpl : public math::Calculator {
  public:
   explicit MathCalculatorImpl(InterfaceRequest<math::Calculator> request)
-      : total_(0.0), binding_(this, request.Pass()) {}
+      : total_(0.0), binding_(this, std::move(request)) {}
   ~MathCalculatorImpl() override {}
 
   void CloseMessagePipe() { binding_.Close(); }
 
   void WaitForIncomingMethodCall() { binding_.WaitForIncomingMethodCall(); }
 
   void Clear(const CalcCallback& callback) override {
     total_ = 0.0;
     callback.Run(total_);
   }
 
   void Add(double value, const CalcCallback& callback) override {
     total_ += value;
     callback.Run(total_);
   }
 
   void Multiply(double value, const CalcCallback& callback) override {
     total_ *= value;
     callback.Run(total_);
   }
 
  private:
   double total_;
   Binding<math::Calculator> binding_;
 };
 
 class MathCalculatorUI {
  public:
   explicit MathCalculatorUI(math::CalculatorPtr calculator)
-      : calculator_(calculator.Pass()),
+      : calculator_(std::move(calculator)),
         output_(0.0),
         callback_(MakeRunnable(&MathCalculatorUI::Output, this)) {}
 
   bool WaitForIncomingResponse() {
     return calculator_.WaitForIncomingResponse();
   }
 
   bool encountered_error() const { return calculator_.encountered_error(); }
 
   void Add(double value) { calculator_->Add(value, callback_); }
@@ skipping 10 matching lines @@
   void Output(double output) { output_ = output; }
 
   math::CalculatorPtr calculator_;
   double output_;
   Callback<void(double)> callback_;
 };
 
 class SelfDestructingMathCalculatorUI {
  public:
   explicit SelfDestructingMathCalculatorUI(math::CalculatorPtr calculator)
-      : calculator_(calculator.Pass()), nesting_level_(0) {
+      : calculator_(std::move(calculator)), nesting_level_(0) {
     ++num_instances_;
   }
 
   void BeginTest(bool nested) {
     nesting_level_ = nested ? 2 : 1;
     calculator_->Add(
         1.0, MakeRunnable(&SelfDestructingMathCalculatorUI::Output, this));
   }
 
   static int num_instances() { return num_instances_; }
@@ skipping 18 matching lines @@
 };
 
 // static
 int SelfDestructingMathCalculatorUI::num_instances_ = 0;
 
 class ReentrantServiceImpl : public sample::Service {
  public:
   ~ReentrantServiceImpl() override {}
 
   explicit ReentrantServiceImpl(InterfaceRequest<sample::Service> request)
-      : call_depth_(0), max_call_depth_(0), binding_(this, request.Pass()) {}
+      : call_depth_(0),
+        max_call_depth_(0),
+        binding_(this, std::move(request)) {}
 
   int max_call_depth() { return max_call_depth_; }
 
   void Frobinate(sample::FooPtr foo,
                  sample::Service::BazOptions baz,
                  sample::PortPtr port,
                  const sample::Service::FrobinateCallback& callback) override {
     max_call_depth_ = std::max(++call_depth_, max_call_depth_);
     if (call_depth_ == 1) {
       EXPECT_TRUE(binding_.WaitForIncomingMethodCall());
@@ skipping 43 matching lines @@
   EXPECT_FALSE(calc.is_bound());
   MathCalculatorImpl calc_impl(GetProxy(&calc));
   EXPECT_TRUE(calc.is_bound());
 }
 
 TEST_F(InterfacePtrTest, EndToEnd) {
   math::CalculatorPtr calc;
   MathCalculatorImpl calc_impl(GetProxy(&calc));
 
   // Suppose this is instantiated in a process that has pipe1_.
-  MathCalculatorUI calculator_ui(calc.Pass());
+  MathCalculatorUI calculator_ui(std::move(calc));
 
   calculator_ui.Add(2.0);
   calculator_ui.Multiply(5.0);
 
   PumpMessages();
 
   EXPECT_EQ(10.0, calculator_ui.GetOutput());
 }
 
 TEST_F(InterfacePtrTest, EndToEnd_Synchronous) {
   math::CalculatorPtr calc;
   MathCalculatorImpl calc_impl(GetProxy(&calc));
 
   // Suppose this is instantiated in a process that has pipe1_.
-  MathCalculatorUI calculator_ui(calc.Pass());
+  MathCalculatorUI calculator_ui(std::move(calc));
 
   EXPECT_EQ(0.0, calculator_ui.GetOutput());
 
   calculator_ui.Add(2.0);
   EXPECT_EQ(0.0, calculator_ui.GetOutput());
   calc_impl.WaitForIncomingMethodCall();
   calculator_ui.WaitForIncomingResponse();
   EXPECT_EQ(2.0, calculator_ui.GetOutput());
 
   calculator_ui.Multiply(5.0);
   EXPECT_EQ(2.0, calculator_ui.GetOutput());
   calc_impl.WaitForIncomingMethodCall();
   calculator_ui.WaitForIncomingResponse();
   EXPECT_EQ(10.0, calculator_ui.GetOutput());
 }
 
 TEST_F(InterfacePtrTest, Movable) {
   math::CalculatorPtr a;
   math::CalculatorPtr b;
   MathCalculatorImpl calc_impl(GetProxy(&b));
 
   EXPECT_TRUE(!a);
   EXPECT_FALSE(!b);
 
-  a = b.Pass();
+  a = std::move(b);
 
   EXPECT_FALSE(!a);
   EXPECT_TRUE(!b);
 }
 
 TEST_F(InterfacePtrTest, Resettable) {
   math::CalculatorPtr a;
 
   EXPECT_TRUE(!a);
 
   MessagePipe pipe;
 
   // Save this so we can test it later.
   Handle handle = pipe.handle0.get();
 
-  a = MakeProxy(InterfacePtrInfo<math::Calculator>(pipe.handle0.Pass(), 0u));
+  a = MakeProxy(
+      InterfacePtrInfo<math::Calculator>(std::move(pipe.handle0), 0u));
 
   EXPECT_FALSE(!a);
 
   a.reset();
 
   EXPECT_TRUE(!a);
   EXPECT_FALSE(a.internal_state()->is_bound());
 
   // Test that handle was closed.
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, CloseRaw(handle));
 }
 
 TEST_F(InterfacePtrTest, BindInvalidHandle) {
   math::CalculatorPtr ptr;
   EXPECT_FALSE(ptr.get());
   EXPECT_FALSE(ptr);
 
   ptr.Bind(InterfacePtrInfo<math::Calculator>());
   EXPECT_FALSE(ptr.get());
   EXPECT_FALSE(ptr);
 }
 
 TEST_F(InterfacePtrTest, EncounteredError) {
   math::CalculatorPtr proxy;
   MathCalculatorImpl calc_impl(GetProxy(&proxy));
 
-  MathCalculatorUI calculator_ui(proxy.Pass());
+  MathCalculatorUI calculator_ui(std::move(proxy));
 
   calculator_ui.Add(2.0);
   PumpMessages();
   EXPECT_EQ(2.0, calculator_ui.GetOutput());
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   calculator_ui.Multiply(5.0);
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   // Close the server.
   calc_impl.CloseMessagePipe();
 
   // The state change isn't picked up locally yet.
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   PumpMessages();
 
   // OK, now we see the error.
   EXPECT_TRUE(calculator_ui.encountered_error());
 }
 
 TEST_F(InterfacePtrTest, EncounteredErrorCallback) {
   math::CalculatorPtr proxy;
   MathCalculatorImpl calc_impl(GetProxy(&proxy));
 
   bool encountered_error = false;
   proxy.set_connection_error_handler(
       [&encountered_error]() { encountered_error = true; });
 
-  MathCalculatorUI calculator_ui(proxy.Pass());
+  MathCalculatorUI calculator_ui(std::move(proxy));
 
   calculator_ui.Add(2.0);
   PumpMessages();
   EXPECT_EQ(2.0, calculator_ui.GetOutput());
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   calculator_ui.Multiply(5.0);
   EXPECT_FALSE(calculator_ui.encountered_error());
 
   // Close the server.
@@ skipping 12 matching lines @@
   EXPECT_TRUE(encountered_error);
 }
 
 TEST_F(InterfacePtrTest, DestroyInterfacePtrOnMethodResponse) {
   math::CalculatorPtr proxy;
   MathCalculatorImpl calc_impl(GetProxy(&proxy));
 
   EXPECT_EQ(0, SelfDestructingMathCalculatorUI::num_instances());
 
   SelfDestructingMathCalculatorUI* impl =
-      new SelfDestructingMathCalculatorUI(proxy.Pass());
+      new SelfDestructingMathCalculatorUI(std::move(proxy));
   impl->BeginTest(false);
 
   PumpMessages();
 
   EXPECT_EQ(0, SelfDestructingMathCalculatorUI::num_instances());
 }
 
 TEST_F(InterfacePtrTest, NestedDestroyInterfacePtrOnMethodResponse) {
   math::CalculatorPtr proxy;
   MathCalculatorImpl calc_impl(GetProxy(&proxy));
 
   EXPECT_EQ(0, SelfDestructingMathCalculatorUI::num_instances());
 
   SelfDestructingMathCalculatorUI* impl =
-      new SelfDestructingMathCalculatorUI(proxy.Pass());
+      new SelfDestructingMathCalculatorUI(std::move(proxy));
   impl->BeginTest(true);
 
   PumpMessages();
 
   EXPECT_EQ(0, SelfDestructingMathCalculatorUI::num_instances());
 }
 
 TEST_F(InterfacePtrTest, ReentrantWaitForIncomingMethodCall) {
   sample::ServicePtr proxy;
   ReentrantServiceImpl impl(GetProxy(&proxy));
@@ skipping 55 matching lines @@
   EXPECT_EQ(456, impl.integer());
 }
 
 class StrongMathCalculatorImpl : public math::Calculator {
  public:
   StrongMathCalculatorImpl(ScopedMessagePipeHandle handle,
                            bool* error_received,
                            bool* destroyed)
       : error_received_(error_received),
         destroyed_(destroyed),
-        binding_(this, handle.Pass()) {
+        binding_(this, std::move(handle)) {
     binding_.set_connection_error_handler(
         [this]() { *error_received_ = true; });
   }
   ~StrongMathCalculatorImpl() override { *destroyed_ = true; }
 
   // math::Calculator implementation.
   void Clear(const CalcCallback& callback) override { callback.Run(total_); }
 
   void Add(double value, const CalcCallback& callback) override {
     total_ += value;
@@ skipping 12 matching lines @@
 
   StrongBinding<math::Calculator> binding_;
 };
 
 TEST(StrongConnectorTest, Math) {
   base::MessageLoop loop(common::MessagePumpMojo::Create());
 
   bool error_received = false;
   bool destroyed = false;
   MessagePipe pipe;
-  new StrongMathCalculatorImpl(pipe.handle0.Pass(), &error_received,
+  new StrongMathCalculatorImpl(std::move(pipe.handle0), &error_received,
                                &destroyed);
 
   math::CalculatorPtr calc;
-  calc.Bind(InterfacePtrInfo<math::Calculator>(pipe.handle1.Pass(), 0u));
+  calc.Bind(InterfacePtrInfo<math::Calculator>(std::move(pipe.handle1), 0u));
 
   {
     // Suppose this is instantiated in a process that has the other end of the
     // message pipe.
-    MathCalculatorUI calculator_ui(calc.Pass());
+    MathCalculatorUI calculator_ui(std::move(calc));
 
     calculator_ui.Add(2.0);
     calculator_ui.Multiply(5.0);
 
     loop.RunUntilIdle();
 
     EXPECT_EQ(10.0, calculator_ui.GetOutput());
     EXPECT_FALSE(error_received);
     EXPECT_FALSE(destroyed);
   }
   // Destroying calculator_ui should close the pipe and generate an error on the
   // other
   // end which will destroy the instance since it is strongly bound.
 
   loop.RunUntilIdle();
   EXPECT_TRUE(error_received);
   EXPECT_TRUE(destroyed);
 }
 
 class WeakMathCalculatorImpl : public math::Calculator {
  public:
   WeakMathCalculatorImpl(ScopedMessagePipeHandle handle,
                          bool* error_received,
                          bool* destroyed)
       : error_received_(error_received),
         destroyed_(destroyed),
-        binding_(this, handle.Pass()) {
+        binding_(this, std::move(handle)) {
     binding_.set_connection_error_handler(
         [this]() { *error_received_ = true; });
   }
   ~WeakMathCalculatorImpl() override { *destroyed_ = true; }
 
   void Clear(const CalcCallback& callback) override { callback.Run(total_); }
 
   void Add(double value, const CalcCallback& callback) override {
     total_ += value;
     callback.Run(total_);
@@ skipping 11 matching lines @@
 
   Binding<math::Calculator> binding_;
 };
 
 TEST(WeakConnectorTest, Math) {
   base::MessageLoop loop(common::MessagePumpMojo::Create());
 
   bool error_received = false;
   bool destroyed = false;
   MessagePipe pipe;
-  WeakMathCalculatorImpl impl(pipe.handle0.Pass(), &error_received, &destroyed);
+  WeakMathCalculatorImpl impl(std::move(pipe.handle0), &error_received,
+                              &destroyed);
 
   math::CalculatorPtr calc;
-  calc.Bind(InterfacePtrInfo<math::Calculator>(pipe.handle1.Pass(), 0u));
+  calc.Bind(InterfacePtrInfo<math::Calculator>(std::move(pipe.handle1), 0u));
 
   {
     // Suppose this is instantiated in a process that has the other end of the
     // message pipe.
-    MathCalculatorUI calculator_ui(calc.Pass());
+    MathCalculatorUI calculator_ui(std::move(calc));
 
     calculator_ui.Add(2.0);
     calculator_ui.Multiply(5.0);
 
     loop.RunUntilIdle();
 
     EXPECT_EQ(10.0, calculator_ui.GetOutput());
     EXPECT_FALSE(error_received);
     EXPECT_FALSE(destroyed);
     // Destroying calculator_ui should close the pipe and generate an error on
     // the other
     // end which will destroy the instance since it is strongly bound.
   }
 
   loop.RunUntilIdle();
   EXPECT_TRUE(error_received);
   EXPECT_FALSE(destroyed);
 }
 
 class CImpl : public C {
  public:
   CImpl(bool* d_called, InterfaceRequest<C> request)
-      : d_called_(d_called),
-        binding_(this, request.Pass()) {}
+      : d_called_(d_called), binding_(this, std::move(request)) {}
   ~CImpl() override {}
 
  private:
   void D() override {
     *d_called_ = true;
   }
 
   bool* d_called_;
   StrongBinding<C> binding_;
 };
 
 class BImpl : public B {
  public:
   BImpl(bool* d_called, InterfaceRequest<B> request)
-      : d_called_(d_called),
-        binding_(this, request.Pass()) {}
+      : d_called_(d_called), binding_(this, std::move(request)) {}
   ~BImpl() override {}
 
  private:
   void GetC(InterfaceRequest<C> c) override {
-    new CImpl(d_called_, c.Pass());
+    new CImpl(d_called_, std::move(c));
   }
 
   bool* d_called_;
   StrongBinding<B> binding_;
 };
 
 class AImpl : public A {
  public:
   explicit AImpl(InterfaceRequest<A> request)
-      : d_called_(false),
-        binding_(this, request.Pass()) {}
+      : d_called_(false), binding_(this, std::move(request)) {}
   ~AImpl() override {}
 
   bool d_called() const { return d_called_; }
 
  private:
   void GetB(InterfaceRequest<B> b) override {
-    new BImpl(&d_called_, b.Pass());
+    new BImpl(&d_called_, std::move(b));
   }
 
   bool d_called_;
   Binding<A> binding_;
 };
 
 TEST_F(InterfacePtrTest, Scoping) {
   APtr a;
   AImpl a_impl(GetProxy(&a));
 
@@ skipping 10 matching lines @@
   // While B & C have fallen out of scope, the pipes will remain until they are
   // flushed.
   EXPECT_FALSE(a_impl.d_called());
   PumpMessages();
   EXPECT_TRUE(a_impl.d_called());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo