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

mojo/public/cpp/bindings/tests/validation_unittest.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 <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
-
 #include <algorithm>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/message_loop/message_loop.h"
 #include "mojo/message_pump/message_pump_mojo.h"
 #include "mojo/public/c/system/macros.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
 #include "mojo/public/cpp/bindings/lib/connector.h"
 #include "mojo/public/cpp/bindings/lib/filter_chain.h"
 #include "mojo/public/cpp/bindings/lib/message_header_validator.h"
@@ skipping 176 matching lines @@
       : loop_(common::MessagePumpMojo::Create()),
         test_message_receiver_(nullptr) {}
 
   ~ValidationIntegrationTest() override {}
 
   void SetUp() override {
     ScopedMessagePipeHandle tester_endpoint;
     ASSERT_EQ(MOJO_RESULT_OK,
               CreateMessagePipe(nullptr, &tester_endpoint, &testee_endpoint_));
     test_message_receiver_ =
-        new TestMessageReceiver(this, tester_endpoint.Pass());
+        new TestMessageReceiver(this, std::move(tester_endpoint));
   }
 
   void TearDown() override {
     delete test_message_receiver_;
     test_message_receiver_ = nullptr;
 
     // Make sure that the other end receives the OnConnectionError()
     // notification.
     PumpMessages();
   }
 
   MessageReceiver* test_message_receiver() { return test_message_receiver_; }
 
-  ScopedMessagePipeHandle testee_endpoint() { return testee_endpoint_.Pass(); }
+  ScopedMessagePipeHandle testee_endpoint() {
+    return std::move(testee_endpoint_);
+  }
 
  private:
   class TestMessageReceiver : public MessageReceiver {
    public:
     TestMessageReceiver(ValidationIntegrationTest* owner,
                         ScopedMessagePipeHandle handle)
         : owner_(owner),
-          connector_(handle.Pass(),
+          connector_(std::move(handle),
                      mojo::internal::Connector::SINGLE_THREADED_SEND) {
       connector_.set_enforce_errors_from_incoming_receiver(false);
     }
     ~TestMessageReceiver() override {}
 
     bool Accept(Message* message) override {
       bool rv = connector_.Accept(message);
       owner_->PumpMessages();
       return rv;
     }
@@ skipping 173 matching lines @@
 
   RunValidationTests("resp_boundscheck_", validators.GetHead());
 }
 
 // Test that InterfacePtr<X> applies the correct validators and they don't
 // conflict with each other:
 //   - MessageHeaderValidator
 //   - X::ResponseValidator_
 TEST_F(ValidationIntegrationTest, InterfacePtr) {
   IntegrationTestInterfacePtr interface_ptr = MakeProxy(
-      InterfacePtrInfo<IntegrationTestInterface>(testee_endpoint().Pass(), 0u));
+      InterfacePtrInfo<IntegrationTestInterface>(testee_endpoint(), 0u));
   interface_ptr.internal_state()->EnableTestingMode();
 
   RunValidationTests("integration_intf_resp", test_message_receiver());
   RunValidationTests("integration_msghdr", test_message_receiver());
 }
 
 // Test that Binding<X> applies the correct validators and they don't
 // conflict with each other:
 //   - MessageHeaderValidator
 //   - X::RequestValidator_
 TEST_F(ValidationIntegrationTest, Binding) {
   IntegrationTestInterfaceImpl interface_impl;
   Binding<IntegrationTestInterface> binding(
       &interface_impl,
-      MakeRequest<IntegrationTestInterface>(testee_endpoint().Pass()));
+      MakeRequest<IntegrationTestInterface>(testee_endpoint()));
   binding.EnableTestingMode();
 
   RunValidationTests("integration_intf_rqst", test_message_receiver());
   RunValidationTests("integration_msghdr", test_message_receiver());
 }
 
 // Test pointer validation (specifically, that the encoded offset is 32-bit)
 TEST_F(ValidationTest, ValidateEncodedPointer) {
   uint64_t offset;
 
@@ skipping 37 matching lines @@
       static_cast<StructWithEnum::EnumWithin>(2)));
   EXPECT_TRUE(StructWithEnum::EnumWithin_IsValidValue(
       static_cast<StructWithEnum::EnumWithin>(3)));
   EXPECT_FALSE(StructWithEnum::EnumWithin_IsValidValue(
       static_cast<StructWithEnum::EnumWithin>(4)));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo