Add 'waitUntilExternalURLLoad' method to TestRunner.

content/shell/renderer/test_runner/test_runner.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 "content/shell/renderer/test_runner/test_runner.h"
 
 #include <limits>
 
 #include "base/logging.h"
 #include "content/shell/common/test_runner/test_preferences.h"
@@ skipping 205 matching lines @@
   void DumpSpellCheckCallbacks();
   void DumpBackForwardList();
   void DumpSelectionRect();
   void TestRepaint();
   void RepaintSweepHorizontally();
   void SetPrinting();
   void SetShouldStayOnPageAfterHandlingBeforeUnload(bool value);
   void SetWillSendRequestClearHeader(const std::string& header);
   void DumpResourceRequestPriorities();
   void SetUseMockTheme(bool use);
+  void WaitUntilExternalURLLoad();
   void ShowWebInspector(gin::Arguments* args);
   void CloseWebInspector();
   bool IsChooserShown();
   void EvaluateInWebInspector(int call_id, const std::string& script);
   void ClearAllDatabases();
   void SetDatabaseQuota(int quota);
   void SetAlwaysAcceptCookies(bool accept);
   void SetWindowIsKey(bool value);
   std::string PathToLocalResource(const std::string& path);
   void SetBackingScaleFactor(double value, v8::Handle<v8::Function> callback);
@@ skipping 201 matching lines @@
                  &TestRunnerBindings::RepaintSweepHorizontally)
       .SetMethod("setPrinting", &TestRunnerBindings::SetPrinting)
       .SetMethod("setShouldStayOnPageAfterHandlingBeforeUnload",
                  &TestRunnerBindings::
                      SetShouldStayOnPageAfterHandlingBeforeUnload)
       .SetMethod("setWillSendRequestClearHeader",
                  &TestRunnerBindings::SetWillSendRequestClearHeader)
       .SetMethod("dumpResourceRequestPriorities",
                  &TestRunnerBindings::DumpResourceRequestPriorities)
       .SetMethod("setUseMockTheme", &TestRunnerBindings::SetUseMockTheme)
+      .SetMethod("waitUntilExternalURLLoad",
+                 &TestRunnerBindings::WaitUntilExternalURLLoad)
       .SetMethod("showWebInspector", &TestRunnerBindings::ShowWebInspector)
       .SetMethod("closeWebInspector", &TestRunnerBindings::CloseWebInspector)
       .SetMethod("isChooserShown", &TestRunnerBindings::IsChooserShown)
       .SetMethod("evaluateInWebInspector",
                  &TestRunnerBindings::EvaluateInWebInspector)
       .SetMethod("clearAllDatabases", &TestRunnerBindings::ClearAllDatabases)
       .SetMethod("setDatabaseQuota", &TestRunnerBindings::SetDatabaseQuota)
       .SetMethod("setAlwaysAcceptCookies",
                  &TestRunnerBindings::SetAlwaysAcceptCookies)
       .SetMethod("setWindowIsKey", &TestRunnerBindings::SetWindowIsKey)
@@ skipping 638 matching lines @@
 void TestRunnerBindings::DumpResourceRequestPriorities() {
   if (runner_)
     runner_->DumpResourceRequestPriorities();
 }
 
 void TestRunnerBindings::SetUseMockTheme(bool use) {
   if (runner_)
     runner_->SetUseMockTheme(use);
 }
 
+void TestRunnerBindings::WaitUntilExternalURLLoad() {
+  if (runner_)
+    runner_->WaitUntilExternalURLLoad();
+}
+
 void TestRunnerBindings::ShowWebInspector(gin::Arguments* args) {
   if (runner_) {
     std::string settings;
     args->GetNext(&settings);
     std::string frontend_url;
     args->GetNext(&frontend_url);
     runner_->ShowWebInspector(settings, frontend_url);
   }
 }
 
@@ skipping 301 matching lines @@
 
     if (page_overlay_) {
       web_view_->removePageOverlay(page_overlay_);
       delete page_overlay_;
       page_overlay_ = NULL;
     }
   }
 
   top_loading_frame_ = NULL;
   wait_until_done_ = false;
+  wait_until_external_url_load_ = false;
   policy_delegate_enabled_ = false;
   policy_delegate_is_permissive_ = false;
   policy_delegate_should_notify_done_ = false;
 
   WebSecurityPolicy::resetOriginAccessWhitelists();
 #if defined(__linux__) || defined(ANDROID)
   WebFontRendering::setSubpixelPositioning(false);
 #endif
 
   if (delegate_) {
@@ skipping 200 matching lines @@
 }
 
 bool TestRunner::isPrinting() const {
   return is_printing_;
 }
 
 bool TestRunner::shouldStayOnPageAfterHandlingBeforeUnload() const {
   return should_stay_on_page_after_handling_before_unload_;
 }
 
+bool TestRunner::shouldWaitUntilExternalURLLoad() const {
+  return wait_until_external_url_load_;
+}
+
 const std::set<std::string>* TestRunner::httpHeadersToClear() const {
   return &http_headers_to_clear_;
 }
 
 void TestRunner::setTopLoadingFrame(WebFrame* frame, bool clear) {
   if (frame->top()->view() != web_view_)
     return;
   if (!test_is_running_)
     return;
   if (clear) {
@@ skipping 808 matching lines @@
 
 void TestRunner::SetUseMockTheme(bool use) {
   use_mock_theme_ = use;
 }
 
 void TestRunner::ShowWebInspector(const std::string& str,
                                   const std::string& frontend_url) {
   showDevTools(str, frontend_url);
 }
 
+void TestRunner::WaitUntilExternalURLLoad() {
+  wait_until_external_url_load_ = true;
+}
+
 void TestRunner::CloseWebInspector() {
   delegate_->closeDevTools();
 }
 
 bool TestRunner::IsChooserShown() {
   return proxy_->isChooserShown();
 }
 
 void TestRunner::EvaluateInWebInspector(int call_id,
                                         const std::string& script) {
@@ skipping 156 matching lines @@
 }
 
 void TestRunner::DidLosePointerLockInternal() {
   bool was_locked = pointer_locked_;
   pointer_locked_ = false;
   if (was_locked)
     web_view_->didLosePointerLock();
 }
 
 }  // namespace content