Create an API around UtilityProcessHost and use that from chrome.

chrome/browser/web_resource/web_resource_service.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/web_resource/web_resource_service.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_utility_messages.h"
 #include "chrome/common/web_resource/web_resource_unpacker.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
-#include "content/browser/utility_process_host.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/utility_process_host.h"
+#include "content/public/browser/utility_process_host_client.h"
 #include "content/public/common/url_fetcher.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request_status.h"
 
 using content::BrowserThread;
+using content::UtilityProcessHost;
+using content::UtilityProcessHostClient;
 
 // This class coordinates a web resource unpack and parse task which is run in
 // a separate process.  Results are sent back to this class and routed to
 // the WebResourceService.
-class WebResourceService::UnpackerClient : public UtilityProcessHost::Client {
+class WebResourceService::UnpackerClient : public UtilityProcessHostClient {
  public:
   explicit UnpackerClient(WebResourceService* web_resource_service)
     : web_resource_service_(web_resource_service),
       resource_dispatcher_host_(ResourceDispatcherHost::Get()),
       got_response_(false) {
   }
 
   void Start(const std::string& json_data) {
     AddRef();  // balanced in Cleanup.
 
@@ skipping 17 matching lines @@
         OnUnpackWebResourceSucceeded(*unpacker.parsed_json());
       } else {
         OnUnpackWebResourceFailed(unpacker.error_message());
       }
     }
   }
 
  private:
   virtual ~UnpackerClient() {}
 
-  // UtilityProcessHost::Client
-  virtual bool OnMessageReceived(const IPC::Message& message) {
+  // UtilityProcessHostClient
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(WebResourceService::UnpackerClient, message)
       IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_UnpackWebResource_Succeeded,
                           OnUnpackWebResourceSucceeded)
       IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_UnpackWebResource_Failed,
                           OnUnpackWebResourceFailed)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     return handled;
   }
 
-  virtual void OnProcessCrashed(int exit_code) {
+  virtual void OnProcessCrashed(int exit_code) OVERRIDE {
     if (got_response_)
       return;
 
     OnUnpackWebResourceFailed(
         "Utility process crashed while trying to retrieve web resources.");
   }
 
   void OnUnpackWebResourceSucceeded(
       const DictionaryValue& parsed_json) {
     web_resource_service_->Unpack(parsed_json);
     Cleanup();
   }
 
   void OnUnpackWebResourceFailed(const std::string& error_message) {
     LOG(ERROR) << error_message;
     Cleanup();
   }
 
   // Release reference and set got_response_.
   void Cleanup() {
     DCHECK(!got_response_);
     got_response_ = true;
 
     web_resource_service_->EndFetch();
     Release();
   }
 
   void StartProcessOnIOThread(BrowserThread::ID thread_id,
                               const std::string& json_data) {
-    UtilityProcessHost* host = new UtilityProcessHost(this, thread_id);
-    host->set_use_linux_zygote(true);
+    UtilityProcessHost* host = UtilityProcessHost::Create(this, thread_id);
+    host->EnableZygote();
     // TODO(mrc): get proper file path when we start using web resources
     // that need to be unpacked.
     host->Send(new ChromeUtilityMsg_UnpackWebResource(json_data));
   }
 
   scoped_refptr<WebResourceService> web_resource_service_;
 
   // Owned by the global browser process.
   ResourceDispatcherHost* resource_dispatcher_host_;
 
@@ skipping 105 matching lines @@
 
   std::string data;
   source->GetResponseAsString(&data);
 
   // UnpackerClient releases itself.
   UnpackerClient* client = new UnpackerClient(this);
   client->Start(data);
 
   Release();
 }