Update net-internals unit tests to use the new async

test framework.  Also make the framework take pointers
instead of references to Values it deletes.

TEST=NetInternalsTest.*
BUG=none

Review URL: http://codereview.chromium.org/7670035

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@97332 0039d316-1c4b-4281-b951-d872f2087c98

10 files changed, 117 insertions, 226 deletions

diff --git a/chrome/browser/ui/webui/BidiCheckerWebUITest.cc b/chrome/browser/ui/webui/BidiCheckerWebUITest.cc
index fb58e9b8..79308ce 100644
--- a/chrome/browser/ui/webui/BidiCheckerWebUITest.cc
+++ b/chrome/browser/ui/webui/BidiCheckerWebUITest.cc
@@ -46,8 +46,8 @@ void WebUIBidiCheckerBrowserTest::RunBidiCheckerOnPage(const char pageURL[],
                                                        bool isRTL) {
   ui_test_utils::NavigateToURL(browser(), GURL(pageURL));
   ASSERT_TRUE(RunJavascriptTest("runBidiChecker",
-                                *Value::CreateStringValue(pageURL),
-                                *Value::CreateBooleanValue(isRTL)));
+                                Value::CreateStringValue(pageURL),
+                                Value::CreateBooleanValue(isRTL)));
 }
 
 IN_PROC_BROWSER_TEST_F(WebUIBidiCheckerBrowserTest, TestMainHistoryPageLTR) {
diff --git a/chrome/browser/ui/webui/net_internals_ui_browsertest.cc b/chrome/browser/ui/webui/net_internals_ui_browsertest.cc
index a94233f..6b6ead9 100644
--- a/chrome/browser/ui/webui/net_internals_ui_browsertest.cc
+++ b/chrome/browser/ui/webui/net_internals_ui_browsertest.cc
@@ -17,9 +17,6 @@
 
 namespace {
 
-const string16 kPassTitle = ASCIIToUTF16("Test Passed");
-const string16 kFailTitle = ASCIIToUTF16("Test Failed");
-
 // Class to handle messages from the renderer needed by certain tests.
 class NetInternalsTestMessageHandler : public WebUIMessageHandler {
  public:
@@ -61,8 +58,6 @@ void NetInternalsTestMessageHandler::OpenNewTab(const ListValue* list_value) {
       ui_test_utils::BROWSER_TEST_NONE);
 }
 
-// Each test involves calls a single Javascript function and then waits for the
-// title to be changed to "Test Passed" or "Test Failed" when done.
 class NetInternalsTest : public WebUIBrowserTest {
  public:
   NetInternalsTest();
@@ -73,22 +68,6 @@ class NetInternalsTest : public WebUIBrowserTest {
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE;
   virtual void SetUpOnMainThread() OVERRIDE;
 
-  // Runs the specified Javascript test function with the specified arguments
-  // and waits for the title to change to "Test Passed" or "Test Failed".
-  void RunTestAndWaitForTitle(const std::string& function_name,
-                              const ListValue& function_arguments);
-
-  // Same as above, with constant number of arguments for easy use.  Will also
-  // free arguments.
-  void RunTestAndWaitForTitle(const std::string& function_name);
-  void RunTestAndWaitForTitle(const std::string& function_name, Value* arg);
-  void RunTestAndWaitForTitle(const std::string& function_name,
-                              Value* arg1, Value* arg2);
-  void RunTestAndWaitForTitle(const std::string& function_name,
-                              Value* arg1, Value* arg2, Value* arg3);
-
-  void set_expected_title_(const string16& value) { expected_title_ = value; }
-
  private:
   virtual WebUIMessageHandler* GetMockMessageHandler() OVERRIDE {
     message_handler_.set_browser(browser());
@@ -97,13 +76,10 @@ class NetInternalsTest : public WebUIBrowserTest {
 
   NetInternalsTestMessageHandler message_handler_;
 
-  // The expected title at the end of the test.  Defaults to kPassTitle.
-  string16 expected_title_;
-
   DISALLOW_COPY_AND_ASSIGN(NetInternalsTest);
 };
 
-NetInternalsTest::NetInternalsTest() : expected_title_(kPassTitle) {
+NetInternalsTest::NetInternalsTest() {
 }
 
 NetInternalsTest::~NetInternalsTest() {
@@ -138,92 +114,41 @@ void NetInternalsTest::SetUpOnMainThread() {
                                GURL(chrome::kChromeUINetInternalsURL));
 }
 
-void NetInternalsTest::RunTestAndWaitForTitle(
-    const std::string& function_name,
-    const ListValue& function_arguments) {
-  ui_test_utils::TitleWatcher title_watcher(browser()->GetTabContentsAt(0),
-                                            kPassTitle);
-  title_watcher.AlsoWaitForTitle(kFailTitle);
-
-  ConstValueVector arguments;
-  StringValue function_name_arg(function_name);
-  arguments.push_back(&function_name_arg);
-  arguments.push_back(&function_arguments);
-
-  ASSERT_TRUE(RunJavascriptFunction("netInternalsTest.runTest", arguments));
-  ASSERT_EQ(expected_title_, title_watcher.WaitAndGetTitle());
-}
-
-void NetInternalsTest::RunTestAndWaitForTitle(
-    const std::string& function_name) {
-  ListValue test_arguments;
-  RunTestAndWaitForTitle(function_name, test_arguments);
-}
-
-void NetInternalsTest::RunTestAndWaitForTitle(const std::string& function_name,
-                                              Value* arg) {
-  ListValue test_arguments;
-  test_arguments.Append(arg);
-  RunTestAndWaitForTitle(function_name, test_arguments);
-}
-
-void NetInternalsTest::RunTestAndWaitForTitle(const std::string& function_name,
-                                              Value* arg1, Value* arg2) {
-  ListValue test_arguments;
-  test_arguments.Append(arg1);
-  test_arguments.Append(arg2);
-  RunTestAndWaitForTitle(function_name, test_arguments);
-}
-
-void NetInternalsTest::RunTestAndWaitForTitle(const std::string& function_name,
-                                              Value* arg1, Value* arg2,
-                                              Value* arg3) {
-  ListValue test_arguments;
-  test_arguments.Append(arg1);
-  test_arguments.Append(arg2);
-  test_arguments.Append(arg3);
-  RunTestAndWaitForTitle(function_name, test_arguments);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // net_internals_ui.js
 ////////////////////////////////////////////////////////////////////////////////
 
 // Checks testDone.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsDone) {
-  RunTestAndWaitForTitle("NetInternalsDone");
+  EXPECT_TRUE(RunJavascriptAsyncTest("netInternalsDone"));
 }
 
 // Checks a failed expect statement.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsExpectFail) {
-  set_expected_title_(kFailTitle);
-  RunTestAndWaitForTitle("NetInternalsExpectFail");
+  EXPECT_FALSE(RunJavascriptAsyncTest("netInternalsExpectFail"));
 }
 
 // Checks a failed assert statement.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsAssertFail) {
-  set_expected_title_(kFailTitle);
-  RunTestAndWaitForTitle("NetInternalsAssertFail");
+  EXPECT_FALSE(RunJavascriptAsyncTest("netInternalsAssertFail"));
 }
 
 // Checks that testDone works when called by an observer in response to an
 // event.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsObserverDone) {
-  RunTestAndWaitForTitle("NetInternalsObserverDone");
+  EXPECT_TRUE(RunJavascriptAsyncTest("netInternalsObserverDone"));
 }
 
 // Checks that a failed expect works when called by an observer in response
 // to an event.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsObserverExpectFail) {
-  set_expected_title_(kFailTitle);
-  RunTestAndWaitForTitle("NetInternalsObserverExpectFail");
+  EXPECT_FALSE(RunJavascriptAsyncTest("netInternalsObserverExpectFail"));
 }
 
 // Checks that a failed assertion works when called by an observer in response
 // to an event.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsObserverAssertFail) {
-  set_expected_title_(kFailTitle);
-  RunTestAndWaitForTitle("NetInternalsObserverAssertFail");
+  EXPECT_FALSE(RunJavascriptAsyncTest("netInternalsObserverAssertFail"));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -232,7 +157,7 @@ IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsObserverAssertFail) {
 
 // Checks tabs initialization and switching between tabs.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsTourTabs) {
-  RunTestAndWaitForTitle("NetInternalsTourTabs");
+  EXPECT_TRUE(RunJavascriptAsyncTest("netInternalsTourTabs"));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -245,7 +170,7 @@ IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsTourTabs) {
 // TODO(mmenke):  Add some checks for the import view.
 // TODO(mmenke):  Add a test for a log created with --log-net-log.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsExportImportDump) {
-  RunTestAndWaitForTitle("NetInternalsExportImportDump");
+  EXPECT_TRUE(RunJavascriptAsyncTest("netInternalsExportImportDump"));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -257,29 +182,29 @@ IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsExportImportDump) {
 // the table.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsTestViewPassTwice) {
   ASSERT_TRUE(test_server()->Start());
-  RunTestAndWaitForTitle(
-      "NetInternalsTestView",
+  EXPECT_TRUE(RunJavascriptAsyncTest(
+      "netInternalsTestView",
       // URL that results in success.
       Value::CreateStringValue(
           test_server()->GetURL("files/title1.html").spec()),
       // Resulting error code of the first test.
       Value::CreateIntegerValue(net::OK),
       // Number of times to run the test suite.
-      Value::CreateIntegerValue(2));
+      Value::CreateIntegerValue(2)));
 }
 
 // Runs the test suite twice, expecting a failing result the first time.  Checks
 // the first result, the order of events that occur, and the number of rows in
 // the table.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsTestViewFailTwice) {
-  RunTestAndWaitForTitle(
-      "NetInternalsTestView",
+  EXPECT_TRUE(RunJavascriptAsyncTest(
+      "netInternalsTestView",
       // URL that results in an error, due to the port.
       Value::CreateStringValue("http://127.0.0.1:7/"),
       // Resulting error code of the first test.
       Value::CreateIntegerValue(net::ERR_UNSAFE_PORT),
       // Number of times to run the test suite.
-      Value::CreateIntegerValue(2));
+      Value::CreateIntegerValue(2)));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -289,27 +214,27 @@ IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsTestViewFailTwice) {
 // Prerender a page and navigate to it, once prerendering starts.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsPrerenderViewSucceed) {
   ASSERT_TRUE(test_server()->Start());
-  RunTestAndWaitForTitle(
-      "NetInternalsPrerenderView",
+  EXPECT_TRUE(RunJavascriptAsyncTest(
+      "netInternalsPrerenderView",
       // URL that can be prerendered.
       Value::CreateStringValue(
           test_server()->GetURL("files/title1.html").spec()),
       Value::CreateBooleanValue(true),
       Value::CreateStringValue(
-          prerender::NameFromFinalStatus(prerender::FINAL_STATUS_USED)));
+          prerender::NameFromFinalStatus(prerender::FINAL_STATUS_USED))));
 }
 
 // Prerender a page that is expected to fail.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsPrerenderViewFail) {
   ASSERT_TRUE(test_server()->Start());
