Add a Mojo EDK for Chrome that uses one OS pipe per message pipe.

mojo/edk/system/raw_channel_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.
 
 #include "mojo/edk/system/raw_channel.h"
 
 #include <stdint.h>
 #include <stdio.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/rand_util.h"
+#include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_io_thread.h"
 #include "base/threading/simple_thread.h"
 #include "build/build_config.h"  // TODO(vtl): Remove this.
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/platform_handle.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "mojo/edk/system/message_in_transit.h"
-#include "mojo/edk/system/mutex.h"
 #include "mojo/edk/system/test_utils.h"
 #include "mojo/edk/system/transport_data.h"
 #include "mojo/edk/test/test_utils.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace system {
 namespace {
 
@@ skipping 185 matching lines @@
   // |RawChannel::Delegate| implementation (called on the I/O thread):
   void OnReadMessage(
       const MessageInTransit::View& message_view,
       embedder::ScopedPlatformHandleVectorPtr platform_handles) override {
     EXPECT_FALSE(platform_handles);
 
     size_t position;
     size_t expected_size;
     bool should_signal = false;
     {
-      MutexLocker locker(&mutex_);
+      base::AutoLock locker(lock_);
       CHECK_LT(position_, expected_sizes_.size());
       position = position_;
       expected_size = expected_sizes_[position];
       position_++;
       if (position_ >= expected_sizes_.size())
         should_signal = true;
     }
 
     EXPECT_EQ(expected_size, message_view.num_bytes()) << position;
     if (message_view.num_bytes() == expected_size) {
       EXPECT_TRUE(
           CheckMessageData(message_view.bytes(), message_view.num_bytes()))
           << position;
     }
 
     if (should_signal)
       done_event_.Signal();
   }
   void OnError(Error error) override {
     // We'll get a read (shutdown) error when the connection is closed.
     CHECK_EQ(error, ERROR_READ_SHUTDOWN);
   }
 
   // Waits for all the messages (of sizes |expected_sizes_|) to be seen.
   void Wait() { done_event_.Wait(); }
 
   void SetExpectedSizes(const std::vector<uint32_t>& expected_sizes) {
-    MutexLocker locker(&mutex_);
+    base::AutoLock locker(lock_);
     CHECK_EQ(position_, expected_sizes_.size());
     expected_sizes_ = expected_sizes;
     position_ = 0;
   }
 
  private:
   base::WaitableEvent done_event_;
 
-  Mutex mutex_;
-  std::vector<uint32_t> expected_sizes_ MOJO_GUARDED_BY(mutex_);
-  size_t position_ MOJO_GUARDED_BY(mutex_);
+  base::Lock lock_;  // Protects the following members.
+  std::vector<uint32_t> expected_sizes_;
+  size_t position_;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(ReadCheckerRawChannelDelegate);
 };
 
 // Tests reading (writing using our own custom writer).
 TEST_F(RawChannelTest, OnReadMessage) {
   ReadCheckerRawChannelDelegate delegate;
   scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass()));
   io_thread()->PostTaskAndWait(
       FROM_HERE,
@@ skipping 563 matching lines @@
       FROM_HERE,
       base::Bind(&RawChannel::Shutdown, base::Unretained(rc_read.get())));
   io_thread()->PostTaskAndWait(
       FROM_HERE,
       base::Bind(&RawChannel::Shutdown, base::Unretained(rc_write.get())));
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo