Create an API around UtilityProcessHost and use that from chrome.

chrome/browser/extensions/extension_updater.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/extension_updater.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 19 matching lines @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_utility_messages.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_file_util.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
-#include "content/browser/utility_process_host.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
+#include "content/public/browser/utility_process_host.h"
 #include "content/public/common/url_fetcher.h"
 #include "crypto/sha2.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request_status.h"
 
 #if defined(OS_MACOSX)
 #include "base/sys_string_conversions.h"
 #endif
 
 #define SEND_ACTIVE_PINGS 1
 
 using base::RandDouble;
 using base::RandInt;
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
+using content::UtilityProcessHost;
+using content::UtilityProcessHostClient;
 using prefs::kExtensionBlacklistUpdateVersion;
 using prefs::kLastExtensionsUpdateCheck;
 using prefs::kNextExtensionsUpdateCheck;
 
 // Update AppID for extension blacklist.
 const char* ExtensionUpdater::kBlacklistAppID = "com.google.crx.blacklist";
 
 namespace {
 
 // Wait at least 5 minutes after browser startup before we do any checks. If you
@@ skipping 542 matching lines @@
                        source->GetURL(),
                        source->GetStatus(),
                        source->GetResponseCode());
   } else {
     NOTREACHED();
   }
   NotifyIfFinished();
 }
 
 // Utility class to handle doing xml parsing in a sandboxed utility process.
-class SafeManifestParser : public UtilityProcessHost::Client {
+class SafeManifestParser : public UtilityProcessHostClient {
  public:
   // Takes ownership of |fetch_data|.
   SafeManifestParser(const std::string& xml, ManifestFetchData* fetch_data,
                      base::WeakPtr<ExtensionUpdater> updater)
       : xml_(xml), updater_(updater) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     fetch_data_.reset(fetch_data);
   }
 
   // Posts a task over to the IO loop to start the parsing of xml_ in a
@@ skipping 11 matching lines @@
 
   // Creates the sandboxed utility process and tells it to start parsing.
   void ParseInSandbox(ResourceDispatcherHost* rdh) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
     // TODO(asargent) we shouldn't need to do this branch here - instead
     // UtilityProcessHost should handle it for us. (http://crbug.com/19192)
     bool use_utility_process = rdh &&
         !CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess);
     if (use_utility_process) {
-      UtilityProcessHost* host = new UtilityProcessHost(
+      UtilityProcessHost* host = UtilityProcessHost::Create(
           this, BrowserThread::UI);
-      host->set_use_linux_zygote(true);
+      host->EnableZygote();
       host->Send(new ChromeUtilityMsg_ParseUpdateManifest(xml_));
     } else {
       UpdateManifest manifest;
       if (manifest.Parse(xml_)) {
         if (!BrowserThread::PostTask(
                 BrowserThread::UI, FROM_HERE,
                 base::Bind(
                     &SafeManifestParser::OnParseUpdateManifestSucceeded, this,
                     manifest.results()))) {
           NOTREACHED();
         }
       } else {
         if (!BrowserThread::PostTask(
                 BrowserThread::UI, FROM_HERE,
                 base::Bind(
                     &SafeManifestParser::OnParseUpdateManifestFailed, this,
                     manifest.errors()))) {
           NOTREACHED();
         }
       }
     }
   }
 
-  // UtilityProcessHost::Client
+  // UtilityProcessHostClient
   virtual bool OnMessageReceived(const IPC::Message& message) {
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(SafeManifestParser, message)
       IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_ParseUpdateManifest_Succeeded,
                           OnParseUpdateManifestSucceeded)
       IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_ParseUpdateManifest_Failed,
                           OnParseUpdateManifestFailed)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     return handled;
@@ skipping 605 matching lines @@
   std::set<std::string>::const_iterator i;
   for (i = ids.begin(); i != ids.end(); ++i)
     in_progress_ids_.insert(*i);
 }
 
 void ExtensionUpdater::RemoveFromInProgress(const std::set<std::string>& ids) {
   std::set<std::string>::const_iterator i;
   for (i = ids.begin(); i != ids.end(); ++i)
     in_progress_ids_.erase(*i);
 }