-  RunTestAndWaitForTitle(
-      "NetInternalsPrerenderView",
+  EXPECT_TRUE(RunJavascriptAsyncTest(
+      "netInternalsPrerenderView",
       // URL that can't be prerendered, since it triggers a download.
       Value::CreateStringValue(
           test_server()->GetURL("files/download-test1.lib").spec()),
       Value::CreateBooleanValue(false),
       Value::CreateStringValue(
-          prerender::NameFromFinalStatus(prerender::FINAL_STATUS_DOWNLOAD)));
+          prerender::NameFromFinalStatus(prerender::FINAL_STATUS_DOWNLOAD))));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -319,7 +244,7 @@ IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsPrerenderViewFail) {
 // Check that we correctly remove cookies and login information.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest,
                        NetInternalsLogViewPainterStripInfo) {
-  RunTestAndWaitForTitle("NetInternalsLogViewPainterStripInfo");
+  EXPECT_TRUE(RunJavascriptAsyncTest("netInternalsLogViewPainterStripInfo"));
 }
 
 }  // namespace
diff --git a/chrome/browser/ui/webui/web_ui_browsertest.cc b/chrome/browser/ui/webui/web_ui_browsertest.cc
index 332b59f..7f88cfa 100644
--- a/chrome/browser/ui/webui/web_ui_browsertest.cc
+++ b/chrome/browser/ui/webui/web_ui_browsertest.cc
@@ -57,18 +57,18 @@ bool WebUIBrowserTest::RunJavascriptFunction(const std::string& function_name) {
 }
 
 bool WebUIBrowserTest::RunJavascriptFunction(const std::string& function_name,
-                                             const Value& arg) {
+                                             Value* arg) {
   ConstValueVector args;
-  args.push_back(&arg);
+  args.push_back(arg);
   return RunJavascriptFunction(function_name, args);
 }
 
 bool WebUIBrowserTest::RunJavascriptFunction(const std::string& function_name,
-                                             const Value& arg1,
-                                             const Value& arg2) {
+                                             Value* arg1,
+                                             Value* arg2) {
   ConstValueVector args;
-  args.push_back(&arg1);
-  args.push_back(&arg2);
+  args.push_back(arg1);
+  args.push_back(arg2);
   return RunJavascriptFunction(function_name, args);
 }
 
