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

mojo/system/multiprocess_message_pipe_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): Enable this on non-POSIX once we have a non-POSIX implementation.
 #include "build/build_config.h"
 #if defined(OS_POSIX)
 
 #include <stdint.h>
 
@@ skipping 30 matching lines @@
   void PostTask(const tracked_objects::Location& from_here,
                 const base::Closure& task) {
     task_runner()->PostTask(from_here, task);
   }
 
   void PostTaskAndWait(const tracked_objects::Location& from_here,
                        const base::Closure& task) {
     test::PostTaskAndWait(task_runner(), from_here, task);
   }
 
-  void Init(ScopedPlatformHandle platform_handle,
+  void Init(embedder::ScopedPlatformHandle platform_handle,
             scoped_refptr<MessagePipe> mp) {
     io_thread_.StartWithOptions(
         base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
     PostTask(FROM_HERE,
              base::Bind(&IOThreadWrapper::InitOnIOThread,
                         base::Unretained(this),
                         base::Passed(&platform_handle), mp));
   }
 
   void Shutdown() {
     PostTaskAndWait(FROM_HERE,
                     base::Bind(&IOThreadWrapper::ShutdownOnIOThread,
                                base::Unretained(this)));
     io_thread_.Stop();
   }
 
   bool is_initialized() const { return !!channel_.get(); }
 
   base::MessageLoop* message_loop() {
     return io_thread_.message_loop();
   }
 
   scoped_refptr<base::TaskRunner> task_runner() {
     return message_loop()->message_loop_proxy();
   }
 
  private:
-  void InitOnIOThread(ScopedPlatformHandle platform_handle,
+  void InitOnIOThread(embedder::ScopedPlatformHandle platform_handle,
                       scoped_refptr<MessagePipe> mp) {
     CHECK_EQ(base::MessageLoop::current(), message_loop());
     CHECK(platform_handle.is_valid());
 
     // Create and initialize |Channel|.
     channel_ = new Channel();
     CHECK(channel_->Init(platform_handle.Pass()));
 
     // Attach the message pipe endpoint.
     // Note: On the "server" (parent process) side, we need not attach the
@@ skipping 55 matching lines @@
   mp->RemoveWaiter(0, &waiter);
   return wait_result;
 }
 
 // For each message received, sends a reply message with the same contents
 // repeated twice, until the other end is closed or it receives "quitquitquit"
 // (which it doesn't reply to). It'll return the number of messages received,
 // not including any "quitquitquit" message, modulo 100.
 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(EchoEcho) {
   IOThreadWrapper io_thread_wrapper;
-  ScopedPlatformHandle client_platform_handle =
+  embedder::ScopedPlatformHandle client_platform_handle =
       MultiprocessMessagePipeTest::client_platform_handle.Pass();
   CHECK(client_platform_handle.is_valid());
   scoped_refptr<MessagePipe> mp(new MessagePipe(
       scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()),
       scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint())));
   io_thread_wrapper.Init(client_platform_handle.Pass(), mp);
 
   const std::string quitquitquit("quitquitquit");
   int rv = 0;
   for (;; rv = (rv + 1) % 100) {
@@ skipping 122 matching lines @@
   mp->Close(0);
 
   EXPECT_EQ(static_cast<int>(kNumMessages % 100), WaitForChildShutdown());
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo
 
 #endif  // defined(OS_POSIX)