Move UtilityProcessHost to content and move the message sending/dispatching to the clients. This...

content/browser/in_process_webkit/indexed_db_key_utility_client.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 "content/browser/in_process_webkit/indexed_db_key_utility_client.h"
 
 #include "base/lazy_instance.h"
 #include "base/synchronization/waitable_event.h"
-#include "chrome/browser/utility_process_host.h"
+#include "content/browser/utility_process_host.h"
 #include "content/common/indexed_db_key.h"
+#include "content/common/indexed_db_messages.h"
+#include "content/common/utility_messages.h"
 #include "content/common/serialized_script_value.h"
 
 // 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:
@@ skipping 18 matching lines @@
       const SerializedScriptValue& value,
       const string16& key_path);
 
  private:
   class Client : public UtilityProcessHost::Client {
    public:
     explicit Client(KeyUtilityClientImpl* parent);
 
     // UtilityProcessHost::Client
     virtual void OnProcessCrashed(int exit_code);
-    virtual void OnIDBKeysFromValuesAndKeyPathSucceeded(
+    virtual bool OnMessageReceived(const IPC::Message& message);
+
+    // IPC message handlers
+    void OnIDBKeysFromValuesAndKeyPathSucceeded(
         int id, const std::vector<IndexedDBKey>& keys);
-    virtual void OnIDBKeysFromValuesAndKeyPathFailed(int id);
-    virtual void OnInjectIDBKeyFinished(const SerializedScriptValue& value);
+    void OnIDBKeysFromValuesAndKeyPathFailed(int id);
+    void OnInjectIDBKeyFinished(const SerializedScriptValue& value);
 
    private:
     KeyUtilityClientImpl* parent_;
 
     DISALLOW_COPY_AND_ASSIGN(Client);
   };
 
   friend class base::RefCountedThreadSafe<KeyUtilityClientImpl>;
   ~KeyUtilityClientImpl();
 
@@ skipping 237 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         NewRunnableMethod(this,
             &KeyUtilityClientImpl::
                 CallStartIDBKeyFromValueAndKeyPathFromIOThread,
             values, key_path));
     return;
   }
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  utility_process_host_->StartIDBKeysFromValuesAndKeyPath(
-      0, values, key_path);
+  utility_process_host_->Send(new UtilityMsg_IDBKeysFromValuesAndKeyPath(
+      0, values, key_path));
 }
 
 void KeyUtilityClientImpl::CallStartInjectIDBKeyFromIOThread(
     const IndexedDBKey& key,
     const SerializedScriptValue& value,
     const string16& key_path) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         NewRunnableMethod(this,
             &KeyUtilityClientImpl::
                 CallStartInjectIDBKeyFromIOThread,
             key, value, key_path));
     return;
   }
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  utility_process_host_->StartInjectIDBKey(key, value, key_path);
+  utility_process_host_->Send(new UtilityMsg_InjectIDBKey(
+      key, value, key_path));
 }
 
 void KeyUtilityClientImpl::SetKeys(const std::vector<IndexedDBKey>& keys) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   keys_ = keys;
 }
 
 void KeyUtilityClientImpl::FinishCreatingKeys() {
   DCHECK(state_ == STATE_CREATING_KEYS);
   state_ = STATE_INITIALIZED;
@@ skipping 14 matching lines @@
 
 KeyUtilityClientImpl::Client::Client(KeyUtilityClientImpl* parent)
     : parent_(parent) {
 }
 
 void KeyUtilityClientImpl::Client::OnProcessCrashed(int exit_code) {
   if (parent_->state_ == STATE_CREATING_KEYS)
     parent_->FinishCreatingKeys();
 }
 
+bool KeyUtilityClientImpl::Client::OnMessageReceived(
+    const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(KeyUtilityClientImpl::Client, message)
+    IPC_MESSAGE_HANDLER(UtilityHostMsg_IDBKeysFromValuesAndKeyPath_Succeeded,
+                        OnIDBKeysFromValuesAndKeyPathSucceeded)
+    IPC_MESSAGE_HANDLER(UtilityHostMsg_IDBKeysFromValuesAndKeyPath_Failed,
+                        OnIDBKeysFromValuesAndKeyPathFailed)
+    IPC_MESSAGE_HANDLER(UtilityHostMsg_InjectIDBKey_Finished,
+                        OnInjectIDBKeyFinished)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP_EX()
+  return handled;
+}
+
 void KeyUtilityClientImpl::Client::OnIDBKeysFromValuesAndKeyPathSucceeded(
     int id, const std::vector<IndexedDBKey>& keys) {
   parent_->SetKeys(keys);
   parent_->FinishCreatingKeys();
 }
 
 void KeyUtilityClientImpl::Client::OnInjectIDBKeyFinished(
     const SerializedScriptValue& value) {
   parent_->SetValueAfterInjection(value);
   parent_->FinishInjectingKey();
 }
 
 void KeyUtilityClientImpl::Client::OnIDBKeysFromValuesAndKeyPathFailed(
     int id) {
   parent_->FinishCreatingKeys();
 }