Update mojo sdk to rev 3d23dae011859a2aae49f1d1adde705c8e85d819

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 30 matching lines @@
   }
 
  private:
   ChannelMojo::Delegate* delegate_;
   ChannelHandle channel_handle_;
   Channel::Mode mode_;
 };
 
 //------------------------------------------------------------------------------
 
-class ClientChannelMojo
-    : public ChannelMojo,
-      public NON_EXPORTED_BASE(mojo::InterfaceImpl<ClientChannel>) {
+class ClientChannelMojo : public ChannelMojo,
+                          public ClientChannel,
+                          public mojo::ErrorHandler {
  public:
   ClientChannelMojo(ChannelMojo::Delegate* delegate,
                     const ChannelHandle& handle,
                     Listener* listener);
   ~ClientChannelMojo() override;
   // MojoBootstrap::Delegate implementation
   void OnPipeAvailable(mojo::embedder::ScopedPlatformHandle handle) override;
-  // InterfaceImpl implementation
+  // 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,
                                      const ChannelHandle& handle,
                                      Listener* listener)
-    : ChannelMojo(delegate, handle, Channel::MODE_CLIENT, listener) {
+    : ChannelMojo(delegate, handle, Channel::MODE_CLIENT, listener),
+      binding_(this) {
 }
 
 ClientChannelMojo::~ClientChannelMojo() {
 }
 
 void ClientChannelMojo::OnPipeAvailable(
     mojo::embedder::ScopedPlatformHandle handle) {
-  mojo::WeakBindToPipe(this, CreateMessagingPipe(handle.Pass()));
+  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,
                     const ChannelHandle& handle,
                     Listener* listener);
   ~ServerChannelMojo() override;
 
   // MojoBootstrap::Delegate implementation
   void OnPipeAvailable(mojo::embedder::ScopedPlatformHandle handle) override;
-  // ErrorHandler implementation
+  // 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_;
@@ skipping 53 matching lines @@
 }
 
 #endif
 
 } // namespace
 
 //------------------------------------------------------------------------------
 
 void ChannelMojo::ChannelInfoDeleter::operator()(
     mojo::embedder::ChannelInfo* ptr) const {
-  mojo::embedder::DestroyChannel(ptr);
+  mojo::embedder::DestroyChannel(ptr, base::Bind(&base::DoNothing), nullptr);
 }
 
 //------------------------------------------------------------------------------
 
 // static
 bool ChannelMojo::ShouldBeUsed() {
   // TODO(morrita): Remove this if it sticks.
   return true;
 }
 
@@ skipping 18 matching lines @@
 // static
 scoped_ptr<ChannelFactory> ChannelMojo::CreateServerFactory(
     ChannelMojo::Delegate* delegate,
     const ChannelHandle& channel_handle) {
   return make_scoped_ptr(
       new MojoChannelFactory(delegate, channel_handle, Channel::MODE_SERVER));
 }
 
 // static
 scoped_ptr<ChannelFactory> ChannelMojo::CreateClientFactory(
+    ChannelMojo::Delegate* delegate,
     const ChannelHandle& channel_handle) {
   return make_scoped_ptr(
-      new MojoChannelFactory(NULL, channel_handle, Channel::MODE_CLIENT));
+      new MojoChannelFactory(delegate, channel_handle, Channel::MODE_CLIENT));
 }
 
 ChannelMojo::ChannelMojo(ChannelMojo::Delegate* delegate,
                          const ChannelHandle& handle,
                          Mode mode,
                          Listener* listener)
     : mode_(mode),
       listener_(listener),
       peer_pid_(base::kNullProcessId),
       weak_factory_(this) {
@@ skipping 11 matching lines @@
               &ChannelMojo::InitDelegate, base::Unretained(this), delegate));
     }
   }
 }
 
 ChannelMojo::~ChannelMojo() {
   Close();
 }
 
 void ChannelMojo::InitDelegate(ChannelMojo::Delegate* delegate) {
+  ipc_support_.reset(
+      new ScopedIPCSupport(base::MessageLoop::current()->task_runner()));
   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);
   channel_info_.reset(channel_info);
   return pipe.Pass();
 }
 
 bool ChannelMojo::Connect() {
   DCHECK(!message_reader_);
   return bootstrap_->Connect();
 }
 
 void ChannelMojo::Close() {
   message_reader_.reset();
   channel_info_.reset();
+  ipc_support_.reset();
 }
 
 void ChannelMojo::OnBootstrapError() {
   listener_->OnChannelError();
 }
 
 void ChannelMojo::InitMessageReader(mojo::ScopedMessagePipeHandle pipe,
                                     int32_t peer_pid) {
   message_reader_ =
       make_scoped_ptr(new internal::MessagePipeReader(pipe.Pass(), this));
 
   for (size_t i = 0; i < pending_messages_.size(); ++i) {
     bool sent = message_reader_->Send(make_scoped_ptr(pending_messages_[i]));
-    pending_messages_[i] = NULL;
+    pending_messages_[i] = nullptr;
     if (!sent) {
       pending_messages_.clear();
       listener_->OnChannelError();
       return;
     }
   }
 
   pending_messages_.clear();
 
   set_peer_pid(peer_pid);
@@ skipping 120 matching lines @@
     if (!ok) {
       DLOG(ERROR) << "Failed to add new Mojo handle.";
       return MOJO_RESULT_UNKNOWN;
     }
   }
 
   return MOJO_RESULT_OK;
 }
 
 }  // namespace IPC