Add //mojo/edk/platform/thread_utils.* containing "yield" and "sleep".

mojo/edk/system/data_pipe_impl_unittest.cc

 // Copyright 2015 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 contains tests that are shared between different implementations of
 // |DataPipeImpl|.
 
 #include "mojo/edk/system/data_pipe_impl.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/logging.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
+#include "mojo/edk/platform/thread_utils.h"
 #include "mojo/edk/system/channel.h"
 #include "mojo/edk/system/channel_endpoint.h"
 #include "mojo/edk/system/data_pipe.h"
 #include "mojo/edk/system/data_pipe_consumer_dispatcher.h"
 #include "mojo/edk/system/data_pipe_producer_dispatcher.h"
 #include "mojo/edk/system/memory.h"
 #include "mojo/edk/system/message_pipe.h"
 #include "mojo/edk/system/raw_channel.h"
-#include "mojo/edk/system/test/sleep.h"
 #include "mojo/edk/system/test/test_io_thread.h"
 #include "mojo/edk/system/test/timeouts.h"
 #include "mojo/edk/system/waiter.h"
 #include "mojo/edk/util/ref_ptr.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using mojo::platform::ThreadSleep;
 using mojo::util::MakeRefCounted;
 using mojo::util::RefPtr;
 
 namespace mojo {
 namespace system {
 namespace {
 
 const MojoHandleSignals kAllSignals = MOJO_HANDLE_SIGNAL_READABLE |
                                       MOJO_HANDLE_SIGNAL_WRITABLE |
                                       MOJO_HANDLE_SIGNAL_PEER_CLOSED;
@@ skipping 1496 matching lines @@
 
   // TODO(vtl): Hack (see also the TODO above): We can't currently wait for a
   // specified amount of data to be available, so poll.
   for (size_t i = 0; i < kMaxPoll; i++) {
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
               this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
     if (num_bytes >= 10u * sizeof(int32_t))
       break;
 
-    test::Sleep(test::EpsilonTimeout());
+    ThreadSleep(test::EpsilonTimeout());
   }
   EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
 
   // Read half.
   num_bytes = 5u * sizeof(int32_t);
   memset(buffer, 0xab, sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerReadData(UserPointer<void>(buffer),
                                    MakeUserPointer(&num_bytes), true, false));
   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
@@ skipping 166 matching lines @@
         UserPointer<const void>(&test_data[20 + total_num_bytes]),
         MakeUserPointer(&num_bytes), false);
     if (result == MOJO_RESULT_OK) {
       total_num_bytes += num_bytes;
       if (total_num_bytes >= 90u)
         break;
     } else {
       EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, result);
     }
 
-    test::Sleep(test::EpsilonTimeout());
+    ThreadSleep(test::EpsilonTimeout());
   }
   EXPECT_EQ(90u, total_num_bytes);
 
   // TODO(vtl): (See corresponding TODO in TwoPhaseAllOrNone.)
   for (size_t i = 0; i < kMaxPoll; i++) {
     // We have 100.
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
               this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
     if (num_bytes >= 100u)
       break;
 
-    test::Sleep(test::EpsilonTimeout());
+    ThreadSleep(test::EpsilonTimeout());
   }
   EXPECT_EQ(100u, num_bytes);
 
   if (this->IsStrictCircularBuffer()) {
     // Check that a two-phase read can now only read (at most) 90 bytes. (This
     // checks an implementation detail; this behavior is not guaranteed.)
     const void* read_buffer_ptr = nullptr;
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
               this->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
@@ skipping 57 matching lines @@
   EXPECT_GT(num_bytes, 0u);
 
   // TODO(vtl): (See corresponding TODO in TwoPhaseAllOrNone.)
   for (size_t i = 0; i < kMaxPoll; i++) {
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
               this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
     if (num_bytes >= 2u * kTestDataSize)
       break;
 
-    test::Sleep(test::EpsilonTimeout());
+    ThreadSleep(test::EpsilonTimeout());
   }
   EXPECT_EQ(2u * kTestDataSize, num_bytes);
 
   // Start two-phase read.
   const void* read_buffer_ptr = nullptr;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
                                         MakeUserPointer(&num_bytes)));
   EXPECT_TRUE(read_buffer_ptr);
@@ skipping 463 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(0u, num_bytes);
 
   // Try "ending" a two-phase write when one isn't active.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             this->ProducerEndWriteData(1u * sizeof(int32_t)));
 
   // Wait a bit, to make sure that if a signal were (incorrectly) sent, it'd
   // have time to propagate.
-  test::Sleep(test::EpsilonTimeout());
+  ThreadSleep(test::EpsilonTimeout());
 
   // Still no data.
   num_bytes = 1000u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(0u, num_bytes);
 
   // Try ending a two-phase write with an invalid amount (too much).
   void* write_ptr = nullptr;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
                                          MakeUserPointer(&num_bytes)));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             this->ProducerEndWriteData(num_bytes +
                                        static_cast<uint32_t>(sizeof(int32_t))));
 
   // But the two-phase write still ended.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, this->ProducerEndWriteData(0u));
 
   // Wait a bit (as above).
-  test::Sleep(test::EpsilonTimeout());
+  ThreadSleep(test::EpsilonTimeout());
 
   // Still no data.
   num_bytes = 1000u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(0u, num_bytes);
 
   // Try ending a two-phase write with an invalid amount (not a multiple of the
   // element size).
   write_ptr = nullptr;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
                                          MakeUserPointer(&num_bytes)));
   EXPECT_GE(num_bytes, 1u);
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, this->ProducerEndWriteData(1u));
 
   // But the two-phase write still ended.
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, this->ProducerEndWriteData(0u));
 
   // Wait a bit (as above).
-  test::Sleep(test::EpsilonTimeout());
+  ThreadSleep(test::EpsilonTimeout());
 
   // Still no data.
   num_bytes = 1000u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(0u, num_bytes);
 
   // Add waiter.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
@@ skipping 95 matching lines @@
 
   // TODO(vtl): Hack: We can't currently wait for a specified amount of data to
   // be available, so poll.
   for (size_t i = 0; i < kMaxPoll; i++) {
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
               this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
     if (num_bytes >= kTestDataSize)
       break;
 
-    test::Sleep(test::EpsilonTimeout());
+    ThreadSleep(test::EpsilonTimeout());
   }
   EXPECT_EQ(kTestDataSize, num_bytes);
 
   const void* read_buffer_ptr = nullptr;
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
                                         MakeUserPointer(&num_bytes)));
   EXPECT_EQ(kTestDataSize, num_bytes);
   EXPECT_EQ(0, memcmp(read_buffer_ptr, kTestData, kTestDataSize));
 
   // Close the producer.
   this->ProducerClose();
 
   // Note: This tiny sleep is to allow/encourage a certain race. In particular,
   // for the remote producer case in
   // |RemoteProducerDataPipeImpl::MarkDataAsConsumed()| (caused by
   // |ConsumerEndReadData()| below) we want |producer_open()| to be false but
   // the call to |channel_endpoint_->EnqueueMessage()| to fail. (This race can
   // occur without the sleep, but is much less likely.)
-  test::Sleep(10u);
+  ThreadSleep(10u);
 
   EXPECT_EQ(MOJO_RESULT_OK, this->ConsumerEndReadData(num_bytes));
 
   this->ConsumerClose();
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo