Mojo: Move platform handle/channel stuff in system to embedder namespace.

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 53 matching lines @@
 // -----------------------------------------------------------------------------
 
 class RawChannelPosixTest : public test::TestWithIOThreadBase {
  public:
   RawChannelPosixTest() {}
   virtual ~RawChannelPosixTest() {}
 
   virtual void SetUp() OVERRIDE {
     test::TestWithIOThreadBase::SetUp();
 
-    PlatformChannelPair channel_pair;
+    embedder::PlatformChannelPair channel_pair;
     handles[0] = channel_pair.PassServerHandle();
     handles[1] = channel_pair.PassClientHandle();
   }
 
   virtual void TearDown() OVERRIDE {
     handles[0].reset();
     handles[1].reset();
 
     test::TestWithIOThreadBase::TearDown();
   }
 
  protected:
-  ScopedPlatformHandle handles[2];
+  embedder::ScopedPlatformHandle handles[2];
 
  private:
   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(PlatformHandle handle)
+  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) {
@@ skipping 37 matching lines @@
         base::PlatformThread::Sleep(
             base::TimeDelta::FromMilliseconds(kMessageReaderSleepMs));
       }
     }
 
     LOG(ERROR) << "Too many iterations.";
     return false;
   }
 
  private:
-  const PlatformHandle handle_;
+  const embedder::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;
@@ skipping 335 matching lines @@
                         FROM_HERE,
                         base::Bind(&RawChannel::Shutdown,
                                    base::Unretained(rc.get())));
 
   EXPECT_FALSE(rc->WriteMessage(MakeTestMessage(1)));
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo