Upgrade the windows specific version of LaunchProcess to avoid raw handles.

chrome/browser/extensions/api/messaging/native_message_process_host.cc

 // 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 "chrome/browser/extensions/api/messaging/native_message_process_host.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/process/kill.h"
@@ skipping 29 matching lines @@
 
 NativeMessageProcessHost::NativeMessageProcessHost(
     const std::string& source_extension_id,
     const std::string& native_host_name,
     scoped_ptr<NativeProcessLauncher> launcher)
     : client_(NULL),
       source_extension_id_(source_extension_id),
       native_host_name_(native_host_name),
       launcher_(launcher.Pass()),
       closed_(false),
-      process_handle_(base::kNullProcessHandle),
 #if defined(OS_POSIX)
       read_file_(-1),
 #endif
       read_pending_(false),
       write_pending_(false),
       weak_factory_(this) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   task_runner_ = content::BrowserThread::GetMessageLoopProxyForThread(
       content::BrowserThread::IO);
@@ skipping 35 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   GURL origin(std::string(kExtensionScheme) + "://" + source_extension_id_);
   launcher_->Launch(origin, native_host_name_,
                     base::Bind(&NativeMessageProcessHost::OnHostProcessLaunched,
                                weak_factory_.GetWeakPtr()));
 }
 
 void NativeMessageProcessHost::OnHostProcessLaunched(
     NativeProcessLauncher::LaunchResult result,
-    base::ProcessHandle process_handle,
+    base::Process process,
     base::File read_file,
     base::File write_file) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   switch (result) {
     case NativeProcessLauncher::RESULT_INVALID_NAME:
       Close(kInvalidNameError);
       return;
     case NativeProcessLauncher::RESULT_NOT_FOUND:
       Close(kNotFoundError);
       return;
     case NativeProcessLauncher::RESULT_FORBIDDEN:
       Close(kForbiddenError);
       return;
     case NativeProcessLauncher::RESULT_FAILED_TO_START:
       Close(kFailedToStartError);
       return;
     case NativeProcessLauncher::RESULT_SUCCESS:
       break;
   }
 
-  process_handle_ = process_handle;
+  process_ = process.Pass();
 #if defined(OS_POSIX)
   // This object is not the owner of the file so it should not keep an fd.
   read_file_ = read_file.GetPlatformFile();
 #endif
 
   scoped_refptr<base::TaskRunner> task_runner(
       content::BrowserThread::GetBlockingPool()->
           GetTaskRunnerWithShutdownBehavior(
               base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
 
@@ skipping 203 matching lines @@
 void NativeMessageProcessHost::Close(const std::string& error_message) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!closed_) {
     closed_ = true;
     read_stream_.reset();
     write_stream_.reset();
     client_->CloseChannel(error_message);
   }
 
-  if (process_handle_ != base::kNullProcessHandle) {
+  if (process_.IsValid()) {
     // Kill the host process if necessary to make sure we don't leave zombies.
     // On OSX base::EnsureProcessTerminated() may block, so we have to post a
     // task on the blocking pool.
 #if defined(OS_MACOSX)
     content::BrowserThread::PostBlockingPoolTask(
-        FROM_HERE, base::Bind(&base::EnsureProcessTerminated, process_handle_));
+        FROM_HERE,
+        base::Bind(&base::EnsureProcessTerminated, Passed(&process_)));
 #else
-    base::EnsureProcessTerminated(process_handle_);
+    base::EnsureProcessTerminated(process_.Pass());
 #endif
-    process_handle_ = base::kNullProcessHandle;
   }
 }
 
 }  // namespace extensions