Convert over to channel handles

ipc/ipc_channel_proxy.cc

 // Copyright (c) 2006-2008 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 "base/message_loop.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/thread.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_logging.h"
@@ skipping 47 matching lines @@
   delete this;
 }
 
 //------------------------------------------------------------------------------
 
 ChannelProxy::Context::Context(Channel::Listener* listener,
                                MessageLoop* ipc_message_loop)
     : listener_message_loop_(MessageLoop::current()),
       listener_(listener),
       ipc_message_loop_(ipc_message_loop),
-      channel_(NULL),
       peer_pid_(0),
       channel_connected_called_(false) {
 }
 
-void ChannelProxy::Context::CreateChannel(const std::string& id,
+void ChannelProxy::Context::CreateChannel(const IPC::ChannelHandle& handle,
                                           const Channel::Mode& mode) {
-  DCHECK(channel_ == NULL);
-  channel_id_ = id;
-  channel_ = new Channel(id, mode, this);
+  DCHECK(channel_.get() == NULL);
+  channel_id_ = handle.name;
+  channel_.reset(new Channel(handle, mode, this));
 }
 
 bool ChannelProxy::Context::TryFilters(const Message& message) {
 #ifdef IPC_MESSAGE_LOG_ENABLED
   Logging* logger = Logging::current();
   if (logger->Enabled())
     logger->OnPreDispatchMessage(message);
 #endif
 
   for (size_t i = 0; i < filters_.size(); ++i) {
@@ skipping 59 matching lines @@
   // Assume a reference to ourselves on behalf of this thread.  This reference
   // will be released when we are closed.
   AddRef();
 
   if (!channel_->Connect()) {
     OnChannelError();
     return;
   }
 
   for (size_t i = 0; i < filters_.size(); ++i)
-    filters_[i]->OnFilterAdded(channel_);
+    filters_[i]->OnFilterAdded(channel_.get());
 }
 
 // Called on the IPC::Channel thread
 void ChannelProxy::Context::OnChannelClosed() {
   // It's okay for IPC::ChannelProxy::Close to be called more than once, which
   // would result in this branch being taken.
-  if (!channel_)
+  if (!channel_.get())
     return;
 
   for (size_t i = 0; i < filters_.size(); ++i) {
     filters_[i]->OnChannelClosing();
     filters_[i]->OnFilterRemoved();
   }
 
   // We don't need the filters anymore.
   filters_.clear();
 
-  delete channel_;
-  channel_ = NULL;
+  channel_.reset();
 
   // Balance with the reference taken during startup.  This may result in
   // self-destruction.
   Release();
 }
 
 // Called on the IPC::Channel thread
 void ChannelProxy::Context::OnSendMessage(Message* message) {
-  if (!channel_) {
+  if (!channel_.get()) {
     delete message;
     OnChannelClosed();
     return;
   }
   if (!channel_->Send(message))
     OnChannelError();
 }
 
 // Called on the IPC::Channel thread
 void ChannelProxy::Context::OnAddFilter() {
   std::vector<scoped_refptr<MessageFilter> > filters;
   {
     AutoLock auto_lock(pending_filters_lock_);
     filters.swap(pending_filters_);
   }
 
   for (size_t i = 0; i < filters.size(); ++i) {
     filters_.push_back(filters[i]);
 
     // If the channel has already been created, then we need to send this
     // message so that the filter gets access to the Channel.
-    if (channel_)
-      filters[i]->OnFilterAdded(channel_);
+    if (channel_.get())
+      filters[i]->OnFilterAdded(channel_.get());
     // Ditto for the peer process id.
     if (peer_pid_)
       filters[i]->OnChannelConnected(peer_pid_);
   }
 }
 
 // Called on the IPC::Channel thread
 void ChannelProxy::Context::OnRemoveFilter(MessageFilter* filter) {
   for (size_t i = 0; i < filters_.size(); ++i) {
     if (filters_[i].get() == filter) {
@@ skipping 52 matching lines @@
 }
 
 // Called on the listener's thread
 void ChannelProxy::Context::OnDispatchError() {
   if (listener_)
     listener_->OnChannelError();
 }
 
 //-----------------------------------------------------------------------------
 
-ChannelProxy::ChannelProxy(const std::string& channel_id,
+ChannelProxy::ChannelProxy(const IPC::ChannelHandle& channel_handle,
                            Channel::Mode mode,
                            Channel::Listener* listener,
                            MessageLoop* ipc_thread)
     : context_(new Context(listener, ipc_thread)) {
-  Init(channel_id, mode, ipc_thread, true);
+  Init(channel_handle, mode, ipc_thread, true);
 }
 
-ChannelProxy::ChannelProxy(const std::string& channel_id,
+ChannelProxy::ChannelProxy(const IPC::ChannelHandle& channel_handle,
                            Channel::Mode mode,
                            MessageLoop* ipc_thread,
                            Context* context,
                            bool create_pipe_now)
     : context_(context) {
-  Init(channel_id, mode, ipc_thread, create_pipe_now);
+  Init(channel_handle, mode, ipc_thread, create_pipe_now);
 }
 
 ChannelProxy::~ChannelProxy() {
   Close();
 }
 
-void ChannelProxy::Init(const std::string& channel_id, Channel::Mode mode,
-                        MessageLoop* ipc_thread_loop, bool create_pipe_now) {
+void ChannelProxy::Init(const IPC::ChannelHandle& channel_handle,
+                        Channel::Mode mode, MessageLoop* ipc_thread_loop,
+                        bool create_pipe_now) {
+#if defined(OS_POSIX)
+  // When we are creating a server on POSIX, we need it's file descriptor

[agl, 2010/12/08 15:38:57]

s/it's/its/

+  // to be created immediately so that it can be accessed and passed
+  // to other processes. Forcing it to be made immediately avoids

[agl, 2010/12/08 15:38:57]

s/made/created/

+  // race conditions that may otherwise arise.
+  if (mode == Channel::MODE_SERVER) {
+    create_pipe_now = true;
+  }
+#endif  // defined(OS_POSIX)
+
   if (create_pipe_now) {
     // Create the channel immediately.  This effectively sets up the
     // low-level pipe so that the client can connect.  Without creating
     // the pipe immediately, it is possible for a listener to attempt
     // to connect and get an error since the pipe doesn't exist yet.
-    context_->CreateChannel(channel_id, mode);
+    context_->CreateChannel(channel_handle, mode);
   } else {
     context_->ipc_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
-        context_.get(), &Context::CreateChannel, channel_id, mode));
+        context_.get(), &Context::CreateChannel, channel_handle, mode));
   }
 
   // complete initialization on the background thread
   context_->ipc_message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
       context_.get(), &Context::OnChannelOpened));
 }
 
 void ChannelProxy::Close() {
   // Clear the backpointer to the listener so that any pending calls to
   // Context::OnDispatchMessage or OnDispatchError will be ignored.  It is
@@ skipping 30 matching lines @@
 
 void ChannelProxy::ClearIPCMessageLoop() {
   context()->ClearIPCMessageLoop();
 }
 
 #if defined(OS_POSIX) && !defined(OS_NACL)
 // See the TODO regarding lazy initialization of the channel in
 // ChannelProxy::Init().
 // We assume that IPC::Channel::GetClientFileDescriptorMapping() is thread-safe.
 int ChannelProxy::GetClientFileDescriptor() const {
-  Channel *channel = context_.get()->channel_;
-  DCHECK(channel); // Channel must have been created first.
+  Channel *channel = context_.get()->channel_.get();
+  // Channel must have been created first.
+  DCHECK(channel) << context_.get()->channel_id_;
   return channel->GetClientFileDescriptor();
 }
 #endif
 
 //-----------------------------------------------------------------------------
 
 }  // namespace IPC