Remove base::StringValue

chrome/test/base/web_ui_browser_test_browsertest.cc

 // Copyright 2014 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 <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 72 matching lines @@
 // Tests that the async framework works.
 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", new base::StringValue("testFailsAssert"));
+    RunJavascriptFunction("runAsync", new base::Value("testFailsAssert"));
   }
 
   // Starts a passing test.
   void RunTestPasses() {
-    RunJavascriptFunction("runAsync", new base::StringValue("testPasses"));
+    RunJavascriptFunction("runAsync", new base::Value("testPasses"));
   }
 
  protected:
   WebUIBrowserAsyncTest() {}
 
   // Class to synchronize asynchronous javascript activity with the tests.
   class AsyncWebUIMessageHandler : public WebUIMessageHandler {
    public:
     AsyncWebUIMessageHandler() {}
 
@@ skipping 49 matching lines @@
 // Test that assertions fail immediately after assertion fails (no testContinues
 // 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", new base::StringValue("testFailsAssert")));
+  ASSERT_FALSE(RunJavascriptAsyncTest("startAsyncTest",
+                                      new base::Value("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", new base::StringValue("testFailsExpect")));
+  ASSERT_FALSE(RunJavascriptAsyncTest("startAsyncTest",
+                                      new base::Value("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", new base::StringValue("testPasses")));
+  ASSERT_TRUE(
+      RunJavascriptAsyncTest("startAsyncTest", new base::Value("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", new base::StringValue("testPasses")));
+  ASSERT_TRUE(
+      RunJavascriptAsyncTest("startAsyncTest", new base::Value("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", new base::StringValue("testPasses")));
+  ASSERT_FALSE(
+      RunJavascriptAsyncTest("startAsyncTest", new base::Value("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", new base::StringValue("testAsyncDoneFailFirstSyncPass")));
+      "runAsync", new base::Value("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"));
 }