Mojo: Rename PlatformChannelHandle to PlatformHandle, etc.

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>
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/thread.h"
 #include "mojo/common/test/multiprocess_test_base.h"
 #include "mojo/system/channel.h"
 #include "mojo/system/local_message_pipe_endpoint.h"
 #include "mojo/system/message_pipe.h"
-#include "mojo/system/platform_channel.h"
 #include "mojo/system/proxy_message_pipe_endpoint.h"
+#include "mojo/system/scoped_platform_handle.h"
 #include "mojo/system/test_utils.h"
 #include "mojo/system/waiter.h"
 
 namespace mojo {
 namespace system {
 namespace {
 
 class IOThreadWrapper {
  public:
   IOThreadWrapper() : io_thread_("io_thread") {}
   ~IOThreadWrapper() {
     CHECK(!channel_.get());
     CHECK(!io_thread_.IsRunning());
   }
 
   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(PlatformChannel* platform_channel, scoped_refptr<MessagePipe> mp) {
+  void Init(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),
-                        platform_channel, mp));
+                        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(PlatformChannel* platform_channel,
+  void InitOnIOThread(ScopedPlatformHandle platform_handle,
                       scoped_refptr<MessagePipe> mp) {
     CHECK_EQ(base::MessageLoop::current(), message_loop());
-    CHECK(platform_channel);
-    CHECK(platform_channel->is_valid());
+    CHECK(platform_handle.is_valid());
 
     // Create and initialize |Channel|.
     channel_ = new Channel();
-    CHECK(channel_->Init(platform_channel->PassHandle()));
+    CHECK(channel_->Init(platform_handle.Pass()));
 
     // Attach the message pipe endpoint.
     // Note: On the "server" (parent process) side, we need not attach the
     // message pipe endpoint immediately. However, on the "client" (child
     // process) side, this *must* be done here -- otherwise, the |Channel| may
     // receive/process messages (which it can do as soon as it's hooked up to
     // the IO thread message loop, and that message loop runs) before the
     // message pipe endpoint is attached.
     CHECK_EQ(channel_->AttachMessagePipeEndpoint(mp, 1),
              Channel::kBootstrapEndpointId);
@@ skipping 18 matching lines @@
   MultiprocessMessagePipeTest() {}
   virtual ~MultiprocessMessagePipeTest() {}
 
   virtual void TearDown() OVERRIDE {
     if (io_thread_wrapper_.is_initialized())
       io_thread_wrapper_.Shutdown();
     mojo::test::MultiprocessTestBase::TearDown();
   }
 
   void Init(scoped_refptr<MessagePipe> mp) {
-    io_thread_wrapper_.Init(server_platform_channel.get(), mp);
+    io_thread_wrapper_.Init(server_platform_handle.Pass(), mp);
   }
 
  private:
   IOThreadWrapper io_thread_wrapper_;
 
   DISALLOW_COPY_AND_ASSIGN(MultiprocessMessagePipeTest);
 };
 
 MojoResult WaitIfNecessary(scoped_refptr<MessagePipe> mp, MojoWaitFlags flags) {
   Waiter waiter;
   waiter.Init();
 
   MojoResult add_result = mp->AddWaiter(0, &waiter, flags, MOJO_RESULT_OK);
   if (add_result != MOJO_RESULT_OK) {
     return (add_result == MOJO_RESULT_ALREADY_EXISTS) ? MOJO_RESULT_OK :
                                                         add_result;
   }
 
   MojoResult wait_result = waiter.Wait(MOJO_DEADLINE_INDEFINITE);
   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;
-  PlatformChannel* const client_platform_channel =
-      MultiprocessMessagePipeTest::client_platform_channel.get();
-  CHECK(client_platform_channel);
-  CHECK(client_platform_channel->is_valid());
+  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_channel, mp);
+  io_thread_wrapper.Init(client_platform_handle.Pass(), mp);
 
   const std::string quitquitquit("quitquitquit");
   int rv = 0;
   for (;; rv = (rv + 1) % 100) {
     // Wait for our end of the message pipe to be readable.
     MojoResult result = WaitIfNecessary(mp, MOJO_WAIT_FLAG_READABLE);
     if (result != MOJO_RESULT_OK) {
       // It was closed, probably.
       CHECK_EQ(result, MOJO_RESULT_FAILED_PRECONDITION);
       break;
@@ skipping 116 matching lines @@
   mp->Close(0);
 
   EXPECT_EQ(static_cast<int>(kNumMessages % 100), WaitForChildShutdown());
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo
 
 #endif  // defined(OS_POSIX)