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

chrome/browser/idbbindingutilities_browsertest.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 "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/utility_process_host.h"
 #include "chrome/test/in_process_browser_test.h"
 #include "chrome/test/ui_test_utils.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
+#include "content/browser/utility_process_host.h"
 #include "content/common/indexed_db_key.h"
 #include "content/common/serialized_script_value.h"
+#include "content/common/utility_messages.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSerializedScriptValue.h"
 #include "webkit/glue/idb_bindings.h"
 #include "webkit/glue/web_io_operators.h"
 
 using WebKit::WebSerializedScriptValue;
 
 // Sanity test, check the function call directly outside the sandbox.
 TEST(IDBKeyPathWithoutSandbox, Value) {
@@ skipping 89 matching lines @@
       int id, const std::vector<SerializedScriptValue>& serialized_values,
       const string16& key_path) {
     if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           NewRunnableMethod(this, &IDBKeyPathHelper::CheckValuesForKeyPath,
                             id, serialized_values, key_path));
       return;
     }
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    bool ret =
-        utility_process_host_->StartIDBKeysFromValuesAndKeyPath(
-            id, serialized_values, key_path);
+    bool ret = utility_process_host_->Send(
+        new UtilityMsg_IDBKeysFromValuesAndKeyPath(
+            id, serialized_values, key_path));
     ASSERT_TRUE(ret);
   }
 
   void CheckInjectValue(const IndexedDBKey& key,
                         const SerializedScriptValue& value,
                         const string16& key_path) {
     if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           NewRunnableMethod(this, &IDBKeyPathHelper::CheckInjectValue,
                             key, value, key_path));
       return;
     }
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    bool ret = utility_process_host_->StartInjectIDBKey(key, value, key_path);
+    bool ret = utility_process_host_->Send(new UtilityMsg_InjectIDBKey(
+        key, value, key_path));
     ASSERT_TRUE(ret);
   }
 
   // UtilityProcessHost::Client
-  virtual void OnIDBKeysFromValuesAndKeyPathSucceeded(
+  bool OnMessageReceived(const IPC::Message& message) {
+    bool handled = true;
+    IPC_BEGIN_MESSAGE_MAP(IDBKeyPathHelper, 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 OnIDBKeysFromValuesAndKeyPathSucceeded(
       int id, const std::vector<IndexedDBKey>& values) {
     EXPECT_EQ(expected_id_, id);
     EXPECT_FALSE(value_for_key_path_failed_);
     ASSERT_EQ(expected_keys_.size(), values.size());
     size_t pos = 0;
     for (std::vector<IndexedDBKey>::const_iterator i(values.begin());
          i != values.end(); ++i, ++pos) {
       ASSERT_EQ(expected_keys_[pos].type(), i->type());
       if (i->type() == WebKit::WebIDBKey::StringType) {
         ASSERT_EQ(expected_keys_[pos].string(), i->string());
       } else if (i->type() == WebKit::WebIDBKey::NumberType) {
         ASSERT_EQ(expected_keys_[pos].number(), i->number());
       }
     }
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             new MessageLoop::QuitTask());
   }
 
-  virtual void OnIDBKeysFromValuesAndKeyPathFailed(int id) {
+  void OnIDBKeysFromValuesAndKeyPathFailed(int id) {
     EXPECT_TRUE(value_for_key_path_failed_);
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             new MessageLoop::QuitTask());
   }
 
-  virtual void OnInjectIDBKeyFinished(
-      const SerializedScriptValue& new_value) {
+  void OnInjectIDBKeyFinished(const SerializedScriptValue& new_value) {
     EXPECT_EQ(expected_value_.data(), new_value.data());
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             new MessageLoop::QuitTask());
   }
 
 
  private:
   int expected_id_;
   std::vector<IndexedDBKey> expected_keys_;
   UtilityProcessHost* utility_process_host_;
@@ skipping 139 matching lines @@
                                        string16(expected_data,
                                                 arraysize(expected_data)));
 
   ScopedIDBKeyPathHelper scoped_helper;
   scoped_helper.SetExpectedValue(expected_value);
   scoped_helper.CheckInjectValue(key, value, UTF8ToUTF16("bar"));
 
   scoped_helper.SetExpectedValue(SerializedScriptValue());  // Expect null.
   scoped_helper.CheckInjectValue(key, value, UTF8ToUTF16("bad.key.path"));
 }