Convert IPC::ChannelMojo initialization to use new mojo::embedder::CreateChannelOnIOThread().

ipc/mojo/ipc_channel_mojo.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 "ipc/mojo/ipc_channel_mojo.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "ipc/ipc_listener.h"
@@ skipping 254 matching lines @@
     std::for_each(handles.begin(), handles.end(), &MojoClose);
     CloseWithError(write_result);
     return false;
   }
 
   return true;
 }
 
 //------------------------------------------------------------------------------
 
-// MessagePipeReader implemenation for control messages.
+// MessagePipeReader implementation for control messages.
 // Actual message handling is implemented by sublcasses.
 class ChannelMojo::ControlReader : public internal::MessagePipeReader {
  public:
   ControlReader(mojo::ScopedMessagePipeHandle pipe, ChannelMojo* owner)
       : internal::MessagePipeReader(pipe.Pass()),
         owner_(owner) {}
 
   virtual bool Connect() { return true; }
   virtual void OnPipeClosed() OVERRIDE;
   virtual void OnPipeError(MojoResult error) OVERRIDE;
@@ skipping 195 matching lines @@
           io_thread_task_runner)).PassAs<ChannelFactory>();
 }
 
 ChannelMojo::ChannelMojo(
     scoped_ptr<Channel> bootstrap, Mode mode, Listener* listener,
     scoped_refptr<base::TaskRunner> io_thread_task_runner)
     : weak_factory_(this),
       bootstrap_(bootstrap.Pass()),
       mode_(mode), listener_(listener),
       peer_pid_(base::kNullProcessId) {
-  DCHECK(mode_ == MODE_SERVER || mode_ == MODE_CLIENT);
-  mojo::ScopedMessagePipeHandle control_pipe
-      = mojo::embedder::CreateChannel(
-          mojo::embedder::ScopedPlatformHandle(
-              ToPlatformHandle(bootstrap_->TakePipeHandle())),
-          io_thread_task_runner,
-          base::Bind(&ChannelMojo::DidCreateChannel, base::Unretained(this)),
-          io_thread_task_runner);
-
-  // MessagePipeReader, that is crated in InitOnIOThread(), should live only in
-  // IO thread, but IPC::Channel can be instantiated outside of it.
-  // So we move the creation to the appropriate thread.
   if (base::MessageLoopProxy::current() == io_thread_task_runner) {
-    InitOnIOThread(control_pipe.Pass());
+    InitOnIOThread();
   } else {
-    io_thread_task_runner->PostTask(
-        FROM_HERE,
-        base::Bind(&ChannelMojo::InitOnIOThread,
-                   weak_factory_.GetWeakPtr(),
-                   base::Passed(control_pipe.Pass())));
+    io_thread_task_runner->PostTask(FROM_HERE,
+                                    base::Bind(&ChannelMojo::InitOnIOThread,
+                                               weak_factory_.GetWeakPtr()));
   }
 }
 
 ChannelMojo::~ChannelMojo() {
   Close();
 }
 
-void ChannelMojo::InitOnIOThread(mojo::ScopedMessagePipeHandle control_pipe) {
-  control_reader_ = CreateControlReader(control_pipe.Pass());
-}
+void ChannelMojo::InitOnIOThread() {
+  mojo::embedder::ChannelInfo* channel_info;
+  mojo::ScopedMessagePipeHandle control_pipe =
+      mojo::embedder::CreateChannelOnIOThread(
+          mojo::embedder::ScopedPlatformHandle(
+              ToPlatformHandle(bootstrap_->TakePipeHandle())),
+          &channel_info);
+  channel_info_.reset(channel_info);
 
-scoped_ptr<ChannelMojo::ControlReader> ChannelMojo::CreateControlReader(
-    mojo::ScopedMessagePipeHandle pipe) {
-  if (MODE_SERVER == mode_) {
-    return make_scoped_ptr(
-        new ServerControlReader(pipe.Pass(), this)).PassAs<ControlReader>();
+  switch (mode_) {
+    case MODE_SERVER:
+      control_reader_.reset(new ServerControlReader(control_pipe.Pass(), this));
+      break;
+    case MODE_CLIENT:
+      control_reader_.reset(new ClientControlReader(control_pipe.Pass(), this));
+      break;
+    default:
+      NOTREACHED();
+      break;
   }
-
-  DCHECK(mode_ == MODE_CLIENT);
-  return make_scoped_ptr(
-      new ClientControlReader(pipe.Pass(), this)).PassAs<ControlReader>();
 }
 
 bool ChannelMojo::Connect() {
   DCHECK(!message_reader_);
   return control_reader_->Connect();
 }
 
 void ChannelMojo::Close() {
   control_reader_.reset();
   message_reader_.reset();
@@ skipping 36 matching lines @@
 }
 
 base::ProcessId ChannelMojo::GetSelfPID() const {
   return bootstrap_->GetSelfPID();
 }
 
 ChannelHandle ChannelMojo::TakePipeHandle() {
   return bootstrap_->TakePipeHandle();
 }
 
-void ChannelMojo::DidCreateChannel(mojo::embedder::ChannelInfo* info) {
-  channel_info_.reset(info);
-}
-
 void ChannelMojo::OnMessageReceived(Message& message) {
   listener_->OnMessageReceived(message);
   if (message.dispatch_error())
     listener_->OnBadMessageReceived(message);
 }
 
 #if defined(OS_POSIX) && !defined(OS_NACL)
 int ChannelMojo::GetClientFileDescriptor() const {
   return bootstrap_->GetClientFileDescriptor();
 }
 
 int ChannelMojo::TakeClientFileDescriptor() {
   return bootstrap_->TakeClientFileDescriptor();
 }
 #endif  // defined(OS_POSIX) && !defined(OS_NACL)
 
 }  // namespace IPC