Move a number of other tests from browser_tests to content_browsertests.

content/browser/indexed_db/idbbindingutilities_browsertest.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 "base/bind.h"
+#include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/test/base/in_process_browser_test.h"
-#include "chrome/test/base/ui_test_utils.h"
 #include "content/browser/utility_process_host_impl.h"
 #include "content/public/browser/utility_process_host_client.h"
 #include "content/common/indexed_db/indexed_db_key.h"
 #include "content/common/indexed_db/indexed_db_key_path.h"
 #include "content/common/utility_messages.h"
 #include "content/common/webkitplatformsupport_impl.h"
 #include "content/public/common/serialized_script_value.h"
+#include "content/public/test/test_utils.h"
+#include "content/test/content_browser_test.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebSerializedScriptValue.h"
 #include "webkit/glue/idb_bindings.h"
 #include "webkit/glue/web_io_operators.h"
 
-using content::BrowserThread;
-using content::IndexedDBKey;
-using content::IndexedDBKeyPath;
-using content::UtilityProcessHost;
-using content::UtilityProcessHostClient;
-using content::SerializedScriptValue;
 using WebKit::WebSerializedScriptValue;
 using WebKit::WebIDBKeyPath;
 
+namespace content {
+
 // Enables calling WebKit::shutdown no matter where a "return" happens.
 class ScopedShutdownWebKit {
  public:
   ScopedShutdownWebKit() {
   }
 
   ~ScopedShutdownWebKit() {
     WebKit::shutdown();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScopedShutdownWebKit);
 };
 
 // Sanity test, check the function call directly outside the sandbox.
 TEST(IDBKeyPathWithoutSandbox, Value) {
-  content::WebKitPlatformSupportImpl webkit_platform_support;
+  WebKitPlatformSupportImpl webkit_platform_support;
   WebKit::initialize(&webkit_platform_support);
   ScopedShutdownWebKit shutdown_webkit;
 
   // {foo: "zoo"}
   char16 data_foo_zoo[] = {0x0353,0x6f66,0x536f,0x7a03,0x6f6f,0x017b};
   std::vector<WebSerializedScriptValue> serialized_values;
   serialized_values.push_back(
       WebSerializedScriptValue::fromString(string16(data_foo_zoo,
                                                     arraysize(data_foo_zoo))));
 
@@ skipping 176 matching lines @@
   int expected_id_;
   std::vector<IndexedDBKey> expected_keys_;
   base::WeakPtr<UtilityProcessHost> utility_process_host_;
   bool value_for_key_path_failed_;
   SerializedScriptValue expected_value_;
 };
 
 // This test fixture runs in the UI thread. However, most of the work done by
 // UtilityProcessHost (and wrapped by IDBKeyPathHelper above) happens on the IO
 // thread. This fixture delegates to IDBKeyPathHelper and blocks via
-// "content::RunMessageLoop()", until IDBKeyPathHelper posts a quit
+// "RunMessageLoop()", until IDBKeyPathHelper posts a quit
 // message the MessageLoop.
 class ScopedIDBKeyPathHelper {
  public:
   ScopedIDBKeyPathHelper() {
     key_path_helper_ = new IDBKeyPathHelper();
     key_path_helper_->CreateUtilityProcess();
-    content::RunMessageLoop();
+    RunMessageLoop();
   }
 
   ~ScopedIDBKeyPathHelper() {
     key_path_helper_->DestroyUtilityProcess();
-    content::RunMessageLoop();
+    RunMessageLoop();
   }
 
   void SetExpectedKeys(int id,
                        const std::vector<IndexedDBKey>& expected_keys,
                        bool failed) {
     key_path_helper_->SetExpectedKeys(id, expected_keys, failed);
   }
 
   void SetExpectedValue(const SerializedScriptValue& expected_value) {
     key_path_helper_->SetExpectedValue(expected_value);
   }
 
   void CheckValuesForKeyPath(
       int id,
       const std::vector<SerializedScriptValue>&
           serialized_script_values,
       const IndexedDBKeyPath& key_path) {
     key_path_helper_->CheckValuesForKeyPath(id, serialized_script_values,
                                             key_path);
-    content::RunMessageLoop();
+    RunMessageLoop();
   }
 
   void CheckInjectValue(const IndexedDBKey& key,
                         const SerializedScriptValue& value,
                         const IndexedDBKeyPath& key_path) {
     key_path_helper_->CheckInjectValue(key, value, key_path);
-    content::RunMessageLoop();
+    RunMessageLoop();
   }
 
  private:
   scoped_refptr<IDBKeyPathHelper> key_path_helper_;
 };
 
 // Cases:
-IN_PROC_BROWSER_TEST_F(InProcessBrowserTest, IDBKeyPathExtract) {
+IN_PROC_BROWSER_TEST_F(ContentBrowserTest, IDBKeyPathExtract) {
   ScopedIDBKeyPathHelper scoped_helper;
   const int kId = 7;
   std::vector<IndexedDBKey> expected_keys;
   std::vector<SerializedScriptValue> serialized_values;
 
   IndexedDBKey string_zoo_key;
   string_zoo_key.SetString(UTF8ToUTF16("zoo"));
   IndexedDBKey null_key;
   null_key.SetNull();
   IndexedDBKey invalid_key;
@@ skipping 23 matching lines @@
   expected_keys.push_back(null_key);
 
   scoped_helper.SetExpectedKeys(kId, expected_keys, false);
 
   IndexedDBKeyPath key_path;
   key_path.SetString(UTF8ToUTF16("foo"));
   scoped_helper.CheckValuesForKeyPath(
       kId, serialized_values, key_path);
 }
 
-IN_PROC_BROWSER_TEST_F(InProcessBrowserTest, IDBKeyPathPropertyNotAvailable) {
+IN_PROC_BROWSER_TEST_F(ContentBrowserTest, IDBKeyPathPropertyNotAvailable) {
   ScopedIDBKeyPathHelper scoped_helper;
   const int kId = 7;
   std::vector<IndexedDBKey> expected_keys;
   IndexedDBKey null_value;
   null_value.SetNull();
   expected_keys.push_back(null_value);
   expected_keys.push_back(null_value);
 
   scoped_helper.SetExpectedKeys(kId, expected_keys, false);
 
   std::vector<SerializedScriptValue> serialized_values;
   // {foo: "zoo", bar: null}
   char16 data[] = {0x0353, 0x6f66, 0x536f, 0x7a03, 0x6f6f, 0x0353, 0x6162,
                    0x3072, 0x027b};
   serialized_values.push_back(SerializedScriptValue(
       false, false, string16(data, arraysize(data))));
 
   // null
   serialized_values.push_back(
       SerializedScriptValue(true, false, string16()));
 
   IndexedDBKeyPath key_path;
   key_path.SetString(UTF8ToUTF16("PropertyNotAvailable"));
   scoped_helper.CheckValuesForKeyPath(kId, serialized_values, key_path);
 }
 
-IN_PROC_BROWSER_TEST_F(InProcessBrowserTest, IDBKeyPathMultipleCalls) {
+IN_PROC_BROWSER_TEST_F(ContentBrowserTest, IDBKeyPathMultipleCalls) {
   ScopedIDBKeyPathHelper scoped_helper;
   const int kId = 7;
   std::vector<IndexedDBKey> expected_keys;
 
   IndexedDBKey null_value;
   null_value.SetNull();
   expected_keys.push_back(null_value);
   expected_keys.push_back(null_value);
   scoped_helper.SetExpectedKeys(kId, expected_keys, false);
 
@@ skipping 17 matching lines @@
   expected_keys.clear();
   IndexedDBKey value;
   value.SetString(UTF8ToUTF16("zoo"));
   expected_keys.push_back(value);
   expected_keys.push_back(null_value);
   scoped_helper.SetExpectedKeys(kId + 1, expected_keys, false);
   key_path.SetString(UTF8ToUTF16("foo"));
   scoped_helper.CheckValuesForKeyPath(kId + 1, serialized_values, key_path);
 }
 
-IN_PROC_BROWSER_TEST_F(InProcessBrowserTest, InjectIDBKey) {
+IN_PROC_BROWSER_TEST_F(ContentBrowserTest, InjectIDBKey) {
   // {foo: 'zoo'}
   const char16 initial_data[] = {0x0353,0x6f66,0x536f,0x7a03,0x6f6f,0x017b};
   SerializedScriptValue value(
       false, false, string16(initial_data, arraysize(initial_data)));
   IndexedDBKey key;
   key.SetString(UTF8ToUTF16("myNewKey"));
 
   ScopedIDBKeyPathHelper scoped_helper;
 
   // {foo: 'zoo', bar: 'myNewKey'}
@@ skipping 20 matching lines @@
                                    0x5301, 0x6203, 0x7261, 0x013f, 0x3f6f,
                                    0x5302, 0x6203, 0x7a61, 0x023f, 0x0853,
                                    0x796d, 0x654e, 0x4b77, 0x7965, 0x017b,
                                    0x027b};
   SerializedScriptValue expected_value2(
       false, false, string16(expected_data2, arraysize(expected_data2)));
   scoped_helper.SetExpectedValue(expected_value2);
   key_path.SetString(UTF8ToUTF16("bar.baz"));
   scoped_helper.CheckInjectValue(key, value, key_path);
 }
+
+}  // namespace content