Launches a privileged utility process.

content/browser/ppapi_plugin_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 "content/browser/ppapi_plugin_process_host.h"
 
 #include <string>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
@@ skipping 308 matching lines @@
   // plugin launcher means we need to use another process instead of just
   // forking the zygote.
 #if defined(OS_POSIX)
   bool use_zygote = !is_broker_ && plugin_launcher.empty() && info.is_sandboxed;
   if (!info.is_sandboxed)
     cmd_line->AppendSwitchASCII(switches::kNoSandbox, std::string());
 #endif  // OS_POSIX
   process_->Launch(
 #if defined(OS_WIN)
       new PpapiPluginSandboxedProcessLauncherDelegate(is_broker_),
+      false,
 #elif defined(OS_POSIX)
       use_zygote,
       base::EnvironmentMap(),
 #endif
       cmd_line);
   return true;
 }
 
 void PpapiPluginProcessHost::RequestPluginChannel(Client* client) {
   base::ProcessHandle process_handle;
   int renderer_child_id;
   client->GetPpapiChannelInfo(&process_handle, &renderer_child_id);
 
   base::ProcessId process_id = (process_handle == base::kNullProcessHandle) ?
       0 : base::GetProcId(process_handle);
 
   // We can't send any sync messages from the browser because it might lead to
   // a hang. See the similar code in PluginProcessHost for more description.
   PpapiMsg_CreateChannel* msg = new PpapiMsg_CreateChannel(
       process_id, renderer_child_id, client->OffTheRecord());
   msg->set_unblock(true);
   if (Send(msg)) {
     sent_requests_.push(client);
   } else {
     client->OnPpapiChannelOpened(IPC::ChannelHandle(), base::kNullProcessId, 0);
   }
 }
 
 void PpapiPluginProcessHost::OnProcessLaunched() {
-  host_impl_->set_plugin_process_handle(process_->GetHandle());
+  host_impl_->set_plugin_process_handle(
+      static_cast<ChildProcessHostDelegate*>(process_.get())->GetHandle());

[jam, 2014/02/01 01:09:10]

I just noticed this and the other places that case. It's probably cleaner to
just make BrowserChildProcessHostImpl's implementation of
ChildProcessHostDelegate be public, since it's legitimate to call one of these
methods and the casting is ugly

[Drew Haven, 2014/02/04 21:25:54]

Okay, I sort of thought the same thing.  But I didn't know which was the lesser
of the two evils.

 }
 
 void PpapiPluginProcessHost::OnProcessCrashed(int exit_code) {
   PluginServiceImpl::GetInstance()->RegisterPluginCrash(plugin_path_);
 }
 
 bool PpapiPluginProcessHost::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PpapiPluginProcessHost, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_ChannelCreated,
@@ skipping 55 matching lines @@
   // sent_requests_ queue should be the one that the plugin just created.
   Client* client = sent_requests_.front();
   sent_requests_.pop();
 
   const ChildProcessData& data = process_->GetData();
   client->OnPpapiChannelOpened(channel_handle, base::GetProcId(data.handle),
                                data.id);
 }
 
 }  // namespace content