Support javascript gtests in an extension background page.

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/values.h"
 #include "chrome/common/url_constants.h"
@@ skipping 63 matching lines @@
   ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUIDownloadsURL));
   EXPECT_FATAL_FAILURE(
       RunJavascriptAsyncTestNoReturn("DISABLED_BogusFunctionName"),
       "WebUITestHandler::JavaScriptComplete");
 }
 
 // Tests that the async framework works.
 class WebUIBrowserAsyncTest : public WebUIBrowserTest {
  public:
   // Calls the testDone() function from test_api.js
-  void TestDone() {
-    RunJavascriptFunction("testDone");
-  }
+  void TestDone() { RunJavascriptFunction("testDone"); }

[Peter Lundblad, 2014/06/08 23:27:22]

Is this file *just* git cl format or is there any non-style change here?
If the former, can we dorp it from the cl to not disttact the rest?

[David Tseng, 2014/06/10 05:35:22]

reverted file.

 
   // Starts a failing test.
   void RunTestFailsAssert() {
     RunJavascriptFunction("runAsync", new base::StringValue("testFailsAssert"));
   }
 
   // Starts a passing test.
   void RunTestPasses() {
     RunJavascriptFunction("runAsync", new base::StringValue("testPasses"));
   }
 
  protected:
   WebUIBrowserAsyncTest() {}
 
   // Class to synchronize asynchronous javascript activity with the tests.
   class AsyncWebUIMessageHandler : public WebUIMessageHandler {
    public:
     AsyncWebUIMessageHandler() {}
 
     MOCK_METHOD1(HandleTestContinues, void(const base::ListValue*));
     MOCK_METHOD1(HandleTestFails, void(const base::ListValue*));
     MOCK_METHOD1(HandleTestPasses, void(const base::ListValue*));
 
    private:
     virtual void RegisterMessages() OVERRIDE {
-      web_ui()->RegisterMessageCallback("startAsyncTest",
+      web_ui()->RegisterMessageCallback(
+          "startAsyncTest",
           base::Bind(&AsyncWebUIMessageHandler::HandleStartAsyncTest,
                      base::Unretained(this)));
-      web_ui()->RegisterMessageCallback("testContinues",
+      web_ui()->RegisterMessageCallback(
+          "testContinues",
           base::Bind(&AsyncWebUIMessageHandler::HandleTestContinues,
                      base::Unretained(this)));
-      web_ui()->RegisterMessageCallback("testFails",
+      web_ui()->RegisterMessageCallback(
+          "testFails",
           base::Bind(&AsyncWebUIMessageHandler::HandleTestFails,
                      base::Unretained(this)));
-      web_ui()->RegisterMessageCallback("testPasses",
+      web_ui()->RegisterMessageCallback(
+          "testPasses",
           base::Bind(&AsyncWebUIMessageHandler::HandleTestPasses,
                      base::Unretained(this)));
     }
 
     // Starts the test in |list_value|[0] with the runAsync wrapper.
     void HandleStartAsyncTest(const base::ListValue* list_value) {
       const base::Value* test_name;
       ASSERT_TRUE(list_value->Get(0, &test_name));
       web_ui()->CallJavascriptFunction("runAsync", *test_name);
     }
@@ skipping 46 matching lines @@
 // 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")));
+  EXPECT_CALL(message_handler_, HandleTestPasses(::testing::_)).WillOnce(
+      ::testing::InvokeWithoutArgs(this, &WebUIBrowserAsyncTest::TestDone));
+  ASSERT_TRUE(RunJavascriptAsyncTest("startAsyncTest",
+                                     new base::StringValue("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")));
+  EXPECT_CALL(message_handler_, HandleTestPasses(::testing::_)).WillOnce(
+      ::testing::InvokeWithoutArgs(this, &WebUIBrowserAsyncTest::TestDone));
+  ASSERT_TRUE(RunJavascriptAsyncTest("startAsyncTest",
+                                     new base::StringValue("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::StringValue("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")));
 }
 
 // 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"));
 }