Remove "ScopedHandleBase<H>::operator H() const"

mojo/public/tests/system_core_cpp_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 "mojo/public/system/core_cpp.h"
 
 #include <map>
 
 #include "mojo/public/system/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 71 matching lines @@
 
     EXPECT_EQ(kInvalidHandleValue, h.get().value());
 
     // This should be a no-op.
     Close(h.Pass());
 
     // It should still be invalid.
     EXPECT_EQ(kInvalidHandleValue, h.get().value());
 
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              Wait(h, MOJO_WAIT_FLAG_EVERYTHING, 1000000));
+              Wait(h.get(), MOJO_WAIT_FLAG_EVERYTHING, 1000000));
 
     std::vector<Handle> wh;
-    wh.push_back(h);
+    wh.push_back(h.get());
     std::vector<MojoWaitFlags> wf;
     wf.push_back(MOJO_WAIT_FLAG_EVERYTHING);
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
               WaitMany(wh, wf, MOJO_DEADLINE_INDEFINITE));
   }
 
   // |MessagePipeHandle|/|ScopedMessagePipeHandle| functions:
   {
     MessagePipeHandle h_invalid;
     EXPECT_FALSE(h_invalid.is_valid());
@@ skipping 31 matching lines @@
       CreateMessagePipe(&h_0, &h_1);
       EXPECT_TRUE(h_0.get().is_valid());
       EXPECT_TRUE(h_1.get().is_valid());
       EXPECT_NE(h_0.get().value(), h_1.get().value());
       // Save the handle values, so we can check that things got closed
       // correctly.
       hv_0 = h_0.get().value();
       MojoHandle hv_1 = h_1.get().value();
 
       EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
-                Wait(h_0, MOJO_WAIT_FLAG_READABLE, 0));
+                Wait(h_0.get(), MOJO_WAIT_FLAG_READABLE, 0));
       std::vector<Handle> wh;
-      wh.push_back(h_0);
-      wh.push_back(h_1);
+      wh.push_back(h_0.get());
+      wh.push_back(h_1.get());
       std::vector<MojoWaitFlags> wf;
       wf.push_back(MOJO_WAIT_FLAG_READABLE);
       wf.push_back(MOJO_WAIT_FLAG_WRITABLE);
       EXPECT_EQ(1, WaitMany(wh, wf, 1000));
 
       // Test closing |h_1| explicitly.
       Close(h_1.Pass());
       EXPECT_FALSE(h_1.get().is_valid());
 
       // Make sure |h_1| is closed.
       EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
                 MojoWait(hv_1,
                          MOJO_WAIT_FLAG_EVERYTHING,
                          MOJO_DEADLINE_INDEFINITE));
 
       EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-                Wait(h_0, MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE));
