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

mojo/public/cpp/system/tests/core_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 core wrappers.
 // TODO(vtl): Maybe rename "CoreCppTest" -> "CoreTest" if/when this gets
 // compiled into a different binary from the C API tests.
 
+#include <stddef.h>
+#include <map>
+#include <utility>
+
 #include "mojo/public/cpp/system/core.h"
-
-#include <stddef.h>
-
-#include <map>
-
 #include "mojo/public/cpp/system/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace {
 
 const MojoHandleSignals kSignalReadableWritable =
     MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE;
 
 const MojoHandleSignals kSignalAll = MOJO_HANDLE_SIGNAL_READABLE |
@@ skipping 70 matching lines @@
     // how to support the variations of |hash_map|.)
   }
 
   // |Handle|/|ScopedHandle| functions:
   {
     ScopedHandle h;
 
     EXPECT_EQ(kInvalidHandleValue, h.get().value());
 
     // This should be a no-op.
-    Close(h.Pass());
+    Close(std::move(h));
 
     // It should still be invalid.
     EXPECT_EQ(kInvalidHandleValue, h.get().value());
 
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               Wait(h.get(), ~MOJO_HANDLE_SIGNAL_NONE, 1000000, nullptr));
 
     std::vector<Handle> wh;
     wh.push_back(h.get());
     std::vector<MojoHandleSignals> sigs;
@@ skipping 89 matching lines @@
       EXPECT_EQ(MOJO_RESULT_OK, wait_many_result.result);
       EXPECT_EQ(1u, wait_many_result.index);
       EXPECT_TRUE(wait_many_result.IsIndexValid());
       EXPECT_TRUE(wait_many_result.AreSignalsStatesValid());
       EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, states[0].satisfied_signals);
       EXPECT_EQ(kSignalAll, states[0].satisfiable_signals);
       EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, states[1].satisfied_signals);
       EXPECT_EQ(kSignalAll, states[1].satisfiable_signals);
 
       // Test closing |h1| explicitly.
-      Close(h1.Pass());
+      Close(std::move(h1));
       EXPECT_FALSE(h1.get().is_valid());
 
       // Make sure |h1| is closed.
       EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
                 Wait(Handle(hv1), ~MOJO_HANDLE_SIGNAL_NONE,
                      MOJO_DEADLINE_INDEFINITE, nullptr));
 
       EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
                 Wait(h0.get(), MOJO_HANDLE_SIGNAL_READABLE,
                      MOJO_DEADLINE_INDEFINITE, &state));
@@ skipping 240 matching lines @@
   ScopedSharedBufferHandle buffer1;
   EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(nullptr, 1024, &buffer1));
   EXPECT_TRUE(buffer1.is_valid());
 
   ScopedSharedBufferHandle buffer2;
   EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(nullptr, 1024, &buffer2));
   EXPECT_TRUE(buffer2.is_valid());
 
   // If this fails to close buffer1, ScopedHandleBase::CloseIfNecessary() will
   // assert.
-  buffer1 = buffer2.Pass();
+  buffer1 = std::move(buffer2);
 
   EXPECT_TRUE(buffer1.is_valid());
   EXPECT_FALSE(buffer2.is_valid());
 }
 
-TEST(CoreCppTest, ScopedHandleMoveCtorSelf) {
-  ScopedSharedBufferHandle buffer1;
-  EXPECT_EQ(MOJO_RESULT_OK, CreateSharedBuffer(nullptr, 1024, &buffer1));
-  EXPECT_TRUE(buffer1.is_valid());
-
-  buffer1 = buffer1.Pass();

[dcheng, 2015/12/18 09:54:41]

Clang has a -Wself-move warning that this triggers. In particular, per
http://en.cppreference.com/w/cpp/utility/move, standard library objects called
with xvalue arguments (e.g. the result of std::move()) are allowed to assume
that a xvalue argument has the only reference to the object. This is obviously
not a standard library object, but given that convention, most move
operators/assignments don't check for self-assignment.

If it's critical to retain this test (and the one in macros_unittest.cc), it's
possible to test this with some shenanigans. Let me know what you think.

-
-  EXPECT_TRUE(buffer1.is_valid());
-}
-
 // TODO(vtl): Write data pipe tests.
 
 }  // namespace
 }  // namespace mojo