Create an API around UtilityProcessHost and use that from chrome.

content/browser/in_process_webkit/indexed_db_key_utility_client.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/in_process_webkit/indexed_db_key_utility_client.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/synchronization/waitable_event.h"
-#include "content/browser/utility_process_host.h"
+#include "content/browser/utility_process_host_impl.h"
 #include "content/common/indexed_db/indexed_db_key.h"
 #include "content/common/indexed_db/indexed_db_messages.h"
 #include "content/common/utility_messages.h"
+#include "content/public/browser/utility_process_host_client.h"
 #include "content/public/common/serialized_script_value.h"
 
 using content::BrowserThread;
+using content::UtilityProcessHostClient;
 
 // This class is used to obtain IndexedDBKeys from SerializedScriptValues
 // given an IDBKeyPath. It uses UtilityProcess to do this inside a sandbox
 // (a V8 lock is required there). At this level, all methods are synchronous
 // as required by the caller. The public API is used on WEBKIT thread,
 // but internally it moves around to UI and IO as needed.
 class KeyUtilityClientImpl
     : public base::RefCountedThreadSafe<KeyUtilityClientImpl> {
  public:
   KeyUtilityClientImpl();
@@ skipping 11 matching lines @@
       std::vector<IndexedDBKey>* keys);
 
   // Synchronously inject |key| into |value| using the given |key_path|,
   // returning the new value.
   content::SerializedScriptValue InjectIDBKeyIntoSerializedValue(
       const IndexedDBKey& key,
       const content::SerializedScriptValue& value,
       const string16& key_path);
 
  private:
-  class Client : public UtilityProcessHost::Client {
+  class Client : public UtilityProcessHostClient {
    public:
     explicit Client(KeyUtilityClientImpl* parent);
 
-    // UtilityProcessHost::Client
+    // UtilityProcessHostClient
     virtual void OnProcessCrashed(int exit_code);
     virtual bool OnMessageReceived(const IPC::Message& message);
 
     // IPC message handlers
     void OnIDBKeysFromValuesAndKeyPathSucceeded(
         int id, const std::vector<IndexedDBKey>& keys);
     void OnIDBKeysFromValuesAndKeyPathFailed(int id);
     void OnInjectIDBKeyFinished(const content::SerializedScriptValue& value);
 
    private:
@@ skipping 30 matching lines @@
     STATE_INITIALIZED,
     STATE_CREATING_KEYS,
     STATE_INJECTING_KEY,
     STATE_SHUTDOWN,
   };
   State state_;
   std::vector<IndexedDBKey> keys_;
   content::SerializedScriptValue value_after_injection_;
 
   // Used in the IO thread.
-  base::WeakPtr<UtilityProcessHost> utility_process_host_;
+  base::WeakPtr<content::UtilityProcessHost> utility_process_host_;
   scoped_refptr<Client> client_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyUtilityClientImpl);
 };
 
 // IndexedDBKeyUtilityClient definitions.
 
 static base::LazyInstance<IndexedDBKeyUtilityClient> client_instance =
     LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 154 matching lines @@
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&KeyUtilityClientImpl::StartUtilityProcessInternal, this));
     return;
   }
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(state_ == STATE_UNINITIALIZED);
 
   client_ = new KeyUtilityClientImpl::Client(this);
-  utility_process_host_ = (new UtilityProcessHost(
+  utility_process_host_ = (new UtilityProcessHostImpl(
       client_.get(), BrowserThread::IO))->AsWeakPtr();
-  utility_process_host_->set_use_linux_zygote(true);
+  utility_process_host_->EnableZygote();
   utility_process_host_->StartBatchMode();
   state_ = STATE_INITIALIZED;
   waitable_event_.Signal();
 }
 
 void KeyUtilityClientImpl::EndUtilityProcessInternal() {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&KeyUtilityClientImpl::EndUtilityProcessInternal, this));
@@ skipping 103 matching lines @@
 void KeyUtilityClientImpl::Client::OnInjectIDBKeyFinished(
     const content::SerializedScriptValue& value) {
   parent_->SetValueAfterInjection(value);
   parent_->FinishInjectingKey();
 }
 
 void KeyUtilityClientImpl::Client::OnIDBKeysFromValuesAndKeyPathFailed(
     int id) {
   parent_->FinishCreatingKeys();
 }