more changes

chrome/browser/ui/webui/web_ui_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 "chrome/browser/ui/webui/web_ui_browsertest.h"
 
 #include <string>
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/path_service.h"
@@ skipping 64 matching lines @@
 bool WebUIBrowserTest::RunJavascriptFunction(
     const std::string& function_name,
     const ConstValueVector& function_arguments) {
   return RunJavascriptUsingHandler(
       function_name, function_arguments, false, false, NULL);
 }
 
 bool WebUIBrowserTest::RunJavascriptTestF(const std::string& test_fixture,
                                           const std::string& test_name) {
   ConstValueVector args;
-  args.push_back(Value::CreateStringValue(test_fixture));
-  args.push_back(Value::CreateStringValue(test_name));
+  args.push_back(base::StringValue::New(test_fixture));
+  args.push_back(base::StringValue::New(test_name));
   return RunJavascriptTest("RUN_TEST_F", args);
 }
 
 bool WebUIBrowserTest::RunJavascriptTest(const std::string& test_name) {
   return RunJavascriptTest(test_name, ConstValueVector());
 }
 
 bool WebUIBrowserTest::RunJavascriptTest(const std::string& test_name,
                                          const Value& arg) {
   ConstValueVector args;
@@ skipping 42 matching lines @@
     const ConstValueVector& test_arguments) {
   return RunJavascriptUsingHandler(test_name, test_arguments, true, true, NULL);
 }
 
 void WebUIBrowserTest::PreLoadJavascriptLibraries(
     const std::string& preload_test_fixture,
     const std::string& preload_test_name,
     RenderViewHost* preload_host) {
   ASSERT_FALSE(libraries_preloaded_);
   ConstValueVector args;
-  args.push_back(Value::CreateStringValue(preload_test_fixture));
-  args.push_back(Value::CreateStringValue(preload_test_name));
+  args.push_back(base::StringValue::New(preload_test_fixture));
+  args.push_back(base::StringValue::New(preload_test_name));
   RunJavascriptUsingHandler(
       "preloadJavascriptLibraries", args, false, false, preload_host);
   libraries_preloaded_ = true;
 }
 
 void WebUIBrowserTest::BrowsePreload(const GURL& browse_to,
                                      const std::string& preload_test_fixture,
                                      const std::string& preload_test_name) {
   // Remember for callback OnJsInjectionReady().
   preload_test_fixture_ = preload_test_fixture;
@@ skipping 87 matching lines @@
     utf8_content.append(";\n");
   }
   content->append(UTF8ToUTF16(utf8_content));
 }
 
 string16 WebUIBrowserTest::BuildRunTestJSCall(
     bool is_async,
     const std::string& function_name,
     const WebUIBrowserTest::ConstValueVector& test_func_args) {
   WebUIBrowserTest::ConstValueVector arguments;
-  base::FundamentalValue is_async_arg(is_async);
+  base::BooleanValue is_async_arg(is_async);
   arguments.push_back(&is_async_arg);
   StringValue function_name_arg(function_name);
   arguments.push_back(&function_name_arg);
   ListValue baked_argument_list;
   WebUIBrowserTest::ConstValueVector::const_iterator arguments_iterator;
   for (arguments_iterator = test_func_args.begin();
        arguments_iterator != test_func_args.end();
        ++arguments_iterator) {
     baked_argument_list.Append((Value *)*arguments_iterator);
   }
@@ skipping 114 matching lines @@
 class WebUIBrowserAsyncTest : public WebUIBrowserTest {
  public:
   // Calls the testDone() function from test_api.js
   void TestDone() {
     RunJavascriptFunction("testDone");
   }
 
   // Starts a failing test.
   void RunTestFailsAssert() {
     RunJavascriptFunction("runAsync",
-                          *Value::CreateStringValue("testFailsAssert"));
+                          *base::StringValue::New("testFailsAssert"));
   }
 
   // Starts a passing test.
   void RunTestPasses() {
-    RunJavascriptFunction("runAsync", *Value::CreateStringValue("testPasses"));
+    RunJavascriptFunction("runAsync", *base::StringValue::New("testPasses"));
   }
 
  protected:
   WebUIBrowserAsyncTest() {}
 
   static const char kDummyURL[];
 
   // Class to synchronize asynchronous javascript activity with the tests.
   class AsyncWebUIMessageHandler : public WebUIMessageHandler {
    public:
@@ skipping 77 matching lines @@
 // message). (Sync version).
 IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestSyncOkTestFail) {
   ASSERT_FALSE(RunJavascriptTest("testFailsAssert"));
 }
 
 // Test that assertions fail immediately after assertion fails (no testContinues
 // message). (Async version).
 IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncFailsAssert) {
   EXPECT_CALL(message_handler_, HandleTestFails(::testing::_));
   ASSERT_FALSE(RunJavascriptAsyncTest(
-      "startAsyncTest", *Value::CreateStringValue("testFailsAssert")));
+      "startAsyncTest", *base::StringValue::New("testFailsAssert")));
 }
 
 // Test that expectations continue the function, but fail the test.
 IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncFailsExpect) {
   ::testing::InSequence s;
   EXPECT_CALL(message_handler_, HandleTestContinues(::testing::_));
   EXPECT_CALL(message_handler_, HandleTestFails(::testing::_));
   ASSERT_FALSE(RunJavascriptAsyncTest(
-      "startAsyncTest", *Value::CreateStringValue("testFailsExpect")));
+      "startAsyncTest", *base::StringValue::New("testFailsExpect")));
 }
 
 // Test that test continues and passes. (Sync version).
 IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestSyncPasses) {
   EXPECT_CALL(message_handler_, HandleTestContinues(::testing::_));
   ASSERT_TRUE(RunJavascriptTest("testPasses"));
 }
 
 // Test that test continues and passes. (Async version).
 IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncPasses) {
   ::testing::InSequence s;
   EXPECT_CALL(message_handler_, HandleTestContinues(::testing::_));
   EXPECT_CALL(message_handler_, HandleTestPasses(::testing::_))
       .WillOnce(::testing::InvokeWithoutArgs(
           this, &WebUIBrowserAsyncTest::TestDone));
   ASSERT_TRUE(RunJavascriptAsyncTest(
-      "startAsyncTest", *Value::CreateStringValue("testPasses")));
+      "startAsyncTest", *base::StringValue::New("testPasses")));
 }
 
 // Test that two tests pass.
 IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncPassPass) {
   ::testing::InSequence s;
   EXPECT_CALL(message_handler_, HandleTestContinues(::testing::_));
   EXPECT_CALL(message_handler_, HandleTestPasses(::testing::_))
       .WillOnce(::testing::InvokeWithoutArgs(
           this, &WebUIBrowserAsyncTest::RunTestPasses));
   EXPECT_CALL(message_handler_, HandleTestContinues(::testing::_));
   EXPECT_CALL(message_handler_, HandleTestPasses(::testing::_))
       .WillOnce(::testing::InvokeWithoutArgs(
           this, &WebUIBrowserAsyncTest::TestDone));
   ASSERT_TRUE(RunJavascriptAsyncTest(
-      "startAsyncTest", *Value::CreateStringValue("testPasses")));
+      "startAsyncTest", *base::StringValue::New("testPasses")));
 }
 
 // Test that first test passes; second fails.
 IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncPassThenFail) {
   ::testing::InSequence s;
   EXPECT_CALL(message_handler_, HandleTestContinues(::testing::_));
   EXPECT_CALL(message_handler_, HandleTestPasses(::testing::_))
       .WillOnce(::testing::InvokeWithoutArgs(
           this, &WebUIBrowserAsyncTest::RunTestFailsAssert));
   EXPECT_CALL(message_handler_, HandleTestFails(::testing::_));
   ASSERT_FALSE(RunJavascriptAsyncTest(
-      "startAsyncTest", *Value::CreateStringValue("testPasses")));
+      "startAsyncTest", *base::StringValue::New("testPasses")));
 }
 
 // Test that testDone() with failure first then sync pass still fails.
 IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncDoneFailFirstSyncPass) {
   ::testing::InSequence s;
   EXPECT_CALL(message_handler_, HandleTestContinues(::testing::_));
   EXPECT_CALL(message_handler_, HandleTestFails(::testing::_));
 
   // Call runAsync directly instead of deferring through startAsyncTest. It will
   // call testDone() on failure, then return.
   ASSERT_FALSE(RunJavascriptAsyncTest(
-      "runAsync", *Value::CreateStringValue("testAsyncDoneFailFirstSyncPass")));
+      "runAsync", *base::StringValue::New("testAsyncDoneFailFirstSyncPass")));
 }
 
 // Test that calling testDone during RunJavascriptAsyncTest still completes
 // when waiting for async result. This is similar to the previous test, but call
 // testDone directly and expect pass result.
 IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestTestDoneEarlyPassesAsync) {
   ASSERT_TRUE(RunJavascriptAsyncTest("testDone"));
 }
 
 // Test that calling testDone during RunJavascriptTest still completes when
 // waiting for async result.
 IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestTestDoneEarlyPasses) {
   ASSERT_TRUE(RunJavascriptTest("testDone"));
 }