@@ -92,18 +92,18 @@ bool WebUIBrowserTest::RunJavascriptTest(const std::string& test_name) {
 }
 
 bool WebUIBrowserTest::RunJavascriptTest(const std::string& test_name,
-                                         const Value& arg) {
+                                         Value* arg) {
   ConstValueVector args;
-  args.push_back(&arg);
+  args.push_back(arg);
   return RunJavascriptTest(test_name, args);
 }
 
 bool WebUIBrowserTest::RunJavascriptTest(const std::string& test_name,
-                                         const Value& arg1,
-                                         const Value& arg2) {
+                                         Value* arg1,
+                                         Value* arg2) {
   ConstValueVector args;
-  args.push_back(&arg1);
-  args.push_back(&arg2);
+  args.push_back(arg1);
+  args.push_back(arg2);
   return RunJavascriptTest(test_name, args);
 }
 
@@ -119,18 +119,29 @@ bool WebUIBrowserTest::RunJavascriptAsyncTest(const std::string& test_name) {
 }
 
 bool WebUIBrowserTest::RunJavascriptAsyncTest(const std::string& test_name,
-                                         const Value& arg) {
+                                              Value* arg) {
   ConstValueVector args;
-  args.push_back(&arg);
+  args.push_back(arg);
   return RunJavascriptAsyncTest(test_name, args);
 }
 
 bool WebUIBrowserTest::RunJavascriptAsyncTest(const std::string& test_name,
-                                         const Value& arg1,
-                                         const Value& arg2) {
+                                              Value* arg1,
+                                              Value* arg2) {
   ConstValueVector args;
-  args.push_back(&arg1);
-  args.push_back(&arg2);
+  args.push_back(arg1);
+  args.push_back(arg2);
+  return RunJavascriptAsyncTest(test_name, args);
+}
+
+bool WebUIBrowserTest::RunJavascriptAsyncTest(const std::string& test_name,
+                                              Value* arg1,
+                                              Value* arg2,
+                                              Value* arg3) {
+  ConstValueVector args;
+  args.push_back(arg1);
+  args.push_back(arg2);
+  args.push_back(arg3);
   return RunJavascriptAsyncTest(test_name, args);
 }
 
