Create an API around UtilityProcessHost and use that from chrome.

chrome/browser/extensions/webstore_inline_installer.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/webstore_inline_installer.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_install_dialog.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.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/url_pattern.h"
 #include "chrome/common/url_constants.h"
-#include "content/browser/utility_process_host.h"
 #include "content/public/browser/web_contents.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 "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request_status.h"
 
 using content::BrowserThread;
 using content::OpenURLParams;
+using content::UtilityProcessHost;
+using content::UtilityProcessHostClient;
 using content::WebContents;
 
 const char kManifestKey[] = "manifest";
 const char kIconUrlKey[] = "icon_url";
 const char kLocalizedNameKey[] = "localized_name";
 const char kLocalizedDescriptionKey[] = "localized_description";
 const char kUsersKey[] = "users";
 const char kAverageRatingKey[] = "average_rating";
 const char kRatingCountKey[] = "rating_count";
 const char kVerifiedSiteKey[] = "verified_site";
 const char kInlineInstallNotSupportedKey[] = "inline_install_not_supported";
 const char kRedirectUrlKey[] = "redirect_url";
 
 const char kInvalidWebstoreItemId[] = "Invalid Chrome Web Store item ID";
 const char kWebstoreRequestError[] =
     "Could not fetch data from the Chrome Web Store";
 const char kInvalidWebstoreResponseError[] = "Invalid Chrome Web Store reponse";
 const char kInvalidManifestError[] = "Invalid manifest";
 const char kUserCancelledError[] = "User cancelled install";
 const char kNoVerifiedSiteError[] =
     "Inline installs can only be initiated for Chrome Web Store items that "
     "have a verified site";
 const char kNotFromVerifiedSiteError[] =
     "Installs can only be initiated by the Chrome Web Store item's verified "
     "site";
 const char kInlineInstallSupportedError[] =
     "Inline installation is not supported for this item. The user will be "
     "redirected to the Chrome Web Store.";
 
-class SafeWebstoreResponseParser : public UtilityProcessHost::Client {
+class SafeWebstoreResponseParser : public UtilityProcessHostClient {
  public:
   SafeWebstoreResponseParser(WebstoreInlineInstaller *client,
                              const std::string& webstore_data)
       : client_(client),
-        webstore_data_(webstore_data),
-        utility_host_(NULL) {}
+        webstore_data_(webstore_data) {}
 
   void Start() {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&SafeWebstoreResponseParser::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(webstore_data_));
+    UtilityProcessHost* host =
+        UtilityProcessHost::Create(this, BrowserThread::IO);
+    host->EnableZygote();
+    host->Send(new ChromeUtilityMsg_ParseJSON(webstore_data_));
   }
 
-  // Implementing pieces of the UtilityProcessHost::Client interface.
+  // Implementing pieces of the UtilityProcessHostClient interface.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(SafeWebstoreResponseParser, 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;
@@ skipping 15 matching lines @@
 
   virtual void OnJSONParseFailed(const std::string& error_message) {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     error_ = error_message;
     ReportResults();
   }
 
   void ReportResults() {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-    // The utility_host_ will take care of deleting itself after this call.
-    utility_host_ = NULL;
-
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&SafeWebstoreResponseParser::ReportResultOnUIThread, this));
   }
 
   void ReportResultOnUIThread() {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (error_.empty() && parsed_webstore_data_.get()) {
       client_->OnWebstoreResponseParseSuccess(parsed_webstore_data_.release());
     } else {
       client_->OnWebstoreResponseParseFailure(error_);
     }
   }
 
  private:
   virtual ~SafeWebstoreResponseParser() {}
 
   WebstoreInlineInstaller* client_;
 
   std::string webstore_data_;
-
-  UtilityProcessHost* utility_host_;
-
   std::string error_;
   scoped_ptr<DictionaryValue> parsed_webstore_data_;
 };
 
 WebstoreInlineInstaller::WebstoreInlineInstaller(WebContents* web_contents,
                                                  int install_id,
                                                  std::string webstore_item_id,
                                                  GURL requestor_url,
                                                  Delegate* delegate)
     : content::WebContentsObserver(web_contents),
@@ skipping 294 matching lines @@
   if (web_contents()) {
     if (error.empty()) {
       delegate_->OnInlineInstallSuccess(install_id_);
     } else {
       delegate_->OnInlineInstallFailure(install_id_, error);
     }
   }
 
   Release(); // Matches the AddRef in BeginInstall.
 }