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

mojo/public/cpp/system/tests/macros_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.
 
 // This file tests the C++ Mojo system macros and consists of "positive" tests,
 // i.e., those verifying that things work (without compile errors, or even
 // warnings if warnings are treated as errors).
 // TODO(vtl): Maybe rename "MacrosCppTest" -> "MacrosTest" if/when this gets
 // compiled into a different binary from the C API tests.
 // TODO(vtl): Fix no-compile tests (which are all disabled; crbug.com/105388)
 // and write some "negative" tests.
 
-#include "mojo/public/cpp/system/macros.h"
-
 #include <assert.h>
 #include <stdint.h>
 #include <stdlib.h>
+#include <utility>
 
+#include "mojo/public/cpp/system/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 
 // The test for |MOJO_STATIC_CONST_MEMBER_DEFINITION| is really a compile/link
 // test. To test it fully would really require a header file and multiple .cc
 // files, but we'll just cursorily verify it.
 //
 // This is defined outside of an anonymous namespace because
 // MOJO_STATIC_CONST_MEMBER_DEFINITION may not be used on internal symbols.
@@ skipping 61 matching lines @@
 // defined in a local scope, so define these globally.
 class MoveOnlyInt {
   MOJO_MOVE_ONLY_TYPE(MoveOnlyInt)
 
  public:
   MoveOnlyInt() : is_set_(false), value_() {}
   explicit MoveOnlyInt(int value) : is_set_(true), value_(value) {}
   ~MoveOnlyInt() {}
 
   // Move-only constructor and operator=.
-  MoveOnlyInt(MoveOnlyInt&& other) { *this = other.Pass(); }
+  MoveOnlyInt(MoveOnlyInt&& other) { *this = std::move(other); }
   MoveOnlyInt& operator=(MoveOnlyInt&& other) {
     if (&other != this) {
       is_set_ = other.is_set_;
       value_ = other.value_;
       other.is_set_ = false;
     }
     return *this;
   }
 
   int value() const {
     assert(is_set());
     return value_;
   }
   bool is_set() const { return is_set_; }
 
  private:
   bool is_set_;
   int value_;
 };
 
 TEST(MacrosCppTest, MoveOnlyType) {
   MoveOnlyInt x(123);
   EXPECT_TRUE(x.is_set());
   EXPECT_EQ(123, x.value());
   MoveOnlyInt y;
   EXPECT_FALSE(y.is_set());
-  y = x.Pass();
+  y = std::move(x);
   EXPECT_FALSE(x.is_set());
   EXPECT_TRUE(y.is_set());
   EXPECT_EQ(123, y.value());
-  MoveOnlyInt z(y.Pass());
+  MoveOnlyInt z(std::move(y));
   EXPECT_FALSE(y.is_set());
   EXPECT_TRUE(z.is_set());
   EXPECT_EQ(123, z.value());
-  z = z.Pass();
-  EXPECT_TRUE(z.is_set());
-  EXPECT_EQ(123, z.value());
 }
 
 // Use it, to make sure things get linked in and to avoid any warnings about
 // unused things.
 TEST(MacrosCppTest, StaticConstMemberDefinition) {
   EXPECT_EQ(123, StructWithStaticConstMember::kStaticConstMember);
 }
 
 // The test for |ignore_result()| is also just a compilation test. (Note that
 // |MOJO_WARN_UNUSED_RESULT| can only be used in the prototype.
 int ReturnsIntYouMustUse() MOJO_WARN_UNUSED_RESULT;
 
 int ReturnsIntYouMustUse() {
   return 123;
 }
 
 TEST(MacrosCppTest, IgnoreResult) {
   ignore_result(ReturnsIntYouMustUse());
 }
 
 }  // namespace
 }  // namespace mojo