Create an API around UtilityProcessHost and use that from chrome.

chrome/browser/extensions/extension_management_api.cc

 // Copyright (c) 2011 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_management_api.h"
 
 #include <map>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 12 matching lines @@
 #include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_utility_messages.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/url_pattern.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
+#include "content/public/browser/utility_process_host.h"
+#include "content/public/browser/utility_process_host_client.h"
 
 using base::IntToString;
 using content::BrowserThread;
+using content::UtilityProcessHost;
+using content::UtilityProcessHostClient;
 
 namespace events = extension_event_names;
 namespace keys = extension_management_api_constants;
 
 ExtensionService* ExtensionManagementFunction::service() {
   return profile()->GetExtensionService();
 }
 
 ExtensionService* AsyncExtensionManagementFunction::service() {
   return profile()->GetExtensionService();
@@ skipping 140 matching lines @@
        i < warnings.end(); ++i)
     result->Append(Value::CreateStringValue(i->message()));
   result_.reset(result);
   return true;
 }
 
 namespace {
 
 // This class helps GetPermissionWarningsByManifestFunction manage
 // sending manifest JSON strings to the utility process for parsing.
-class SafeManifestJSONParser : public UtilityProcessHost::Client {
+class SafeManifestJSONParser : public UtilityProcessHostClient {
  public:
   SafeManifestJSONParser(GetPermissionWarningsByManifestFunction* client,
                  const std::string& manifest)
       : client_(client),
-        manifest_(manifest),
-        utility_host_(NULL) {}
+        manifest_(manifest) {}
 
   void Start() {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&SafeManifestJSONParser::StartWorkOnIOThread, this));
   }
 
   void StartWorkOnIOThread() {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    utility_host_ = new UtilityProcessHost(this, BrowserThread::IO);
-    utility_host_->set_use_linux_zygote(true);
-    utility_host_->Send(new ChromeUtilityMsg_ParseJSON(manifest_));
+    UtilityProcessHost* host =
+        UtilityProcessHost::Create(this, BrowserThread::IO);
+    host->EnableZygote();
+    host->Send(new ChromeUtilityMsg_ParseJSON(manifest_));
   }
 
   virtual bool OnMessageReceived(const IPC::Message& message) {
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(SafeManifestJSONParser, message)
       IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_ParseJSON_Succeeded,
                           OnJSONParseSucceeded)
       IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_ParseJSON_Failed,
                           OnJSONParseFailed)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     return handled;
   }
 
   void OnJSONParseSucceeded(const ListValue& wrapper) {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     Value* value = NULL;
     CHECK(wrapper.Get(0, &value));
     if (value->IsType(Value::TYPE_DICTIONARY))
       parsed_manifest_.reset(static_cast<DictionaryValue*>(value)->DeepCopy());
     else
       error_ = keys::kManifestParseError;
 
-    utility_host_ = NULL; // has already deleted itself
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&SafeManifestJSONParser::ReportResultFromUIThread, this));
   }
 
   void OnJSONParseFailed(const std::string& error) {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     error_ = error;
-    utility_host_ = NULL; // has already deleted itself
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&SafeManifestJSONParser::ReportResultFromUIThread, this));
   }
 
   void ReportResultFromUIThread() {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (error_.empty() && parsed_manifest_.get())
       client_->OnParseSuccess(parsed_manifest_.release());
     else
       client_->OnParseFailure(error_);
   }
 
  private:
   ~SafeManifestJSONParser() {}
 
   // The client who we'll report results back to.
   GetPermissionWarningsByManifestFunction* client_;
 
   // Data to parse.
   std::string manifest_;
 
   // Results of parsing.
   scoped_ptr<DictionaryValue> parsed_manifest_;
 
   std::string error_;
-  UtilityProcessHost* utility_host_;
 };
 
 }  // namespace
 
 bool GetPermissionWarningsByManifestFunction::RunImpl() {
   std::string manifest_str;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &manifest_str));
 
   scoped_refptr<SafeManifestJSONParser> parser =
       new SafeManifestJSONParser(this, manifest_str);
@@ skipping 220 matching lines @@
     bool escalated = prefs ->DidExtensionEscalatePermissions(extension->id());
     args.Append(CreateExtensionInfo(*extension, enabled, escalated));
   }
 
   std::string args_json;
   base::JSONWriter::Write(&args, false /* pretty_print */, &args_json);
 
   profile->GetExtensionEventRouter()->DispatchEventToRenderers(
       event_name, args_json, NULL, GURL());
 }