Convert over to channel handles

chrome/plugin/plugin_channel_base.cc

 // Copyright (c) 2009 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 "chrome/plugin/plugin_channel_base.h"
 
 #include <stack>
 
 #include "base/auto_reset.h"
 #include "base/hash_tables.h"
@@ skipping 10 matching lines @@
     PluginChannelMap;
 
 static PluginChannelMap g_plugin_channels_;
 
 static base::LazyInstance<std::stack<scoped_refptr<PluginChannelBase> > >
     lazy_plugin_channel_stack_(base::LINKER_INITIALIZED);
 
 static int next_pipe_id = 0;
 
 PluginChannelBase* PluginChannelBase::GetChannel(
-    const std::string& channel_key, IPC::Channel::Mode mode,
+    const IPC::ChannelHandle& channel_handle, IPC::Channel::Mode mode,
     PluginChannelFactory factory, MessageLoop* ipc_message_loop,
     bool create_pipe_now) {
   scoped_refptr<PluginChannelBase> channel;
-
+  std::string channel_key = channel_handle.name;
   PluginChannelMap::const_iterator iter = g_plugin_channels_.find(channel_key);
   if (iter == g_plugin_channels_.end()) {
     channel = factory();
   } else {
     channel = iter->second;
   }
 
   DCHECK(channel != NULL);
 
   if (!channel->channel_valid()) {
-    channel->channel_name_ = channel_key;
+    channel->channel_handle_ = channel_handle;
     if (mode == IPC::Channel::MODE_SERVER) {
-      channel->channel_name_.append(".");
-      channel->channel_name_.append(base::IntToString(next_pipe_id++));
+      channel->channel_handle_.name.append(".");
+      channel->channel_handle_.name.append(base::IntToString(next_pipe_id++));
     }
     channel->mode_ = mode;
     if (channel->Init(ipc_message_loop, create_pipe_now)) {
       g_plugin_channels_[channel_key] = channel;
     } else {
       channel = NULL;
     }
   }
 
   return channel;
@@ skipping 48 matching lines @@
   if (iter == npobject_listeners_.end()) {
     DLOG(WARNING) << "Invalid route id passed in:" << route_id;
     return NULL;
   }
   return iter->second;
 }
 
 bool PluginChannelBase::Init(MessageLoop* ipc_message_loop,
                              bool create_pipe_now) {
   channel_.reset(new IPC::SyncChannel(
-      channel_name_, mode_, this, ipc_message_loop, create_pipe_now,
+      channel_handle_, mode_, this, ipc_message_loop, create_pipe_now,
       ChildProcess::current()->GetShutDownEvent()));
   channel_valid_ = true;
   return true;
 }
 
 bool PluginChannelBase::Send(IPC::Message* message) {
   if (!channel_.get()) {
     delete message;
     return false;
   }
@@ skipping 83 matching lines @@
         IPC::Channel::Listener* channel_listener =
             npobj_iter->second->GetChannelListener();
         DCHECK(channel_listener != NULL);
         channel_listener->OnChannelError();
       }
     }
 
     for (PluginChannelMap::iterator iter = g_plugin_channels_.begin();
          iter != g_plugin_channels_.end(); ++iter) {
       if (iter->second == this) {
-#if defined(OS_POSIX)
-        if (channel_valid()) {
-          IPC::RemoveAndCloseChannelSocket(channel_name());
-        }
-#endif
         g_plugin_channels_.erase(iter);
         return;
       }
     }
 
     NOTREACHED();
   }
 }
 
 void PluginChannelBase::OnControlMessageReceived(const IPC::Message& msg) {
   NOTREACHED() <<
       "should override in subclass if you care about control messages";
 }
 
 void PluginChannelBase::OnChannelError() {
-#if defined(OS_POSIX)
-  if (channel_valid()) {
-    IPC::RemoveAndCloseChannelSocket(channel_name());
-  }
-#endif
   channel_valid_ = false;
 }