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

mojo/public/cpp/bindings/tests/binding_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.
 
 // Note: This file tests both binding.h (mojo::Binding) and strong_binding.h
 // (mojo::StrongBinding).
 
+#include "mojo/public/cpp/bindings/binding.h"
+
 #include <stdint.h>
+#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/cpp/system/macros.h"
 #include "mojo/public/interfaces/bindings/tests/sample_interfaces.mojom.h"
 #include "mojo/public/interfaces/bindings/tests/sample_service.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace {
 
 class BindingTestBase : public testing::Test {
@@ skipping 36 matching lines @@
 // BindingTest -----------------------------------------------------------------
 
 using BindingTest = BindingTestBase;
 
 TEST_F(BindingTest, Close) {
   bool called = false;
   sample::ServicePtr ptr;
   auto request = GetProxy(&ptr);
   ptr.set_connection_error_handler([&called]() { called = true; });
   ServiceImpl impl;
-  Binding<sample::Service> binding(&impl, request.Pass());
+  Binding<sample::Service> binding(&impl, std::move(request));
 
   binding.Close();
   EXPECT_FALSE(called);
   loop().RunUntilIdle();
   EXPECT_TRUE(called);
 }
 
 // Tests that destroying a mojo::Binding closes the bound message pipe handle.
 TEST_F(BindingTest, DestroyClosesMessagePipe) {
   bool encountered_error = false;
   ServiceImpl impl;
   sample::ServicePtr ptr;
   auto request = GetProxy(&ptr);
   ptr.set_connection_error_handler(
       [&encountered_error]() { encountered_error = true; });
   bool called = false;
   auto called_cb = [&called](int32_t result) { called = true; };
   {
-    Binding<sample::Service> binding(&impl, request.Pass());
+    Binding<sample::Service> binding(&impl, std::move(request));
     ptr->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr,
                    called_cb);
     loop().RunUntilIdle();
     EXPECT_TRUE(called);
     EXPECT_FALSE(encountered_error);
   }
   // Now that the Binding is out of scope we should detect an error on the other
   // end of the pipe.
   loop().RunUntilIdle();
   EXPECT_TRUE(encountered_error);
@@ skipping 41 matching lines @@
   // called.
   ptr.reset();
   loop().RunUntilIdle();
   EXPECT_FALSE(called);
 }
 
 class ServiceImplWithBinding : public ServiceImpl {
  public:
   ServiceImplWithBinding(bool* was_deleted,
                          InterfaceRequest<sample::Service> request)
-      : ServiceImpl(was_deleted), binding_(this, request.Pass()) {
+      : ServiceImpl(was_deleted), binding_(this, std::move(request)) {
     binding_.set_connection_error_handler([this]() { delete this; });
   }
 
  private:
   Binding<sample::Service> binding_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ServiceImplWithBinding);
 };
 
 // Tests that the binding may be deleted in the connection error handler.
@@ skipping 24 matching lines @@
   called = false;
   auto request = binding.Unbind();
   EXPECT_FALSE(binding.is_bound());
   // All calls should fail when not bound...
   ptr->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr,
                  called_cb);
   loop().RunUntilIdle();
   EXPECT_FALSE(called);
 
   called = false;
