Setting TestRunner's main window from BlinkTestRunner.

components/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 "components/test_runner/test_runner.h"
 
 #include <stddef.h>
 #include <limits>
 #include <utility>
 
@@ skipping 1541 matching lines @@
 void TestRunner::WorkQueue::AddWork(WorkItem* work) {
   if (frozen_) {
     delete work;
     return;
   }
   queue_.push_back(work);
 }
 
 void TestRunner::WorkQueue::ProcessWork() {
   // Quit doing work once a load is in progress.
-  while (!queue_.empty()) {
-    bool startedLoad = queue_.front()->Run(controller_->delegate_,
-                                           controller_->web_view_);
-    delete queue_.front();
-    queue_.pop_front();
-    if (startedLoad)
-      return;
+  if (controller_->main_view_) {
+    while (!queue_.empty()) {
+      bool startedLoad =
+          queue_.front()->Run(controller_->delegate_, controller_->main_view_);
+      delete queue_.front();
+      queue_.pop_front();
+      if (startedLoad)
+        return;
+    }
   }
 
   if (!controller_->layout_test_runtime_flags_.wait_until_done() &&
       !controller_->topLoadingFrame())
     controller_->delegate_->TestFinished();
 }
 
 TestRunner::TestRunner(TestInterfaces* interfaces)
     : test_is_running_(false),
       close_remaining_windows_(false),
       work_queue_(this),
       web_history_item_count_(0),
       test_interfaces_(interfaces),
       delegate_(nullptr),
-      web_view_(nullptr),
+      main_view_(nullptr),
       mock_content_settings_client_(
           new MockContentSettingsClient(&layout_test_runtime_flags_)),
       credential_manager_client_(new MockCredentialManagerClient),
       mock_screen_orientation_client_(new MockScreenOrientationClient),
       spellcheck_(new SpellCheckClient(this)),
       chooser_count_(0),
       previously_focused_view_(nullptr),
       weak_factory_(this) {}
 
 TestRunner::~TestRunner() {}
 
 void TestRunner::Install(
     WebLocalFrame* frame,
     base::WeakPtr<TestRunnerForSpecificView> view_test_runner) {
   TestRunnerBindings::Install(weak_factory_.GetWeakPtr(), view_test_runner,
                               frame);
 }
 
 void TestRunner::SetDelegate(WebTestDelegate* delegate) {
   delegate_ = delegate;
   mock_content_settings_client_->SetDelegate(delegate);
   spellcheck_->SetDelegate(delegate);
   if (speech_recognizer_)
     speech_recognizer_->SetDelegate(delegate);
 }
 
-void TestRunner::SetWebView(WebView* webView) {
-  web_view_ = webView;
+void TestRunner::SetMainView(WebView* web_view) {
+  main_view_ = web_view;
 }
 
 void TestRunner::Reset() {
   top_loading_frame_ = nullptr;
   layout_test_runtime_flags_.Reset();
   mock_screen_orientation_client_->ResetData();
   drag_image_.reset();
   views_with_scheduled_animations_.clear();
 
   WebSecurityPolicy::resetOriginAccessWhitelists();
@@ skipping 233 matching lines @@
 }
 
 bool TestRunner::shouldDumpPingLoaderCallbacks() const {
   return test_is_running_ &&
          layout_test_runtime_flags_.dump_ping_loader_callbacks();
 }
 
 void TestRunner::setShouldEnableViewSource(bool value) {
   // TODO(lukasza): This flag should be 1) replicated across OOPIFs and
   // 2) applied to all views, not just the main window view.
-  web_view_->mainFrame()->enableViewSourceMode(value);
+
+  // Path-based test config is trigerred by BlinkTestRunner, when |main_view_|
+  // is guaranteed to exist at this point.
+  DCHECK(main_view_);
+
+  main_view_->mainFrame()->enableViewSourceMode(value);
 }
 
 bool TestRunner::shouldDumpUserGestureInFrameLoadCallbacks() const {
   return test_is_running_ &&
          layout_test_runtime_flags_.dump_user_gesture_in_frame_load_callbacks();
 }
 
 bool TestRunner::shouldDumpTitleChanges() const {
   return layout_test_runtime_flags_.dump_title_changes();
 }
@@ skipping 47 matching lines @@
 
 bool TestRunner::shouldWaitUntilExternalURLLoad() const {
   return layout_test_runtime_flags_.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_)
+  if (frame->top()->view() != main_view_)
     return;
   if (!test_is_running_)
     return;
   if (clear) {
     top_loading_frame_ = nullptr;
     LocationChangeDone();
   } else if (!top_loading_frame_) {
     top_loading_frame_ = frame;
   }
 }
@@ skipping 180 matching lines @@
     delegate->LoadURLForFrame(url_, target_);
     return true; // FIXME: Did it really start a navigation?
   }
 
  private:
   WebURL url_;
   std::string target_;
 };
 
 void TestRunner::QueueLoad(const std::string& url, const std::string& target) {
+  if (!main_view_)
+    return;
+
   // FIXME: Implement WebURL::resolve() and avoid GURL.
-  GURL current_url = web_view_->mainFrame()->document().url();
+  GURL current_url = main_view_->mainFrame()->document().url();
   GURL full_url = current_url.Resolve(url);
   work_queue_.AddWork(new WorkItemLoad(full_url, target));
 }
 
 void TestRunner::SetCustomPolicyDelegate(gin::Arguments* args) {
   bool value;
   args->GetNext(&value);
   layout_test_runtime_flags_.set_policy_delegate_enabled(value);
 
   if (!args->PeekNext().IsEmpty() && args->PeekNext()->IsBoolean()) {
@@ skipping 1085 matching lines @@
     work_queue_.ProcessWorkSoon();
 }
 
 void TestRunner::CheckResponseMimeType() {
   // Text output: the test page can request different types of output which we
   // handle here.
 
   if (layout_test_runtime_flags_.dump_as_text())
     return;
 
-  WebDataSource* data_source = web_view_->mainFrame()->dataSource();
+  if (!main_view_)
+    return;
+
+  WebDataSource* data_source = main_view_->mainFrame()->dataSource();
   if (!data_source)
     return;
 
   std::string mimeType = data_source->response().mimeType().utf8();
   if (mimeType != "text/plain")
     return;
 
   layout_test_runtime_flags_.set_dump_as_text(true);
   layout_test_runtime_flags_.set_generate_pixel_results(false);
   OnLayoutTestRuntimeFlagsChanged();
@@ skipping 77 matching lines @@
 
 blink::WebView* TestRunnerForSpecificView::web_view() {
   return web_test_proxy_base_->web_view();
 }
 
 WebTestDelegate* TestRunnerForSpecificView::delegate() {
   return web_test_proxy_base_->delegate();
 }
 
 }  // namespace test_runner