Provide ability for WebUIBrowserTests to run asynchronous tests.

chrome/browser/ui/webui/web_ui_test_handler.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_test_handler.h"
 
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_registrar.h"
 
+WebUITestHandler::WebUITestHandler()
+    : test_succeeded_(false),
+      test_succeeded_async_(false),
+      is_waiting_(false),
+      test_done_(false),
+      test_done_async_(false) {
+}
+
 void WebUITestHandler::PreloadJavaScript(const string16& js_text,
                                          RenderViewHost* preload_host) {
   DCHECK(preload_host);
   preload_host->Send(new ViewMsg_WebUIJavaScript(
       preload_host->routing_id(), string16(), js_text, 0,
       false));
 }
 
 void WebUITestHandler::RunJavaScript(const string16& js_text) {
   web_ui_->GetRenderViewHost()->ExecuteJavascriptInWebFrame(
       string16(), js_text);
 }
 
-bool WebUITestHandler::RunJavaScriptTestWithResult(const string16& js_text) {
+bool WebUITestHandler::RunJavaScriptTestWithResult(const string16& js_text,
+                                                   bool is_async) {
+  test_succeeded_ = false;
+  test_succeeded_async_ = false;
   NotificationRegistrar notification_registrar;
   notification_registrar.Add(
       this, content::NOTIFICATION_EXECUTE_JAVASCRIPT_RESULT,
       Source<RenderViewHost>(web_ui_->GetRenderViewHost()));
   web_ui_->GetRenderViewHost()->ExecuteJavascriptInWebFrameNotifyResult(
       string16(), js_text);
-  return WaitForResult();
+  return WaitForResult(is_async);
+}
+
+void WebUITestHandler::RegisterMessages() {
+  web_ui_->RegisterMessageCallback("asyncTestResult", NewCallback(
+      this, &WebUITestHandler::HandleAsyncTestResult));
+}
+
+void WebUITestHandler::HandleAsyncTestResult(const ListValue* test_result) {
+  // Quit the message loop if we were waiting so Waiting process can get result
+  // or error. To ensure this gets done, do this before ASSERT* calls.
+  if (is_waiting_)
+    MessageLoopForUI::current()->Quit();

[mmenke, 2011/08/10 17:23:40]

You could move this into HandleTestResult, since you duplicate the code.  I'm
fine with it as it is, though, just a suggestion.

[Sheridan Rawlins, 2011/08/11 01:58:44]

There are ASSERT_* calls in Observe which occur before the call to
HandleTestResult and we must Quit the messageloop regardless of early
termination of result parsing code. I'm leaving this where it is, especially
since you're "fine with it as is".

On 2011/08/10 17:23:40, Matt Menke wrote:

[mmenke, 2011/08/11 15:16:16]

Err...  Good point.

On 2011/08/11 01:58:44, Sheridan Rawlins wrote:

+
+  EXPECT_FALSE(test_done_async_);
+  test_done_async_ = true;
+
+  SCOPED_TRACE("WebUITestHandler::HandleAsyncTestResult");
+  HandleTestResult(test_result, &test_succeeded_async_);
+}
+
+void WebUITestHandler::HandleTestResult(const ListValue* test_result,
+                                        bool* success) {
+  *success = false;
+  ASSERT_TRUE(test_result->GetBoolean(0, success));
+  if (!success) {
+    std::string message;
+    ASSERT_TRUE(test_result->GetString(1, &message));
+    LOG(ERROR) << message;
+  }
 }
 
 void WebUITestHandler::Observe(int type,
                                const NotificationSource& source,
                                const NotificationDetails& details) {
   // Quit the message loop if we were waiting so Waiting process can get result
   // or error. To ensure this gets done, do this before ASSERT* calls.
   if (is_waiting_)
     MessageLoopForUI::current()->Quit();
 
+  EXPECT_FALSE(test_done_);
+  test_done_ = true;
+
   SCOPED_TRACE("WebUITestHandler::Observe");
   Value* value = Details<std::pair<int, Value*> >(details)->second;
-  ListValue* list_value;
-  ASSERT_TRUE(value->GetAsList(&list_value));
-  ASSERT_TRUE(list_value->GetBoolean(0, &test_succeeded_));
-  if (!test_succeeded_) {
-    std::string message;
-    ASSERT_TRUE(list_value->GetString(1, &message));
-    LOG(ERROR) << message;
-  }
+  ListValue* test_result;
+  ASSERT_TRUE(value->GetAsList(&test_result));
+  HandleTestResult(test_result, &test_succeeded_);
 }
 
-bool WebUITestHandler::WaitForResult() {
+bool WebUITestHandler::WaitForResult(bool is_async) {
+  SCOPED_TRACE("WebUITestHandler::WaitForResult");
+  test_done_ = false;
+  test_done_async_ = false;
   is_waiting_ = true;
+
+  // Either sync test completion or the asyncTestDone() will cause message loop
+  // to quit.
   ui_test_utils::RunMessageLoop();
+
+  // When the test |is_async|, run a second message loop when |test_done_async_|
+  // so that the sync test completes, or |test_succeeded_| so the async test
+  // completes.

[mmenke, 2011/08/10 17:23:40]

This sentence isn't quite right.  Maybe:

When the test |is_async|, run a second message loop when not |test_done_| so
that the sync test completes, or |test_succeeded_| but not |test_done_async_| so
the async test completes.

[Sheridan Rawlins, 2011/08/11 01:58:44]

Done.

+  if (is_async && (!test_done_ || (test_succeeded_ && !test_done_async_))) {
+    ui_test_utils::RunMessageLoop();
+  }
+
+  // Verify that |test_done_async_| isn't set when !|is_async|. When |is_async|
+  // is true, |test_done_async_| may be false if the sync test failed first.
+  if (!is_async)
+    EXPECT_FALSE(test_done_async_);
+
   is_waiting_ = false;
-  return test_succeeded_;
+
+  // Both loops must succeed to pass.

[mmenke, 2011/08/10 17:23:40]

nit:  If !is_async, that's not quite true.

[Sheridan Rawlins, 2011/08/11 01:58:44]

Done.

+  return test_succeeded_ && (!is_async || test_succeeded_async_);
 }