Adds testing infrastructure to web_ui_browsertest to support testing HtmlDialogs.

chrome/browser/ui/webui/web_ui_browsertest.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_browsertest.h"
 
 #include <string>
 #include <vector>
 
 #include "base/lazy_instance.h"
 #include "base/path_service.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/webui/chrome_web_ui.h"
 #include "chrome/browser/ui/webui/test_chrome_web_ui_factory.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/test_tab_strip_model_observer.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/browser/tab_contents/tab_contents.h"
+#include "content/common/content_notification_types.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest-spi.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace {
 
 const FilePath::CharType kMockJS[] = FILE_PATH_LITERAL("mock4js.js");
 const FilePath::CharType kWebUILibraryJS[] = FILE_PATH_LITERAL("test_api.js");
 const FilePath::CharType kWebUITestFolder[] = FILE_PATH_LITERAL("webui");
 base::LazyInstance<std::vector<std::string> > error_messages_(
@@ skipping 167 matching lines @@
   TestTabStripModelObserver tabstrip_observer(
       browser()->tabstrip_model(), this);
   browser()->Print();
   tabstrip_observer.WaitForObservation();
 }
 
 const char WebUIBrowserTest::kDummyURL[] = "chrome://DummyURL";
 
 WebUIBrowserTest::WebUIBrowserTest()
     : test_handler_(new WebUITestHandler()),
-      libraries_preloaded_(false) {}
+      libraries_preloaded_(false),
+      web_ui_instance_(NULL),
+      web_ui_instance_ready_(false),
+      message_loop_running_(false) {}
 
 namespace {
 
 class MockWebUIProvider : public TestChromeWebUIFactory::WebUIProvider {
  public:
   MockWebUIProvider() {}
 
   // Returns a new ChromeWebUI
   WebUI* NewWebUI(TabContents* tab_contents, const GURL& url) OVERRIDE {
     return new ChromeWebUI(tab_contents);
@@ skipping 21 matching lines @@
   FilePath mockPath;
   ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &mockPath));
   mockPath = mockPath.AppendASCII("chrome");
   mockPath = mockPath.AppendASCII("third_party");
   mockPath = mockPath.AppendASCII("mock4js");
   mockPath = mockPath.Append(kMockJS);
   AddLibrary(mockPath);
   AddLibrary(FilePath(kWebUILibraryJS));
 }
 
+void WebUIBrowserTest::ObserveNextHtmlDialog() {
+  registrar_.Add(this, chrome::NOTIFICATION_HTML_DIALOG_SHOWN,
+                 NotificationService::AllSources());
+}
+
 void WebUIBrowserTest::TearDownInProcessBrowserTestFixture() {
   InProcessBrowserTest::TearDownInProcessBrowserTestFixture();
   TestChromeWebUIFactory::RemoveFactoryOverride(GURL(kDummyURL).host());
 }
 
 WebUIMessageHandler* WebUIBrowserTest::GetMockMessageHandler() {
   return NULL;
 }
 
 GURL WebUIBrowserTest::WebUITestDataPathToURL(
     const FilePath::StringType& path) {
   FilePath dir_test_data;
   EXPECT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &dir_test_data));
   FilePath test_path(dir_test_data.AppendASCII("webui"));
   test_path = test_path.Append(path);
   EXPECT_TRUE(file_util::PathExists(test_path));
   return net::FilePathToFileURL(test_path);
 }
 
 void WebUIBrowserTest::OnJsInjectionReady(RenderViewHost* render_view_host) {
   PreLoadJavascriptLibraries(preload_test_fixture_, preload_test_name_,
                              render_view_host);
 }
 
