ChannelMojo: Ensure that it always has ScopedIPCSupport

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 10 matching lines @@
 #include "ipc/ipc_platform_file_attachment_posix.h"
 #endif
 
 namespace IPC {
 
 namespace {
 
 class MojoChannelFactory : public ChannelFactory {
  public:
   MojoChannelFactory(ChannelMojo::Delegate* delegate,
+                     scoped_refptr<base::TaskRunner> io_runner,
                      ChannelHandle channel_handle,
                      Channel::Mode mode)
-      : delegate_(delegate), channel_handle_(channel_handle), mode_(mode) {}
+      : delegate_(delegate),
+        io_runner_(io_runner),
+        channel_handle_(channel_handle),
+        mode_(mode) {}
 
   std::string GetName() const override {
     return channel_handle_.name;
   }
 
   scoped_ptr<Channel> BuildChannel(Listener* listener) override {
-    return ChannelMojo::Create(delegate_, channel_handle_, mode_, listener);
+    return ChannelMojo::Create(delegate_, io_runner_, channel_handle_, mode_,
+                               listener);
   }
 
  private:
   ChannelMojo::Delegate* delegate_;
+  scoped_refptr<base::TaskRunner> io_runner_;
   ChannelHandle channel_handle_;
   Channel::Mode mode_;
 };
 
 //------------------------------------------------------------------------------
 
 class ClientChannelMojo : public ChannelMojo,
                           public ClientChannel,
                           public mojo::ErrorHandler {
  public:
   ClientChannelMojo(ChannelMojo::Delegate* delegate,
+                    scoped_refptr<base::TaskRunner> io_runner,
                     const ChannelHandle& handle,
                     Listener* listener);
   ~ClientChannelMojo() override;
   // MojoBootstrap::Delegate implementation
   void OnPipeAvailable(mojo::embedder::ScopedPlatformHandle handle) override;
   // mojo::ErrorHandler implementation
   void OnConnectionError() override;
   // ClientChannel implementation
   void Init(
       mojo::ScopedMessagePipeHandle pipe,
       int32_t peer_pid,
       const mojo::Callback<void(int32_t)>& callback) override;
 
  private:
   mojo::Binding<ClientChannel> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientChannelMojo);
 };
 
 ClientChannelMojo::ClientChannelMojo(ChannelMojo::Delegate* delegate,
+                                     scoped_refptr<base::TaskRunner> io_runner,
                                      const ChannelHandle& handle,
                                      Listener* listener)
-    : ChannelMojo(delegate, handle, Channel::MODE_CLIENT, listener),
+    : ChannelMojo(delegate, io_runner, handle, Channel::MODE_CLIENT, listener),
       binding_(this) {
 }
 
 ClientChannelMojo::~ClientChannelMojo() {
 }
 
 void ClientChannelMojo::OnPipeAvailable(
     mojo::embedder::ScopedPlatformHandle handle) {
   binding_.Bind(CreateMessagingPipe(handle.Pass()));
 }
 
 void ClientChannelMojo::OnConnectionError() {
   listener()->OnChannelError();
 }
 
 void ClientChannelMojo::Init(
     mojo::ScopedMessagePipeHandle pipe,
     int32_t peer_pid,
     const mojo::Callback<void(int32_t)>& callback) {
   InitMessageReader(pipe.Pass(), static_cast<base::ProcessId>(peer_pid));
   callback.Run(GetSelfPID());
 }
 
 //------------------------------------------------------------------------------
 
 class ServerChannelMojo : public ChannelMojo, public mojo::ErrorHandler {
  public:
   ServerChannelMojo(ChannelMojo::Delegate* delegate,
+                    scoped_refptr<base::TaskRunner> io_runner,
                     const ChannelHandle& handle,
                     Listener* listener);
   ~ServerChannelMojo() override;
 
   // MojoBootstrap::Delegate implementation
   void OnPipeAvailable(mojo::embedder::ScopedPlatformHandle handle) override;
   // mojo::ErrorHandler implementation
   void OnConnectionError() override;
   // Channel override
   void Close() override;
 
  private:
   // ClientChannelClient implementation
   void ClientChannelWasInitialized(int32_t peer_pid);
 
   mojo::InterfacePtr<ClientChannel> client_channel_;
   mojo::ScopedMessagePipeHandle message_pipe_;
 
   DISALLOW_COPY_AND_ASSIGN(ServerChannelMojo);
 };
 
 ServerChannelMojo::ServerChannelMojo(ChannelMojo::Delegate* delegate,
+                                     scoped_refptr<base::TaskRunner> io_runner,
                                      const ChannelHandle& handle,
                                      Listener* listener)
-    : ChannelMojo(delegate, handle, Channel::MODE_SERVER, listener) {
+    : ChannelMojo(delegate, io_runner, handle, Channel::MODE_SERVER, listener) {
 }
 
 ServerChannelMojo::~ServerChannelMojo() {
   Close();
 }
 
 void ServerChannelMojo::OnPipeAvailable(
     mojo::embedder::ScopedPlatformHandle handle) {
   mojo::ScopedMessagePipeHandle peer;
   MojoResult create_result =
@@ skipping 47 matching lines @@
 
 //------------------------------------------------------------------------------
 
 // static
 bool ChannelMojo::ShouldBeUsed() {
   // TODO(morrita): Remove this if it sticks.
   return true;
 }
 
 // static
-scoped_ptr<ChannelMojo> ChannelMojo::Create(ChannelMojo::Delegate* delegate,
-                                            const ChannelHandle& channel_handle,
-                                            Mode mode,
-                                            Listener* listener) {
+scoped_ptr<ChannelMojo> ChannelMojo::Create(
+    ChannelMojo::Delegate* delegate,
+    scoped_refptr<base::TaskRunner> io_runner,
+    const ChannelHandle& channel_handle,
+    Mode mode,
+    Listener* listener) {
   switch (mode) {
     case Channel::MODE_CLIENT:
       return make_scoped_ptr(
-          new ClientChannelMojo(delegate, channel_handle, listener));
+          new ClientChannelMojo(delegate, io_runner, channel_handle, listener));
     case Channel::MODE_SERVER:
       return make_scoped_ptr(
-          new ServerChannelMojo(delegate, channel_handle, listener));
+          new ServerChannelMojo(delegate, io_runner, channel_handle, listener));
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 // static
 scoped_ptr<ChannelFactory> ChannelMojo::CreateServerFactory(
     ChannelMojo::Delegate* delegate,
+    scoped_refptr<base::TaskRunner> io_runner,
     const ChannelHandle& channel_handle) {
-  return make_scoped_ptr(
-      new MojoChannelFactory(delegate, channel_handle, Channel::MODE_SERVER));
+  return make_scoped_ptr(new MojoChannelFactory(
+      delegate, io_runner, channel_handle, Channel::MODE_SERVER));
 }
 
 // static
 scoped_ptr<ChannelFactory> ChannelMojo::CreateClientFactory(
     ChannelMojo::Delegate* delegate,
+    scoped_refptr<base::TaskRunner> io_runner,
     const ChannelHandle& channel_handle) {
-  return make_scoped_ptr(
-      new MojoChannelFactory(delegate, channel_handle, Channel::MODE_CLIENT));
+  return make_scoped_ptr(new MojoChannelFactory(
+      delegate, io_runner, channel_handle, Channel::MODE_CLIENT));
 }
 
 ChannelMojo::ChannelMojo(ChannelMojo::Delegate* delegate,
+                         scoped_refptr<base::TaskRunner> io_runner,
                          const ChannelHandle& handle,
                          Mode mode,
                          Listener* listener)
     : mode_(mode),
       listener_(listener),
       peer_pid_(base::kNullProcessId),
       weak_factory_(this) {
   // Create MojoBootstrap after all members are set as it touches
   // ChannelMojo from a different thread.
   bootstrap_ = MojoBootstrap::Create(handle, mode, this);
-  if (delegate) {
-    if (delegate->GetIOTaskRunner() ==
-        base::MessageLoop::current()->message_loop_proxy()) {
-      InitDelegate(delegate);
-    } else {
-      delegate->GetIOTaskRunner()->PostTask(
-          FROM_HERE,
-          base::Bind(
-              &ChannelMojo::InitDelegate, base::Unretained(this), delegate));
-    }
+  if (io_runner == base::MessageLoop::current()->message_loop_proxy()) {
+    InitOnIOThread(delegate);
+  } else {
+    io_runner->PostTask(FROM_HERE,
+                        base::Bind(&ChannelMojo::InitOnIOThread,
+                                   base::Unretained(this), delegate));
   }
 }
 
 ChannelMojo::~ChannelMojo() {
   Close();
 }
 
-void ChannelMojo::InitDelegate(ChannelMojo::Delegate* delegate) {
+void ChannelMojo::InitOnIOThread(ChannelMojo::Delegate* delegate) {
   ipc_support_.reset(
       new ScopedIPCSupport(base::MessageLoop::current()->task_runner()));
+  if (!delegate)
+    return;
   delegate_ = delegate->ToWeakPtr();
   delegate_->OnChannelCreated(weak_factory_.GetWeakPtr());
 }
 
 mojo::ScopedMessagePipeHandle ChannelMojo::CreateMessagingPipe(
     mojo::embedder::ScopedPlatformHandle handle) {
   DCHECK(!channel_info_.get());
   mojo::embedder::ChannelInfo* channel_info;
   mojo::ScopedMessagePipeHandle pipe =
       mojo::embedder::CreateChannelOnIOThread(handle.Pass(), &channel_info);
@@ skipping 157 matching lines @@
     if (!ok) {
       LOG(ERROR) << "Failed to add new Mojo handle.";
       return MOJO_RESULT_UNKNOWN;
     }
   }
 
   return MOJO_RESULT_OK;
 }
 
 }  // namespace IPC