Convert over to channel handles

ipc/ipc_channel_posix.cc

 // Copyright (c) 2010 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/ipc_channel_posix.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/types.h>
@@ skipping 61 matching lines @@
 //
 // TODO(port): a client process cannot connect to multiple IPC channels with
 // this scheme.
 
 class PipeMap {
  public:
   static PipeMap* GetInstance() {
     return Singleton<PipeMap>::get();
   }
 
+  ~PipeMap() {
+    // Shouldn't have left over pipes.
+    DCHECK(map_.size() == 0);
+  }
+
   // Lookup a given channel id. Return -1 if not found.
   int Lookup(const std::string& channel_id) {
     AutoLock locked(lock_);
 
     ChannelToFDMap::const_iterator i = map_.find(channel_id);
     if (i == map_.end())
       return -1;
     return i->second;
   }
 
@@ skipping 175 matching lines @@
   // the receiver has read enough data to allow passing the FD over atomically.
   return errno == EAGAIN || errno == EMSGSIZE;
 #else
   return errno == EAGAIN;
 #endif
 }
 
 }  // namespace
 //------------------------------------------------------------------------------
 
-Channel::ChannelImpl::ChannelImpl(const std::string& channel_id, Mode mode,
-                                  Listener* listener)
+Channel::ChannelImpl::ChannelImpl(const IPC::ChannelHandle& channel_handle,
+                                  Mode mode, Listener* listener)
     : mode_(mode),
       is_blocked_on_write_(false),
       message_send_bytes_written_(0),
       uses_fifo_(
           CommandLine::ForCurrentProcess()->HasSwitch(switches::kIPCUseFIFO) ||
           mode == MODE_NAMED_SERVER || mode == MODE_NAMED_CLIENT),
       server_listen_pipe_(-1),
       pipe_(-1),
       client_pipe_(-1),
 #if !defined(OS_MACOSX)
       fd_pipe_(-1),
       remote_fd_pipe_(-1),
 #endif
       listener_(listener),
       waiting_connect_(true),
       factory_(this) {
   if (mode_ == MODE_NAMED_SERVER)
     mode_ = MODE_SERVER;
   if (mode_ == MODE_NAMED_CLIENT)
     mode_ = MODE_CLIENT;
 
-  if (!CreatePipe(channel_id, mode_)) {
+  if (!CreatePipe(channel_handle, mode_)) {
     // The pipe may have been closed already.
-    PLOG(WARNING) << "Unable to create pipe named \"" << channel_id
+    LOG(WARNING) << "Unable to create pipe named \"" << channel_handle.name
                   << "\" in " << (mode_ == MODE_SERVER ? "server" : "client")
                   << " mode";
   }
 }
 
 Channel::ChannelImpl::~ChannelImpl() {
   Close();
 }
 
 // static
@@ skipping 29 matching lines @@
       PLOG(ERROR) << "close";
     return false;
   }
 
   *fd1 = pipe_fds[0];
   *fd2 = pipe_fds[1];
 
   return true;
 }
 
-bool Channel::ChannelImpl::CreatePipe(const std::string& channel_id,
+bool Channel::ChannelImpl::CreatePipe(const IPC::ChannelHandle &channel_handle,
                                       Mode mode) {
   DCHECK(server_listen_pipe_ == -1 && pipe_ == -1);
-
+  pipe_name_ = channel_handle.name;
+  pipe_ = channel_handle.socket.fd;
   if (uses_fifo_) {
     // This only happens in unit tests; see the comment above PipeMap.
     // TODO(playmobil): We shouldn't need to create fifos on disk.
     // TODO(playmobil): If we do, they should be in the user data directory.
     // TODO(playmobil): Cleanup any stale fifos.
-    pipe_name_ = channel_id;
     if (mode == MODE_SERVER) {
       if (!CreateServerFifo(pipe_name_, &server_listen_pipe_)) {
         return false;
       }
     } else {
       if (!ClientConnectToFifo(pipe_name_, &pipe_)) {
         return false;
       }
       waiting_connect_ = false;
     }
   } else {
     // This is the normal (non-unit-test) case, where we're using sockets.
     // Three possible cases:
     // 1) It's for a channel we already have a pipe for; reuse it.
     // 2) It's the initial IPC channel:
     //   2a) Server side: create the pipe.
     //   2b) Client side: Pull the pipe out of the GlobalDescriptors set.
-    pipe_name_ = channel_id;
-    pipe_ = ChannelNameToFD(pipe_name_);
+    if (pipe_ < 0) {
+      pipe_ = ChannelNameToFD(pipe_name_);
+    }
     if (pipe_ < 0) {
       // Initial IPC channel.
       if (mode == MODE_SERVER) {
         if (!SocketPair(&pipe_, &client_pipe_))
           return false;
         AddChannelSocket(pipe_name_, client_pipe_);
       } else {
         // Guard against inappropriate reuse of the initial IPC channel.  If
         // an IPC channel closes and someone attempts to reuse it by name, the
         // initial channel must not be recycled here.  http://crbug.com/26754.
@@ skipping 667 matching lines @@
   for (std::vector<int>::iterator
        i = input_overflow_fds_.begin(); i != input_overflow_fds_.end(); ++i) {
     if (HANDLE_EINTR(close(*i)) < 0)
       PLOG(ERROR) << "close";
   }
   input_overflow_fds_.clear();
 }
 
 //------------------------------------------------------------------------------
 // Channel's methods simply call through to ChannelImpl.
-Channel::Channel(const std::string& channel_id, Mode mode,
+Channel::Channel(const IPC::ChannelHandle& channel_handle, Mode mode,
                  Listener* listener)
-    : channel_impl_(new ChannelImpl(channel_id, mode, listener)) {
+    : channel_impl_(new ChannelImpl(channel_handle, mode, listener)) {
 }
 
 Channel::~Channel() {
   delete channel_impl_;
 }
 
 bool Channel::Connect() {
   return channel_impl_->Connect();
 }
 
 void Channel::Close() {
   channel_impl_->Close();
 }
 
 void Channel::set_listener(Listener* listener) {
   channel_impl_->set_listener(listener);
 }
 
 bool Channel::Send(Message* message) {
   return channel_impl_->Send(message);
 }
 
 int Channel::GetClientFileDescriptor() const {
   return channel_impl_->GetClientFileDescriptor();
 }
 
 }  // namespace IPC