Initialize IPC:ChannelHandle from existing HANDLE

ipc/ipc_channel_win.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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 "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 95 matching lines @@
 // static
 const std::wstring Channel::ChannelImpl::PipeName(
     const std::string& channel_id) {
   std::string name("\\\\.\\pipe\\chrome.");
   return ASCIIToWide(name.append(channel_id));
 }
 
 bool Channel::ChannelImpl::CreatePipe(const IPC::ChannelHandle &channel_handle,
                                       Mode mode) {
   DCHECK_EQ(INVALID_HANDLE_VALUE, pipe_);
-  const std::wstring pipe_name = PipeName(channel_handle.name);
-  if (mode & MODE_SERVER_FLAG) {
+  string16 pipe_name;
+  // If we already have a valid pipe for channel just copy it.
+  if (channel_handle.pipe.handle) {
+    DCHECK(channel_handle.name.empty());
+    pipe_name = L"Not Available";  // Just used for LOG
+    // Check that the given pipe confirms to the specified mode.  We can
+    // only check for PIPE_TYPE_MESSAGE & PIPE_SERVER_END flags since the
+    // other flags (PIPE_TYPE_BYTE, and PIPE_CLIENT_END) are defined as 0.
+    DWORD flags = 0;
+    GetNamedPipeInfo(channel_handle.pipe.handle, &flags, NULL, NULL, NULL);
+    DCHECK(!(flags & PIPE_TYPE_MESSAGE));
+    if (((mode & MODE_SERVER_FLAG) && !(flags & PIPE_SERVER_END)) ||
+        ((mode & MODE_CLIENT_FLAG) && (flags & PIPE_SERVER_END))) {
+      LOG(WARNING) << "Inconsistent open mode. Mode :" << mode;
+      return false;
+    }
+    if (!DuplicateHandle(GetCurrentProcess(),
+                         channel_handle.pipe.handle,
+                         GetCurrentProcess(),
+                         &pipe_,
+                         0,
+                         FALSE,
+                         DUPLICATE_SAME_ACCESS)) {
+      LOG(WARNING) << "DuplicateHandle failed. Error :" << GetLastError();
+      return false;
+    }
+  } else if (mode & MODE_SERVER_FLAG) {
+    DCHECK(!channel_handle.pipe.handle);
+    const DWORD open_mode = PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED |
+                            FILE_FLAG_FIRST_PIPE_INSTANCE;
+    pipe_name = PipeName(channel_handle.name);
     pipe_ = CreateNamedPipeW(pipe_name.c_str(),
-                             PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED |
-                              FILE_FLAG_FIRST_PIPE_INSTANCE,
+                             open_mode,
                              PIPE_TYPE_BYTE | PIPE_READMODE_BYTE,
                              1,
                              Channel::kReadBufferSize,
                              Channel::kReadBufferSize,
                              5000,
                              NULL);
   } else if (mode & MODE_CLIENT_FLAG) {
+    DCHECK(!channel_handle.pipe.handle);
+    pipe_name = PipeName(channel_handle.name);
     pipe_ = CreateFileW(pipe_name.c_str(),
                         GENERIC_READ | GENERIC_WRITE,
                         0,
                         NULL,
                         OPEN_EXISTING,
                         SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION |
                             FILE_FLAG_OVERLAPPED,
                         NULL);
   } else {
     NOTREACHED();
   }
+
   if (pipe_ == INVALID_HANDLE_VALUE) {
     // If this process is being closed, the pipe may be gone already.
     LOG(WARNING) << "Unable to create pipe \"" << pipe_name <<
                     "\" in " << (mode == 0 ? "server" : "client")
                     << " mode. Error :" << GetLastError();
     return false;
   }
 
   // Create the Hello message to be sent when Connect is called
   scoped_ptr<Message> m(new Message(MSG_ROUTING_NONE,
@@ skipping 274 matching lines @@
 bool Channel::Send(Message* message) {
   return channel_impl_->Send(message);
 }
 
 // static
 bool Channel::IsNamedServerInitialized(const std::string& channel_id) {
   return ChannelImpl::IsNamedServerInitialized(channel_id);
 }
 
 }  // namespace IPC