@@ -390,12 +401,12 @@ class WebUIBrowserAsyncTest : public WebUIBrowserTest {
   // Starts a failing test.
   void RunTestFailsAssert() {
     RunJavascriptFunction("runAsync",
-                          *Value::CreateStringValue("testFailsAssert"));
+                          Value::CreateStringValue("testFailsAssert"));
   }
 
   // Starts a passing test.
   void RunTestPasses() {
-    RunJavascriptFunction("runAsync", *Value::CreateStringValue("testPasses"));
+    RunJavascriptFunction("runAsync", Value::CreateStringValue("testPasses"));
   }
 
  protected:
@@ -493,7 +504,7 @@ IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestSyncOkTestFail) {
 IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncFailsAssert) {
   EXPECT_CALL(message_handler_, HandleTestFails(::testing::_));
   ASSERT_FALSE(RunJavascriptAsyncTest(
-      "startAsyncTest", *Value::CreateStringValue("testFailsAssert")));
+      "startAsyncTest", Value::CreateStringValue("testFailsAssert")));
 }
 
 // Test that expectations continue the function, but fail the test.
@@ -502,7 +513,7 @@ IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncFailsExpect) {
   EXPECT_CALL(message_handler_, HandleTestContinues(::testing::_));
   EXPECT_CALL(message_handler_, HandleTestFails(::testing::_));
   ASSERT_FALSE(RunJavascriptAsyncTest(
-      "startAsyncTest", *Value::CreateStringValue("testFailsExpect")));
+      "startAsyncTest", Value::CreateStringValue("testFailsExpect")));
 }
 
 // Test that test continues and passes. (Sync version).
@@ -519,7 +530,7 @@ IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncPasses) {
       .WillOnce(::testing::InvokeWithoutArgs(
           this, &WebUIBrowserAsyncTest::TestDone));
   ASSERT_TRUE(RunJavascriptAsyncTest(
-      "startAsyncTest", *Value::CreateStringValue("testPasses")));
+      "startAsyncTest", Value::CreateStringValue("testPasses")));
 }
 
 // Test that two tests pass.