+                Wait(h_0.get(), MOJO_WAIT_FLAG_READABLE,
+                     MOJO_DEADLINE_INDEFINITE));
     }
     // |hv_0| should have been closed when |h_0| went out of scope, so this
     // close should fail.
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(hv_0));
 
     // Actually test writing/reading messages.
     {
       ScopedMessagePipeHandle h_0;
       ScopedMessagePipeHandle h_1;
       CreateMessagePipe(&h_0, &h_1);
 
       const char kHello[] = "hello";
       const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
       EXPECT_EQ(MOJO_RESULT_OK,
-                WriteMessageRaw(h_0,
+                WriteMessageRaw(h_0.get(),
                                 kHello, kHelloSize,
                                 NULL, 0,
                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
       EXPECT_EQ(MOJO_RESULT_OK,
-                Wait(h_1, MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE));
+                Wait(h_1.get(), MOJO_WAIT_FLAG_READABLE,
+                     MOJO_DEADLINE_INDEFINITE));
       char buffer[10] = { 0 };
       uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
       EXPECT_EQ(MOJO_RESULT_OK,
-                ReadMessageRaw(h_1,
+                ReadMessageRaw(h_1.get(),
                                buffer, &buffer_size,
                                NULL, NULL,
                                MOJO_READ_MESSAGE_FLAG_NONE));
       EXPECT_EQ(kHelloSize, buffer_size);
       EXPECT_STREQ(kHello, buffer);
 
       // Send a handle over the previously-establish |MessagePipe|.
       ScopedMessagePipeHandle h_2;
       ScopedMessagePipeHandle h_3;
       CreateMessagePipe(&h_2, &h_3);
 
       // Write a message to |h_2|, before we send |h_3|.
       const char kWorld[] = "world!";
       const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
       EXPECT_EQ(MOJO_RESULT_OK,
-                WriteMessageRaw(h_2,
+                WriteMessageRaw(h_2.get(),
                                 kWorld, kWorldSize,
                                 NULL, 0,
                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
 
       // Send |h_3| over |h_1| to |h_0|.
       MojoHandle handles[5];
       handles[0] = h_3.release().value();
       EXPECT_NE(kInvalidHandleValue, handles[0]);
       EXPECT_FALSE(h_3.get().is_valid());
       uint32_t handles_count = 1;
       EXPECT_EQ(MOJO_RESULT_OK,
-                WriteMessageRaw(h_1,
+                WriteMessageRaw(h_1.get(),
                                 kHello, kHelloSize,
                                 handles, handles_count,
                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
       // |handles[0]| should actually be invalid now.
       EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(handles[0]));
 
       // Read "hello" and the sent handle.
       EXPECT_EQ(MOJO_RESULT_OK,
-                Wait(h_0, MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE));
+                Wait(h_0.get(), MOJO_WAIT_FLAG_READABLE,
+                     MOJO_DEADLINE_INDEFINITE));
       memset(buffer, 0, sizeof(buffer));
       buffer_size = static_cast<uint32_t>(sizeof(buffer));
       for (size_t i = 0; i < MOJO_ARRAYSIZE(handles); i++)
         handles[i] = kInvalidHandleValue;
       handles_count = static_cast<uint32_t>(MOJO_ARRAYSIZE(handles));
       EXPECT_EQ(MOJO_RESULT_OK,
-                ReadMessageRaw(h_0,
+                ReadMessageRaw(h_0.get(),
                                buffer, &buffer_size,
                                handles, &handles_count,
                                MOJO_READ_MESSAGE_FLAG_NONE));
       EXPECT_EQ(kHelloSize, buffer_size);
       EXPECT_STREQ(kHello, buffer);
       EXPECT_EQ(1u, handles_count);
       EXPECT_NE(kInvalidHandleValue, handles[0]);
 
       // Read from the sent/received handle.
       h_3.reset(MessagePipeHandle(handles[0]));
       // Save |handles[0]| to check that it gets properly closed.
       hv_0 = handles[0];
       EXPECT_EQ(MOJO_RESULT_OK,
-                Wait(h_3, MOJO_WAIT_FLAG_READABLE, MOJO_DEADLINE_INDEFINITE));
+                Wait(h_3.get(), MOJO_WAIT_FLAG_READABLE,
+                     MOJO_DEADLINE_INDEFINITE));
       memset(buffer, 0, sizeof(buffer));
       buffer_size = static_cast<uint32_t>(sizeof(buffer));
       for (size_t i = 0; i < MOJO_ARRAYSIZE(handles); i++)
         handles[i] = kInvalidHandleValue;
       handles_count = static_cast<uint32_t>(MOJO_ARRAYSIZE(handles));
       EXPECT_EQ(MOJO_RESULT_OK,
-                ReadMessageRaw(h_3,
+                ReadMessageRaw(h_3.get(),
                                buffer, &buffer_size,
                                handles, &handles_count,
                                MOJO_READ_MESSAGE_FLAG_NONE));
       EXPECT_EQ(kWorldSize, buffer_size);
       EXPECT_STREQ(kWorld, buffer);
       EXPECT_EQ(0u, handles_count);
     }
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(hv_0));
   }
 
@@ skipping 11 matching lines @@
 
     // Send a handle over the previously-establish |MessagePipe|.
     ScopedMessagePipeHandle h_2;
     ScopedMessagePipeHandle h_3;
     CreateMessagePipe(&h_2, &h_3);
 
     // Write a message to |h_2|, before we send |h_3|.
     const char kWorld[] = "world!";
     const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
     EXPECT_EQ(MOJO_RESULT_OK,
-              WriteMessageRaw(h_2,
+              WriteMessageRaw(h_2.get(),
                               kWorld, kWorldSize,
                               NULL, 0,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
     // And also a message to |h_3|.
     EXPECT_EQ(MOJO_RESULT_OK,
-              WriteMessageRaw(h_3,
+              WriteMessageRaw(h_3.get(),
                               kWorld, kWorldSize,
                               NULL, 0,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     // Send |h_3| over |h_1| to |h_0|.
     const char kHello[] = "hello";
     const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
     MojoHandle h_3_value;
     h_3_value = h_3.release().value();
     EXPECT_NE(kInvalidHandleValue, h_3_value);
     EXPECT_FALSE(h_3.get().is_valid());
     EXPECT_EQ(MOJO_RESULT_OK,
-              WriteMessageRaw(h_1,
+              WriteMessageRaw(h_1.get(),
                               kHello, kHelloSize,
                               &h_3_value, 1,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
     // |h_3_value| should actually be invalid now.
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(h_3_value));
 
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h_0.release().value()));
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h_1.release().value()));
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h_2.release().value()));
   }
 
   // Do this in a different order: make the enqueued |MessagePipe| handle only
   // half-alive.
   {
     ScopedMessagePipeHandle h_0;
     ScopedMessagePipeHandle h_1;
     CreateMessagePipe(&h_0, &h_1);
 
     // Send a handle over the previously-establish |MessagePipe|.
     ScopedMessagePipeHandle h_2;
     ScopedMessagePipeHandle h_3;
     CreateMessagePipe(&h_2, &h_3);
 
     // Write a message to |h_2|, before we send |h_3|.
     const char kWorld[] = "world!";
     const uint32_t kWorldSize = static_cast<uint32_t>(sizeof(kWorld));
     EXPECT_EQ(MOJO_RESULT_OK,
-              WriteMessageRaw(h_2,
+              WriteMessageRaw(h_2.get(),
                               kWorld, kWorldSize,
                               NULL, 0,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
     // And also a message to |h_3|.
     EXPECT_EQ(MOJO_RESULT_OK,
-              WriteMessageRaw(h_3,
+              WriteMessageRaw(h_3.get(),
                               kWorld, kWorldSize,
                               NULL, 0,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     // Send |h_3| over |h_1| to |h_0|.
     const char kHello[] = "hello";
     const uint32_t kHelloSize = static_cast<uint32_t>(sizeof(kHello));
     MojoHandle h_3_value;
     h_3_value = h_3.release().value();
     EXPECT_NE(kInvalidHandleValue, h_3_value);
     EXPECT_FALSE(h_3.get().is_valid());
     EXPECT_EQ(MOJO_RESULT_OK,
-              WriteMessageRaw(h_1,
+              WriteMessageRaw(h_1.get(),
                               kHello, kHelloSize,
                               &h_3_value, 1,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
     // |h_3_value| should actually be invalid now.
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, MojoClose(h_3_value));
 
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h_2.release().value()));
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h_0.release().value()));
     EXPECT_EQ(MOJO_RESULT_OK, MojoClose(h_1.release().value()));
   }
 }
 
 }  // namespace
 }  // namespace mojo