Reland: Add some handle read/write helpers to mojo/common/test/test_utils.h

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>
-#include <stdint.h>
 #include <sys/socket.h>
-#include <unistd.h>
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #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/time/time.h"
+#include "mojo/common/test/test_utils.h"
 #include "mojo/system/embedder/platform_channel_pair.h"
 #include "mojo/system/embedder/platform_handle.h"
 #include "mojo/system/embedder/scoped_platform_handle.h"
 #include "mojo/system/message_in_transit.h"
 #include "mojo/system/test_utils.h"
 
 namespace mojo {
 namespace system {
 namespace {
 
@@ skipping 18 matching lines @@
 }
 
 void InitOnIOThread(RawChannel* raw_channel) {
   CHECK(raw_channel->Init());
 }
 
 bool WriteTestMessageToHandle(const embedder::PlatformHandle& handle,
                               uint32_t num_bytes) {
   scoped_ptr<MessageInTransit> message(MakeTestMessage(num_bytes));
 
-  ssize_t write_size = HANDLE_EINTR(
-     write(handle.fd, message->main_buffer(), message->main_buffer_size()));
-  bool result = write_size == static_cast<ssize_t>(message->main_buffer_size());
-  return result;
+  size_t write_size = 0;
+  mojo::test::BlockingWrite(
+      handle, message->main_buffer(), message->main_buffer_size(), &write_size);
+  return write_size == message->main_buffer_size();
 }
 
 // -----------------------------------------------------------------------------
 
 class RawChannelPosixTest : public test::TestWithIOThreadBase {
  public:
   RawChannelPosixTest() {}
   virtual ~RawChannelPosixTest() {}
 
   virtual void SetUp() OVERRIDE {
@@ skipping 43 matching lines @@
 class TestMessageReaderAndChecker {
  public:
   explicit TestMessageReaderAndChecker(embedder::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(handle_.fd, buffer, sizeof(buffer)));
-      if (read_size < 0) {
-        PCHECK(errno == EAGAIN || errno == EWOULDBLOCK);
-        read_size = 0;
-      }
+      size_t read_size = 0;
+      CHECK(mojo::test::NonBlockingRead(handle_, buffer, sizeof(buffer),
+                                        &read_size));
 
       // Append newly-read data to |bytes_|.
       bytes_.insert(bytes_.end(), buffer, buffer + read_size);
 
       // If we have the header....
       size_t message_size;
       if (MessageInTransit::GetNextMessageSize(bytes_.data(), bytes_.size(),
                                                &message_size)) {
         // If we've read the whole message....
         if (bytes_.size() >= message_size) {
@@ skipping 125 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(handles[1].get().fd, F_SETFL, 0) == 0);
-
   ReadCheckerRawChannelDelegate delegate;
   scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass(),
                                                &delegate,
                                                io_thread_message_loop()));
 
   test::PostTaskAndWait(io_thread_task_runner(),
                         FROM_HERE,
                         base::Bind(&InitOnIOThread, rc.get()));
 
   // Write and read, for a variety of sizes.
@@ skipping 173 matching lines @@
 
   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) {
   const size_t kMessageCount = 5;
 
-  // We're going to write to |fd(1)|. We'll do so in a blocking manner.
-  PCHECK(fcntl(handles[1].get().fd, F_SETFL, 0) == 0);
-
   FatalErrorRecordingRawChannelDelegate delegate(2 * kMessageCount);
   scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass(),
                                                &delegate,
                                                io_thread_message_loop()));
 
   test::PostTaskAndWait(io_thread_task_runner(),
                         FROM_HERE,
                         base::Bind(&InitOnIOThread, rc.get()));
 
   // Write into the other end a few messages.
@@ skipping 50 matching lines @@
                         FROM_HERE,
                         base::Bind(&RawChannel::Shutdown,
                                    base::Unretained(rc.get())));
 
   EXPECT_FALSE(rc->WriteMessage(MakeTestMessage(1)));
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo