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),
+      is_waiting_(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;
   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();
+
+  EXPECT_FALSE(test_done_async_);
+  test_done_async_ = true;
+
+  SCOPED_TRACE("WebUITestHandler::HandleAsyncTestResult");
+  HandleTestResult(test_result, &test_succeeded_);

[mmenke, 2011/08/08 16:38:25]

What if an async failure is sent before a successful sync result?  I suspect
that won't be a common case, but you should either explicitly return an error
when that happens, or set |test_succeeded_| correctly when that happens.

Your code also doesn't seem to handle a sync failure and then async result, when
both are received before you exit the message loop.

[Sheridan Rawlins, 2011/08/10 01:58:53]

Both quit the loop, so both cannot be received. If a sync failure is received,
then is_waiting is set to false, and any subsequent messages don't cause the
message loop to be quit.  I added more comments below so the logic is explained.

[mmenke, 2011/08/10 04:17:53]

The loop does not quit instantly.  It may handle currently pending tasks before
it actually exits.

[Sheridan Rawlins, 2011/08/10 05:41:06]

Yup.  Had to add another boolean back in...  Take a look now.

+}
+
+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();
 
   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_async_ = false;
   is_waiting_ = true;
   ui_test_utils::RunMessageLoop();
+  if (test_succeeded_ && is_async && !test_done_async_) {

[Sheridan Rawlins, 2011/08/10 01:58:53]

I think this should be 

   (is_async && (test_done_async_ || test_succeeded_))

So that it runs again if the test succeded (to wait for async case) or if the
asyncTestDone() was called early (to wait for the sync-return.

Also need to keep the previous test_succeeded to return with the correct value -
if any fails then return fail.

+    test_succeeded_ = false;
+    ui_test_utils::RunMessageLoop();
+  }
+  EXPECT_EQ(is_async, test_done_async_);
   is_waiting_ = false;
   return test_succeeded_;
 }