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

chrome/browser/extensions/api/messaging/native_process_launcher.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_process_launcher.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 44 matching lines @@
 
    private:
     friend class base::RefCountedThreadSafe<Core>;
     virtual ~Core();
 
     void DoLaunchOnThreadPool(const GURL& origin,
                               const std::string& native_host_name,
                               LaunchedCallback callback);
     void PostErrorResult(const LaunchedCallback& callback, LaunchResult error);
     void PostResult(const LaunchedCallback& callback,
-                    base::ProcessHandle process_handle,
+                    base::Process process,
                     base::File read_file,
                     base::File write_file);
     void CallCallbackOnIOThread(LaunchedCallback callback,
                                 LaunchResult result,
-                                base::ProcessHandle process_handle,
+                                base::Process process,
                                 base::File read_file,
                                 base::File write_file);
 
     bool detached_;
 
     bool allow_user_level_hosts_;
 
     // Handle of the native window corresponding to the extension.
     intptr_t window_handle_;
 
@@ skipping 104 matching lines @@
   CommandLine command_line(host_path);
   command_line.AppendArg(origin.spec());
 
   // Pass handle of the native view window to the native messaging host. This
   // way the host will be able to create properly focused UI windows.
 #if defined(OS_WIN)
   command_line.AppendSwitchASCII(kParentWindowSwitchName,
                                  base::Int64ToString(window_handle_));
 #endif  // !defined(OS_WIN)
 
-  base::ProcessHandle process_handle;
+  base::Process process;
   base::File read_file;
   base::File write_file;
   if (NativeProcessLauncher::LaunchNativeProcess(
-          command_line, &process_handle, &read_file, &write_file)) {
-    PostResult(callback, process_handle, read_file.Pass(), write_file.Pass());
+          command_line, &process, &read_file, &write_file)) {
+    PostResult(callback, process.Pass(), read_file.Pass(), write_file.Pass());
   } else {
     PostErrorResult(callback, RESULT_FAILED_TO_START);
   }
 }
 
 void NativeProcessLauncherImpl::Core::CallCallbackOnIOThread(
     LaunchedCallback callback,
     LaunchResult result,
-    base::ProcessHandle process_handle,
+    base::Process process,
     base::File read_file,
     base::File write_file) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   if (detached_)
     return;
 
-  callback.Run(result, process_handle, read_file.Pass(), write_file.Pass());
+  callback.Run(result, process.Pass(), read_file.Pass(), write_file.Pass());
 }
 
 void NativeProcessLauncherImpl::Core::PostErrorResult(
     const LaunchedCallback& callback,
     LaunchResult error) {
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&NativeProcessLauncherImpl::Core::CallCallbackOnIOThread, this,
-                 callback, error, base::kNullProcessHandle,
+                 callback, error, Passed(base::Process()),
                  Passed(base::File()), Passed(base::File())));
 }
 
 void NativeProcessLauncherImpl::Core::PostResult(
     const LaunchedCallback& callback,
-    base::ProcessHandle process_handle,
+    base::Process process,
     base::File read_file,
     base::File write_file) {
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&NativeProcessLauncherImpl::Core::CallCallbackOnIOThread, this,
-                 callback, RESULT_SUCCESS, process_handle,
-                 Passed(read_file.Pass()), Passed(write_file.Pass())));
+                 callback, RESULT_SUCCESS, Passed(&process),
+                 Passed(&read_file), Passed(&write_file)));
 }
 
 NativeProcessLauncherImpl::NativeProcessLauncherImpl(
     bool allow_user_level_hosts,
     intptr_t window_handle)
     : core_(new Core(allow_user_level_hosts, window_handle)) {
 }
 
 NativeProcessLauncherImpl::~NativeProcessLauncherImpl() {
   core_->Detach();
@@ skipping 14 matching lines @@
   intptr_t window_handle = 0;
 #if defined(OS_WIN)
   window_handle = reinterpret_cast<intptr_t>(
       views::HWNDForNativeView(native_view));
 #endif
   return scoped_ptr<NativeProcessLauncher>(
       new NativeProcessLauncherImpl(allow_user_level_hosts, window_handle));
 }
 
 }  // namespace extensions