+void WebUIBrowserTest::Observe(int type,

[Sheridan Rawlins, 2011/09/09 15:47:50]

I would prefer to see this and other logic broken out to its own class like
TestNavigationObserver was.

[flackr, 2011/09/15 18:41:52]

Done.

+                               const NotificationSource& source,
+                               const NotificationDetails& details) {
+  if (type == chrome::NOTIFICATION_HTML_DIALOG_SHOWN) {

[Sheridan Rawlins, 2011/09/09 15:47:50]

Even though only 2 cases, this looks like a switch.  Default can have
NOTREACHED().

[flackr, 2011/09/15 18:41:52]

Done.

+    web_ui_instance_ = Source<WebUI>(source).ptr();
+    registrar_.Remove(this, chrome::NOTIFICATION_HTML_DIALOG_SHOWN,
+                      NotificationService::AllSources());
+    // Wait for navigation to complete.
+    web_ui_instance_ready_ = false;
+    registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,

[Paweł Hajdan Jr., 2011/09/09 22:13:55]

Is this possibly racy?

[flackr, 2011/09/15 18:41:52]

I don't so, but I'm not certain. The first notification,
NOTIFICATION_HTML_DIALOG_SHOWN is delivered as soon as the render view is
created. I will try to check if navigation is blocked on the render view
creation. I could listen to both events on construction but then I have to track
which NavigationControllers have completed loading until I know which one
belongs to the new WebUI instance. Do you think it would work to assume that the
next navigation during a dialog creation will be for the dialog and have a
DCHECK to fail if that's not the case? Alternately I could check for a dialog
WebUI instance (dynamic_cast?) on all completed navigations.

Btw, the code for this has been moved to test_html_dialog_observer.cc.

+                   Source<NavigationController>(
+                       &web_ui_instance_->tab_contents()->controller()));
+  } else if (type == content::NOTIFICATION_LOAD_STOP) {
+    registrar_.Remove(this, content::NOTIFICATION_LOAD_STOP,
+                      Source<NavigationController>(
+                          &web_ui_instance_->tab_contents()->controller()));
+    web_ui_instance_ready_ = true;
+    if (message_loop_running_) {
+      message_loop_running_ = false;
+      MessageLoopForUI::current()->Quit();
+    }
+  } else {
+    NOTREACHED() << "Unhandled notification type";

[Sheridan Rawlins, 2011/09/09 15:47:50]

Don't bloat with message that doesn't add info (you can tell why from the
line-no).

[flackr, 2011/09/15 18:41:52]

Done.

+  }
+}
+
+void WebUIBrowserTest::WaitForHtmlDialogLoad() {
+  if (!web_ui_instance_ready_) {
+    message_loop_running_ = true;
+    ui_test_utils::RunMessageLoop();
+  }
+}
+
 void WebUIBrowserTest::BuildJavascriptLibraries(string16* content) {
   ASSERT_TRUE(content != NULL);
   std::string utf8_content;
   std::vector<FilePath>::iterator user_libraries_iterator;
   for (user_libraries_iterator = user_libraries_.begin();
        user_libraries_iterator != user_libraries_.end();
        ++user_libraries_iterator) {
     std::string library_content;
     if (user_libraries_iterator->IsAbsolute()) {
       ASSERT_TRUE(file_util::ReadFileToString(*user_libraries_iterator,
@@ skipping 70 matching lines @@
 
   if (error_messages_.Get().size() > 0) {
     LOG(ERROR) << "Encountered javascript console error(s)";
     result = false;
     error_messages_.Get().clear();
   }
   return result;
 }
 
 void WebUIBrowserTest::SetupHandlers() {
-  WebUI* web_ui_instance =
+  WebUI* web_ui_instance = web_ui_instance_ ? web_ui_instance_ :
       browser()->GetSelectedTabContents()->web_ui();
   ASSERT_TRUE(web_ui_instance != NULL);
   web_ui_instance->register_callback_overwrites(true);
   test_handler_->Attach(web_ui_instance);
 
   if (GetMockMessageHandler())
     GetMockMessageHandler()->Attach(web_ui_instance);
 }
 
 // According to the interface for EXPECT_FATAL_FAILURE
@@ skipping 204 matching lines @@
 // 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"));
 }