@@ -534,7 +545,7 @@ IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncPassPass) {
       .WillOnce(::testing::InvokeWithoutArgs(
           this, &WebUIBrowserAsyncTest::TestDone));
   ASSERT_TRUE(RunJavascriptAsyncTest(
-      "startAsyncTest", *Value::CreateStringValue("testPasses")));
+      "startAsyncTest", Value::CreateStringValue("testPasses")));
 }
 
 // Test that first test passes; second fails.
@@ -546,7 +557,7 @@ IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncPassThenFail) {
           this, &WebUIBrowserAsyncTest::RunTestFailsAssert));
   EXPECT_CALL(message_handler_, HandleTestFails(::testing::_));
   ASSERT_FALSE(RunJavascriptAsyncTest(
-      "startAsyncTest", *Value::CreateStringValue("testPasses")));
+      "startAsyncTest", Value::CreateStringValue("testPasses")));
 }
 
 // Test that testDone() with failure first then sync pass still fails.
@@ -558,7 +569,7 @@ IN_PROC_BROWSER_TEST_F(WebUIBrowserAsyncTest, TestAsyncDoneFailFirstSyncPass) {
   // Call runAsync directly instead of deferring through startAsyncTest. It will
   // call testDone() on failure, then return.
   ASSERT_FALSE(RunJavascriptAsyncTest(
-      "runAsync", *Value::CreateStringValue("testAsyncDoneFailFirstSyncPass")));
+      "runAsync", Value::CreateStringValue("testAsyncDoneFailFirstSyncPass")));
 }
 
 // Test that calling testDone during RunJavascriptAsyncTest still completes
diff --git a/chrome/browser/ui/webui/web_ui_browsertest.h b/chrome/browser/ui/webui/web_ui_browsertest.h
index 13b2c40..7ac42d0 100644
--- a/chrome/browser/ui/webui/web_ui_browsertest.h
+++ b/chrome/browser/ui/webui/web_ui_browsertest.h
@@ -49,12 +49,13 @@ class WebUIBrowserTest
 
   // Runs a javascript function in the context of all libraries.
   // Note that calls to functions in test_api.js are not supported.
+  // Takes ownership of Value arguments.
   bool RunJavascriptFunction(const std::string& function_name);
   bool RunJavascriptFunction(const std::string& function_name,
-                             const base::Value& arg);
+                             base::Value* arg);
   bool RunJavascriptFunction(const std::string& function_name,
-                             const base::Value& arg1,
-                             const base::Value& arg2);
+                             base::Value* arg1,
+                             base::Value* arg2);
   bool RunJavascriptFunction(const std::string& function_name,
                              const ConstValueVector& function_arguments);
 
@@ -63,23 +64,28 @@ class WebUIBrowserTest
                           const std::string& test_name);
 
   // Runs a test that may include calls to functions in test_api.js.
+  // Takes ownership of Value arguments.
   bool RunJavascriptTest(const std::string& test_name);
   bool RunJavascriptTest(const std::string& test_name,
-                         const base::Value& arg);
+                         base::Value* arg);
   bool RunJavascriptTest(const std::string& test_name,
-                         const base::Value& arg1,
-                         const base::Value& arg2);
+                         base::Value* arg1,
+                         base::Value* arg2);
   bool RunJavascriptTest(const std::string& test_name,
                          const ConstValueVector& test_arguments);
 
   // Runs a test that may include calls to functions in test_api.js, and waits
-  // for call to asyncTestDone().
+  // for call to asyncTestDone().  Takes ownership of Value arguments.
   bool RunJavascriptAsyncTest(const std::string& test_name);
   bool RunJavascriptAsyncTest(const std::string& test_name,
-                              const base::Value& arg);
+                              base::Value* arg);
   bool RunJavascriptAsyncTest(const std::string& test_name,
-                              const base::Value& arg1,
-                              const base::Value& arg2);
+                              base::Value* arg1,
+                              base::Value* arg2);
+  bool RunJavascriptAsyncTest(const std::string& test_name,
+                              base::Value* arg1,
+                              base::Value* arg2,
+                              base::Value* arg3);
   bool RunJavascriptAsyncTest(const std::string& test_name,
                               const ConstValueVector& test_arguments);
 
diff --git a/chrome/test/data/webui/net_internals/log_util.js b/chrome/test/data/webui/net_internals/log_util.js
index 6f40b05..5caf75f 100644
--- a/chrome/test/data/webui/net_internals/log_util.js
+++ b/chrome/test/data/webui/net_internals/log_util.js
@@ -6,7 +6,7 @@
  * Exports a log dump to a string and loads it.  Makes sure no errors occur,
  * and checks visibility of tabs aftwards.
  */