-  binding.Bind(request.Pass());
+  binding.Bind(std::move(request));
   EXPECT_TRUE(binding.is_bound());
   // ...and should succeed again when the rebound.
   ptr->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr,
                  called_cb);
   loop().RunUntilIdle();
   EXPECT_TRUE(called);
 }
 
 class IntegerAccessorImpl : public sample::IntegerAccessor {
  public:
@@ skipping 16 matching lines @@
   Binding<sample::IntegerAccessor> binding(&impl, &ptr);
   EXPECT_EQ(3u, ptr.version());
 }
 
 TEST_F(BindingTest, PauseResume) {
   bool called = false;
   auto called_cb = [&called](int32_t result) { called = true; };
   sample::ServicePtr ptr;
   auto request = GetProxy(&ptr);
   ServiceImpl impl;
-  Binding<sample::Service> binding(&impl, request.Pass());
+  Binding<sample::Service> binding(&impl, std::move(request));
   binding.PauseIncomingMethodCallProcessing();
   ptr->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr,
                  called_cb);
   EXPECT_FALSE(called);
   loop().RunUntilIdle();
   // Frobinate() should not be called as the binding is paused.
   EXPECT_FALSE(called);
 
   // Resume the binding, which should trigger processing.
   binding.ResumeIncomingMethodCallProcessing();
   loop().RunUntilIdle();
   EXPECT_TRUE(called);
 }
 
 // Verifies the connection error handler is not run while a binding is paused.
 TEST_F(BindingTest, ErrorHandleNotRunWhilePaused) {
   bool called = false;
   sample::ServicePtr ptr;
   auto request = GetProxy(&ptr);
   ServiceImpl impl;
-  Binding<sample::Service> binding(&impl, request.Pass());
+  Binding<sample::Service> binding(&impl, std::move(request));
   binding.set_connection_error_handler([&called]() { called = true; });
   binding.PauseIncomingMethodCallProcessing();
 
   ptr.reset();
   loop().RunUntilIdle();
   // The connection error handle should not be called as the binding is paused.
   EXPECT_FALSE(called);
 
   // Resume the binding, which should trigger the error handler.
   binding.ResumeIncomingMethodCallProcessing();
@@ skipping 11 matching lines @@
   bool encountered_error = false;
   bool was_deleted = false;
   ServiceImpl impl(&was_deleted);
   sample::ServicePtr ptr;
   auto request = GetProxy(&ptr);
   ptr.set_connection_error_handler(
       [&encountered_error]() { encountered_error = true; });
   bool called = false;
   auto called_cb = [&called](int32_t result) { called = true; };
   {
-    StrongBinding<sample::Service> binding(&impl, request.Pass());
+    StrongBinding<sample::Service> binding(&impl, std::move(request));
     ptr->Frobinate(nullptr, sample::Service::BAZ_OPTIONS_REGULAR, nullptr,
                    called_cb);
     loop().RunUntilIdle();
     EXPECT_TRUE(called);
     EXPECT_FALSE(encountered_error);
   }
   // Now that the StrongBinding is out of scope we should detect an error on the
   // other end of the pipe.
   loop().RunUntilIdle();
   EXPECT_TRUE(encountered_error);
   // But destroying the StrongBinding doesn't destroy the object.
   ASSERT_FALSE(was_deleted);
 }
 
 class ServiceImplWithStrongBinding : public ServiceImpl {
  public:
   ServiceImplWithStrongBinding(bool* was_deleted,
                                InterfaceRequest<sample::Service> request)
-      : ServiceImpl(was_deleted), binding_(this, request.Pass()) {}
+      : ServiceImpl(was_deleted), binding_(this, std::move(request)) {}
 
   StrongBinding<sample::Service>& binding() { return binding_; }
 
  private:
   StrongBinding<sample::Service> binding_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ServiceImplWithStrongBinding);
 };
 
 // Tests the typical case, where the implementation object owns the
@@ skipping 18 matching lines @@
 // pipe being closed). Also checks that the connection error handler doesn't get
 // called.
 TEST_F(StrongBindingTest, ExplicitDeleteImpl) {
   bool ptr_error_handler_called = false;
   sample::ServicePtr ptr;
   auto request = GetProxy(&ptr);
   ptr.set_connection_error_handler(
       [&ptr_error_handler_called]() { ptr_error_handler_called = true; });
   bool was_deleted = false;
   ServiceImplWithStrongBinding* impl =
-      new ServiceImplWithStrongBinding(&was_deleted, request.Pass());
+      new ServiceImplWithStrongBinding(&was_deleted, std::move(request));
   bool binding_error_handler_called = false;
   impl->binding().set_connection_error_handler(
       [&binding_error_handler_called]() {
         binding_error_handler_called = true;
       });
 
   loop().RunUntilIdle();
   EXPECT_FALSE(ptr_error_handler_called);
   EXPECT_FALSE(was_deleted);
 
   delete impl;
   EXPECT_FALSE(ptr_error_handler_called);
   EXPECT_TRUE(was_deleted);
   was_deleted = false;  // It shouldn't be double-deleted!
   loop().RunUntilIdle();
   EXPECT_TRUE(ptr_error_handler_called);
   EXPECT_FALSE(was_deleted);
 
   EXPECT_FALSE(binding_error_handler_called);
 }
 
 }  // namespace
 }  // mojo