Mojo: Rename PlatformChannelHandle to PlatformHandle, etc.

mojo/system/raw_channel_posix_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.
 
 // TODO(vtl): Factor out the remaining POSIX-specific bits of this test (once we
 // have a non-POSIX implementation).
 
 #include "mojo/system/raw_channel.h"
 
 #include <fcntl.h>
@@ skipping 13 matching lines @@
 #include "base/message_loop/message_loop.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/rand_util.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"  // For |Sleep()|.
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "mojo/system/message_in_transit.h"
-#include "mojo/system/platform_channel.h"
-#include "mojo/system/platform_channel_handle.h"
 #include "mojo/system/platform_channel_pair.h"
+#include "mojo/system/platform_handle.h"
+#include "mojo/system/scoped_platform_handle.h"
 #include "mojo/system/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace system {
 namespace {
 
 MessageInTransit* MakeTestMessage(uint32_t num_bytes) {
   std::vector<unsigned char> bytes(num_bytes, 0);
   for (size_t i = 0; i < num_bytes; i++)
@@ skipping 25 matching lines @@
   }
 
   virtual ~RawChannelPosixTest() {
   }
 
   virtual void SetUp() OVERRIDE {
     io_thread_.StartWithOptions(
         base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
 
     PlatformChannelPair channel_pair;
-    scoped_ptr<PlatformChannel> server_channel(
-        channel_pair.CreateServerChannel());
-    CHECK(server_channel.get());
-    CHECK(server_channel->is_valid());
-    scoped_ptr<PlatformChannel> client_channel(
-        channel_pair.CreateClientChannel());
-    CHECK(client_channel.get());
-    CHECK(client_channel->is_valid());
-
-    handles_[0] = server_channel->PassHandle();
-    handles_[1] = client_channel->PassHandle();
+    handles[0] = channel_pair.PassServerHandle();
+    handles[1] = channel_pair.PassClientHandle();
   }
 
   virtual void TearDown() OVERRIDE {
-    if (handles_[0].is_valid())
-      close(handles_[0].fd);
-    if (handles_[1].is_valid())
-      close(handles_[1].fd);
+    handles[0].reset();
+    handles[1].reset();
 
     io_thread_.Stop();
   }
 
  protected:
-  int fd(size_t i) { return handles_[i].fd; }
-  void clear_fd(size_t i) { handles_[i] = PlatformChannelHandle(); }
-
   base::MessageLoop* io_thread_message_loop() {
     return io_thread_.message_loop();
   }
 
   scoped_refptr<base::TaskRunner> io_thread_task_runner() {
     return io_thread_message_loop()->message_loop_proxy();
   }
 
+  ScopedPlatformHandle handles[2];
+
  private:
   base::Thread io_thread_;
-  PlatformChannelHandle handles_[2];
 
   DISALLOW_COPY_AND_ASSIGN(RawChannelPosixTest);
 };
 
 // RawChannelPosixTest.WriteMessage --------------------------------------------
 
 class WriteOnlyRawChannelDelegate : public RawChannel::Delegate {
  public:
   WriteOnlyRawChannelDelegate() {}
   virtual ~WriteOnlyRawChannelDelegate() {}
 
   // |RawChannel::Delegate| implementation:
   virtual void OnReadMessage(const MessageInTransit& /*message*/) OVERRIDE {
     NOTREACHED();
   }
   virtual void OnFatalError(FatalError /*fatal_error*/) OVERRIDE {
     NOTREACHED();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WriteOnlyRawChannelDelegate);
 };
 
 static const int64_t kMessageReaderSleepMs = 1;
 static const size_t kMessageReaderMaxPollIterations = 3000;
 
 class TestMessageReaderAndChecker {
  public:
-  explicit TestMessageReaderAndChecker(int fd) : fd_(fd) {}
+  explicit TestMessageReaderAndChecker(PlatformHandle handle)
+      : handle_(handle) {}
   ~TestMessageReaderAndChecker() { CHECK(bytes_.empty()); }
 
   bool ReadAndCheckNextMessage(uint32_t expected_size) {
     unsigned char buffer[4096];
 
     for (size_t i = 0; i < kMessageReaderMaxPollIterations;) {
-      ssize_t read_size = HANDLE_EINTR(read(fd_, buffer, sizeof(buffer)));
+      ssize_t read_size = HANDLE_EINTR(
+          read(handle_.fd, buffer, sizeof(buffer)));
       if (read_size < 0) {
         PCHECK(errno == EAGAIN || errno == EWOULDBLOCK);
         read_size = 0;
       }
 
       // Append newly-read data to |bytes_|.
       bytes_.insert(bytes_.end(), buffer, buffer + read_size);
 
       // If we have the header....
       if (bytes_.size() >= sizeof(MessageInTransit)) {
@@ skipping 28 matching lines @@
         base::PlatformThread::Sleep(
             base::TimeDelta::FromMilliseconds(kMessageReaderSleepMs));
       }
     }
 
     LOG(ERROR) << "Too many iterations.";
     return false;
   }
 
  private:
-  const int fd_;
+  const PlatformHandle handle_;
 
   // The start of the received data should always be on a message boundary.
   std::vector<unsigned char> bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMessageReaderAndChecker);
 };
 
 // Tests writing (and verifies reading using our own custom reader).
 TEST_F(RawChannelPosixTest, WriteMessage) {
   WriteOnlyRawChannelDelegate delegate;
-  scoped_ptr<RawChannel> rc(RawChannel::Create(PlatformChannelHandle(fd(0)),
+  scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass(),
                                                &delegate,
                                                io_thread_message_loop()));
-  // |RawChannel::Create()| takes ownership of the FD.
-  clear_fd(0);
 
-  TestMessageReaderAndChecker checker(fd(1));
+  TestMessageReaderAndChecker checker(handles[1].get());
 
   test::PostTaskAndWait(io_thread_task_runner(),
                         FROM_HERE,
                         base::Bind(&InitOnIOThread, rc.get()));
 
   // Write and read, for a variety of sizes.
   for (uint32_t size = 1; size < 5 * 1000 * 1000; size += size / 2 + 1) {
     EXPECT_TRUE(rc->WriteMessage(MakeTestMessage(size)));
     EXPECT_TRUE(checker.ReadAndCheckNextMessage(size)) << size;
   }
@@ skipping 65 matching lines @@
   base::Lock lock_;  // Protects the following members.
   std::vector<uint32_t> expected_sizes_;
   size_t position_;
 
   DISALLOW_COPY_AND_ASSIGN(ReadCheckerRawChannelDelegate);
 };
 
 // Tests reading (writing using our own custom writer).
 TEST_F(RawChannelPosixTest, OnReadMessage) {
   // We're going to write to |fd(1)|. We'll do so in a blocking manner.
-  PCHECK(fcntl(fd(1), F_SETFL, 0) == 0);
+  PCHECK(fcntl(handles[1].get().fd, F_SETFL, 0) == 0);
 
   ReadCheckerRawChannelDelegate delegate;
-  scoped_ptr<RawChannel> rc(RawChannel::Create(PlatformChannelHandle(fd(0)),
+  scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass(),
                                                &delegate,
                                                io_thread_message_loop()));
-  // |RawChannel::Create()| takes ownership of the FD.
-  clear_fd(0);
 
   test::PostTaskAndWait(io_thread_task_runner(),
                         FROM_HERE,
                         base::Bind(&InitOnIOThread, rc.get()));
 
   // Write and read, for a variety of sizes.
   for (uint32_t size = 1; size < 5 * 1000 * 1000; size += size / 2 + 1) {
     delegate.SetExpectedSizes(std::vector<uint32_t>(1, size));
     MessageInTransit* message = MakeTestMessage(size);
 
     ssize_t write_size = HANDLE_EINTR(
-        write(fd(1), message, message->size_with_header_and_padding()));
+        write(handles[1].get().fd, message,
+              message->size_with_header_and_padding()));
     EXPECT_EQ(static_cast<ssize_t>(message->size_with_header_and_padding()),
               write_size);
     message->Destroy();
     delegate.Wait();
   }
 
   // Set up reader and write as fast as we can.
   // Write/queue and read afterwards, for a variety of sizes.
   std::vector<uint32_t> expected_sizes;
   for (uint32_t size = 1; size < 5 * 1000 * 1000; size += size / 2 + 1)
     expected_sizes.push_back(size);
   delegate.SetExpectedSizes(expected_sizes);
   for (uint32_t size = 1; size < 5 * 1000 * 1000; size += size / 2 + 1) {
     MessageInTransit* message = MakeTestMessage(size);
     ssize_t write_size = HANDLE_EINTR(
-        write(fd(1), message, message->size_with_header_and_padding()));
+        write(handles[1].get().fd, message,
+              message->size_with_header_and_padding()));
     EXPECT_EQ(static_cast<ssize_t>(message->size_with_header_and_padding()),
               write_size);
     message->Destroy();
   }
   delegate.Wait();
 
   test::PostTaskAndWait(io_thread_task_runner(),
                         FROM_HERE,
                         base::Bind(&RawChannel::Shutdown,
                                    base::Unretained(rc.get())));