-netInternalsTest.test('NetInternalsExportImportDump', function() {
+netInternalsTest.test('netInternalsExportImportDump', function() {
   // Callback passed to |createLogDumpAsync|.  Tries to load the dumped log
   // file, and then checks tab visibility afterwards.
   // @param {string} logDumpText Log dump, as a string.
@@ -32,7 +32,7 @@ netInternalsTest.test('NetInternalsExportImportDump', function() {
     };
 
     netInternalsTest.checkTabHandleVisibility(tabVisibilityState, false);
-    netInternalsTest.testDone();
+    testDone();
   }
 
   logutil.createLogDumpAsync('Log dump test', onLogDumpCreated);
diff --git a/chrome/test/data/webui/net_internals/log_view_painter.js b/chrome/test/data/webui/net_internals/log_view_painter.js
index 81547b3..cbb2c0f 100644
--- a/chrome/test/data/webui/net_internals/log_view_painter.js
+++ b/chrome/test/data/webui/net_internals/log_view_painter.js
@@ -5,7 +5,7 @@
 /**
  * Tests the behavior of stripCookiesAndLoginInfo.
  */
-netInternalsTest.test('NetInternalsLogViewPainterStripInfo', function() {
+netInternalsTest.test('netInternalsLogViewPainterStripInfo', function() {
   // Each entry in |expectations| is a list consisting of a header element
   // before and after applying the filter.  If the second entry is null, the
   // element should be unmodified.
@@ -78,5 +78,5 @@ netInternalsTest.test('NetInternalsLogViewPainterStripInfo', function() {
       }
     }
   }
-  netInternalsTest.testDone();
+  testDone();
 });
diff --git a/chrome/test/data/webui/net_internals/main.js b/chrome/test/data/webui/net_internals/main.js
index 57898fb..279aed194 100644
--- a/chrome/test/data/webui/net_internals/main.js
+++ b/chrome/test/data/webui/net_internals/main.js
@@ -7,7 +7,7 @@
  * tabs with visible handles, validating visibility of all other tabs as it
  * goes.
  */
-netInternalsTest.test('NetInternalsTourTabs', function() {
+netInternalsTest.test('netInternalsTourTabs', function() {
   // Prevent sending any events to the browser as we flip through tabs, since
   // this tests is just intended to make sure everything's created and hooked
   // up properly Javascript side.
@@ -34,5 +34,5 @@ netInternalsTest.test('NetInternalsTourTabs', function() {
 
   netInternalsTest.checkTabHandleVisibility(tabVisibilityState, true);
 
-  netInternalsTest.testDone();
+  testDone();
 });
diff --git a/chrome/test/data/webui/net_internals/net_internals_test.js b/chrome/test/data/webui/net_internals/net_internals_test.js
index ff25da0..2aacd9a 100644
--- a/chrome/test/data/webui/net_internals/net_internals_test.js
+++ b/chrome/test/data/webui/net_internals/net_internals_test.js
@@ -10,12 +10,9 @@
  * All callbacks from the browser are wrapped in such a way that they can
  * also use the assert/expect functions.
  *
- * A test ends when an assert/expect test fails, an exception is thrown, or
- * |netInternalsTest.testDone| is called.  At that point, or soon afterwards,
- * the title is updated to 'Test Failed' if an assert/expect test fails, or
- * there was an exception.  Otherwise, it's set to 'Test Passed'.  The
- * behavior when an assert/expect test fails or an assertion is thrown only
- * after |netInternalsTest.testDone| is called is undefined.
+ * A test ends when testDone is called.  This can be done by the test itself,
+ * but will also be done by the test framework when an assert/expect test fails
+ * or an exception is thrown.
  */
 
 // Start of namespace.
@@ -51,45 +48,15 @@ var netInternalsTest = (function() {
   };
 
   /**
-   * Indicates if the test is complete.
-   * @type {boolean}
-   */
-  var done = false;
-
-  /**
-   * Updates the title of the page to report success or failure.  Must be
-   * called at most once for each test.
-   * @param {boolean} success Description of success param.
-   */
-  function updateTitle(success) {
-    if (success) {
-      document.title = 'Test Passed';
-    } else {
-      document.title = 'Test Failed';
-    }
-    done = true;
-  }
-
-  /**
-   * Called to indicate a test is complete.
-   */
-  function testDone() {
-    done = true;
-  }
-
-  /**
    * Creates a test function that can use the expect and assert functions
-   * in test_api.js.  On failure, will set title to 'Test Failed', and when
-   * a test is done and there was no failure, will set title to 'Test Passed'.
-   * Calling expect/assert functions after done has been called has undefined
-   * behavior.  Returned test functions can safely call each other directly.
+   * in test_api.js.  Will call testDone() in response to any failure.
    *
    * The resulting function has no return value.
    * @param {string} testName The name of the function, reported on error.
    * @param {Function} testFunction The function to run.
    * @return {function():void} Function that passes its parameters to
-   *     testFunction, and passes the test result, if any, to the browser
-   *     process by setting the window title.
+   *     testFunction, and passes any failures to the browser by calling
+   *     testDone() after they occur.
    */
   function createTestFunction(testName, testFunction) {
     return function() {
@@ -97,40 +64,22 @@ var netInternalsTest = (function() {
       // failure by runTestFunction.
       var testArguments = Array.prototype.slice.call(arguments, 0);
 
-      // If the test is already complete, do nothing.
-      if (done)
-        return;
-
       var result = runTestFunction(testName, testFunction, testArguments);
 
-      // If the first value is false, the test failed.
-      if (!result[0]) {
-        // Print any error messages.
-        console.log(result[1]);
-        // Update title to indicate failure.
-        updateTitle(false);
-      } else if (done)  {
-        // If the first result is true, and |done| is also true, the test
-        // passed.  Update title to indicate success.
-        updateTitle(true);
-      }
+      // If the first value is false, report the test failure.
+      if (!result[0])
+        testDone();
     };
   }
 
   /**
-   * Dictionary of tests.
-   * @type {Object.<string, Function>}
-   */
-  var tests = {};
-
-  /**
    * Used to declare a test function called by the NetInternals browser test.
-   * Takes in a name and a function, and adds it to the list of tests.
-   * @param {string} testName The of the test.
+   * Takes in a name and a function, and creates a global test function.
+   * @param {string} testName The name of the test.
    * @param {Function} testFunction The test function.
    */
   function test(testName, testFunction) {
-    tests[testName] = testFunction;
+    window[testName] = runTest.bind(null, testName, testFunction);
   }
 
   /**
@@ -138,13 +87,15 @@ var netInternalsTest = (function() {
    * received from the browser yet, waits until they have been.
    * Experimentally, this never seems to happen, but may theoretically be
    * possible.
-   * @param {string} testName The of the test to run.
-   * @param {Function} testArguments The test arguments.
+   * @param {string} testName The name of the test to run.
+   * @param {Function} testFunction The test function.
    */
-  function runTest(testName, testArguments) {
+  function runTest(testName, testFunction) {
+    var testArguments = Array.prototype.slice.call(arguments, 2);
+
     // If we've already received the constants, start the tests.
-    if (typeof(LogEventType) != 'undefined') {
-      startNetInternalsTest(testName, testArguments);
+    if (typeof LogEventType != 'undefined') {
+      startNetInternalsTest(testName, testFunction, testArguments);
       return;
     }
 
@@ -161,7 +112,7 @@ var netInternalsTest = (function() {
     ConstantsObserver.prototype.onConstantsReceived = function() {
       if (!this.testStarted_) {
         this.testStarted_ = true;
-        startNetInternalsTest(testFunction, testArguments);
+        startNetInternalsTest(testFunction, testFunction, testArguments);
       }
     };
 
@@ -176,7 +127,7 @@ var netInternalsTest = (function() {
    * @param {string} testName The of the test to run.
    * @param {Function} testArguments The test arguments.
    */
-  function startNetInternalsTest(testName, testArguments) {
+  function startNetInternalsTest(testName, testFunction, testArguments) {
     // Wrap g_browser.receive around a test function so that assert and expect
     // functions can be called from observers.
     g_browser.receive = createTestFunction('g_browser.receive', function() {
@@ -184,7 +135,7 @@ var netInternalsTest = (function() {
     });
 
     g_browser.setPollInterval(TESTING_POLL_INTERVAL_MS);
-    createTestFunction(testName, tests[testName]).apply(null, testArguments);
+    createTestFunction(testName, testFunction).apply(null, testArguments);
   }
 
   /**
@@ -317,26 +268,25 @@ var netInternalsTest = (function() {
   return {
     test: test,
     runTest: runTest,
-    testDone:testDone,
     checkStyledTableRows: checkStyledTableRows,
     switchToView: switchToView,
     checkTabHandleVisibility: checkTabHandleVisibility
   };
 })();
 
-netInternalsTest.test('NetInternalsDone', function() {
-  netInternalsTest.testDone();
+netInternalsTest.test('netInternalsDone', function() {
+  testDone();
 });
 
-netInternalsTest.test('NetInternalsExpectFail', function() {
+netInternalsTest.test('netInternalsExpectFail', function() {
   expectNotReached();
 });
 
-netInternalsTest.test('NetInternalsAssertFail', function() {
+netInternalsTest.test('netInternalsAssertFail', function() {
   assertNotReached();
 });
 
-netInternalsTest.test('NetInternalsObserverDone', function() {
+netInternalsTest.test('netInternalsObserverDone', function() {
   /**
    * A HostResolverInfo observer that calls testDone() in response to the
    * first seen event.
@@ -345,7 +295,7 @@ netInternalsTest.test('NetInternalsObserverDone', function() {
   }
 
   HostResolverInfoObserver.prototype.onHostResolverInfoChanged = function() {
-    netInternalsTest.testDone();
+    testDone();
   };
 
   // Create the observer and add it to |g_browser|.
@@ -355,7 +305,7 @@ netInternalsTest.test('NetInternalsObserverDone', function() {
   netInternalsTest.switchToView('dns');
 });
 
-netInternalsTest.test('NetInternalsObserverExpectFail', function() {
+netInternalsTest.test('netInternalsObserverExpectFail', function() {
   /**
    * A HostResolverInfo observer that triggers an exception in response to the
    * first seen event.
@@ -365,7 +315,6 @@ netInternalsTest.test('NetInternalsObserverExpectFail', function() {
 
   HostResolverInfoObserver.prototype.onHostResolverInfoChanged = function() {
     expectNotReached();
-    netInternalsTest.testDone();
   };
 
   // Create the observer and add it to |g_browser|.
@@ -375,7 +324,7 @@ netInternalsTest.test('NetInternalsObserverExpectFail', function() {
   netInternalsTest.switchToView('dns');
 });
 
-netInternalsTest.test('NetInternalsObserverAssertFail', function() {
+netInternalsTest.test('netInternalsObserverAssertFail', function() {
   /**
    * A HostResolverInfo observer that triggers an assertion in response to the
    * first seen event.
diff --git a/chrome/test/data/webui/net_internals/prerender_view.js b/chrome/test/data/webui/net_internals/prerender_view.js
index 8934663..5e6ad60 100644
--- a/chrome/test/data/webui/net_internals/prerender_view.js
+++ b/chrome/test/data/webui/net_internals/prerender_view.js
@@ -15,7 +15,7 @@
  * |finalStatus| is the expected status value when the page reaches the
  * history.
  */
-netInternalsTest.test('NetInternalsPrerenderView',
+netInternalsTest.test('netInternalsPrerenderView',
                       function (url, shouldSucceed, finalStatus) {
   // IDs for special HTML elements in prerender_view.html
   var HISTORY_DIV_ID = 'prerender-view-history-div';
@@ -142,7 +142,7 @@ netInternalsTest.test('NetInternalsPrerenderView',
       expectEquals(this.url_, prerenderInfo.history[0].url);
       expectEquals(this.finalStatus_, prerenderInfo.history[0].final_status);
 
-      netInternalsTest.testDone();
+      testDone();
     }
   };
 
diff --git a/chrome/test/data/webui/net_internals/test_view.js b/chrome/test/data/webui/net_internals/test_view.js
index 4c917eb..7823a3d 100644
--- a/chrome/test/data/webui/net_internals/test_view.js
+++ b/chrome/test/data/webui/net_internals/test_view.js
@@ -7,7 +7,7 @@
  * |url|, and expects to see |expectedResult| from each iteration.  Checks the
  * order and several fields of the events received.
  */
-netInternalsTest.test('NetInternalsTestView',
+netInternalsTest.test('netInternalsTestView',
                       function(url, expectedResult, totalIterations) {
   // IDs for special HTML elements in test_view.html
   var URL_INPUT_ID = 'test-view-url-input';
@@ -112,7 +112,7 @@ netInternalsTest.test('NetInternalsTestView',
       if (this.completedIterations_ < this.totalIterations_) {
         this.startTestSuite();
       } else {
-        netInternalsTest.testDone();
+        testDone();
       }
     }
   };