Convert over to channel handles

ipc/ipc_channel_win.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_win.h"
 
 #include <windows.h>
 #include <sddl.h>
 #include <sstream>
 
@@ skipping 79 matching lines @@
   context.handler = channel;
 }
 
 Channel::ChannelImpl::State::~State() {
   COMPILE_ASSERT(!offsetof(Channel::ChannelImpl::State, context),
                  starts_with_io_context);
 }
 
 //------------------------------------------------------------------------------
 
-Channel::ChannelImpl::ChannelImpl(const std::string& channel_id, Mode mode,
-                                  Listener* listener)
+Channel::ChannelImpl::ChannelImpl(const IPC::ChannelHandle &channel_handle,
+                                  Mode mode, Listener* listener)
     : ALLOW_THIS_IN_INITIALIZER_LIST(input_state_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(output_state_(this)),
       pipe_(INVALID_HANDLE_VALUE),
       listener_(listener),
       waiting_connect_(mode == MODE_SERVER),
       processing_incoming_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)) {
-  if (!CreatePipe(channel_id, mode)) {
+  if (!CreatePipe(channel_handle, mode)) {
     // The pipe may have been closed already.
-    LOG(WARNING) << "Unable to create pipe named \"" << channel_id <<
+    LOG(WARNING) << "Unable to create pipe named \"" << channel_handle.name <<
                     "\" in " << (mode == 0 ? "server" : "client") << " mode.";
   }
 }
 
 Channel::ChannelImpl::~ChannelImpl() {
   Close();
 }
 
 void Channel::ChannelImpl::Close() {
   if (thread_check_.get()) {
@@ skipping 46 matching lines @@
 }
 
 const std::wstring Channel::ChannelImpl::PipeName(
     const std::string& channel_id) const {
   std::wostringstream ss;
   // XXX(darin): get application name from somewhere else
   ss << L"\\\\.\\pipe\\chrome." << ASCIIToWide(channel_id);
   return ss.str();
 }
 
-bool Channel::ChannelImpl::CreatePipe(const std::string& channel_id,
+bool Channel::ChannelImpl::CreatePipe(const IPC::ChannelHandle &channel_handle,
                                       Mode mode) {
   DCHECK(pipe_ == INVALID_HANDLE_VALUE);
-  const std::wstring pipe_name = PipeName(channel_id);
+  const std::wstring pipe_name = PipeName(channel_handle.name);
   if (mode == MODE_SERVER) {
     SECURITY_ATTRIBUTES security_attributes = {0};
     security_attributes.bInheritHandle = FALSE;
     security_attributes.nLength = sizeof(SECURITY_ATTRIBUTES);
     if (!GetLogonSessionOnlyDACL(
         reinterpret_cast<SECURITY_DESCRIPTOR**>(
             &security_attributes.lpSecurityDescriptor))) {
       NOTREACHED();
     }
 
@@ skipping 270 matching lines @@
   }
   if (!ok && INVALID_HANDLE_VALUE != pipe_) {
     // We don't want to re-enter Close().
     Close();
     listener_->OnChannelError();
   }
 }
 
 //------------------------------------------------------------------------------
 // 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);
 }
 
 }  // namespace IPC