@@ skipping 63 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ReadCountdownRawChannelDelegate);
 };
 
 TEST_F(RawChannelPosixTest, WriteMessageAndOnReadMessage) {
   static const size_t kNumWriterThreads = 10;
   static const size_t kNumWriteMessagesPerThread = 4000;
 
   WriteOnlyRawChannelDelegate writer_delegate;
   scoped_ptr<RawChannel> writer_rc(
-      RawChannel::Create(PlatformChannelHandle(fd(0)),
-                                               &writer_delegate,
-                                               io_thread_message_loop()));
-  // |RawChannel::Create()| takes ownership of the FD.
-  clear_fd(0);
+      RawChannel::Create(handles[0].Pass(),
+                         &writer_delegate,
+                         io_thread_message_loop()));
 
   test::PostTaskAndWait(io_thread_task_runner(),
                         FROM_HERE,
                         base::Bind(&InitOnIOThread, writer_rc.get()));
 
   ReadCountdownRawChannelDelegate reader_delegate(
       kNumWriterThreads * kNumWriteMessagesPerThread);
   scoped_ptr<RawChannel> reader_rc(
-      RawChannel::Create(PlatformChannelHandle(fd(1)),
-                                               &reader_delegate,
-                                               io_thread_message_loop()));
-  // |RawChannel::Create()| takes ownership of the FD.
-  clear_fd(1);
+      RawChannel::Create(handles[1].Pass(),
+                         &reader_delegate,
+                         io_thread_message_loop()));
 
   test::PostTaskAndWait(io_thread_task_runner(),
                         FROM_HERE,
                         base::Bind(&InitOnIOThread, reader_rc.get()));
 
   {
     ScopedVector<RawChannelWriterThread> writer_threads;
     for (size_t i = 0; i < kNumWriterThreads; i++) {
       writer_threads.push_back(new RawChannelWriterThread(
           writer_rc.get(), kNumWriteMessagesPerThread));
@@ skipping 54 matching lines @@
   FatalError last_fatal_error_;
 
   DISALLOW_COPY_AND_ASSIGN(FatalErrorRecordingRawChannelDelegate);
 };
 
 // Tests fatal errors.
 // TODO(vtl): Figure out how to make reading fail reliably. (I'm not convinced
 // that it does.)
 TEST_F(RawChannelPosixTest, OnFatalError) {
   FatalErrorRecordingRawChannelDelegate delegate;
-  scoped_ptr<RawChannel> rc(RawChannel::Create(PlatformChannelHandle(fd(0)),
+  scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass(),
                                                &delegate,
                                                io_thread_message_loop()));
-  // |RawChannel::Create()| takes ownership of the FD.
-  clear_fd(0);
 
   test::PostTaskAndWait(io_thread_task_runner(),
                         FROM_HERE,
                         base::Bind(&InitOnIOThread, rc.get()));
 
   // Close the other end, which should make writing fail.
-  CHECK_EQ(close(fd(1)), 0);
-  clear_fd(1);
+  handles[1].reset();
 
   EXPECT_FALSE(rc->WriteMessage(MakeTestMessage(1)));
 
   // TODO(vtl): In theory, it's conceivable that closing the other end might
   // lead to read failing. In practice, it doesn't seem to.
   EXPECT_EQ(RawChannel::Delegate::FATAL_ERROR_FAILED_WRITE,
             delegate.WaitForFatalError());
 
   test::PostTaskAndWait(io_thread_task_runner(),
                         FROM_HERE,
                         base::Bind(&RawChannel::Shutdown,
                                    base::Unretained(rc.get())));
 
 }
 
 // RawChannelPosixTest.WriteMessageAfterShutdown -------------------------------
 
 // Makes sure that calling |WriteMessage()| after |Shutdown()| behaves
 // correctly.
 TEST_F(RawChannelPosixTest, WriteMessageAfterShutdown) {
   WriteOnlyRawChannelDelegate delegate;
-  scoped_ptr<RawChannel> rc(RawChannel::Create(PlatformChannelHandle(fd(0)),
+  scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass(),
                                                &delegate,
                                                io_thread_message_loop()));
-  // |RawChannel::Create()| takes ownership of the FD.
-  clear_fd(0);
 
   test::PostTaskAndWait(io_thread_task_runner(),
                         FROM_HERE,
                         base::Bind(&InitOnIOThread, rc.get()));
   test::PostTaskAndWait(io_thread_task_runner(),
                         FROM_HERE,
                         base::Bind(&RawChannel::Shutdown,
                                    base::Unretained(rc.get())));
 
   EXPECT_FALSE(rc->WriteMessage(MakeTestMessage(1)));
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo