Do not store TestRunner in WebFrameTestClient.

components/test_runner/web_frame_test_client.cc

 // Copyright 2016 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/web_frame_test_client.h"
 
 #include <memory>
 
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
@@ skipping 147 matching lines @@
       return kFormResubmittedString;
     case blink::WebNavigationTypeOther:
       return kOtherString;
   }
   return kIllegalString;
 }
 
 }  // namespace
 
 WebFrameTestClient::WebFrameTestClient(
-    TestRunner* test_runner,
     WebTestDelegate* delegate,
     WebViewTestProxyBase* web_view_test_proxy_base,
     WebFrameTestProxyBase* web_frame_test_proxy_base)
-    : test_runner_(test_runner),
-      delegate_(delegate),
+    : delegate_(delegate),
       web_view_test_proxy_base_(web_view_test_proxy_base),
       web_frame_test_proxy_base_(web_frame_test_proxy_base) {
-  DCHECK(test_runner);
   DCHECK(delegate_);
+  DCHECK(web_frame_test_proxy_base_);
   DCHECK(web_view_test_proxy_base_);
 }
 
 WebFrameTestClient::~WebFrameTestClient() {}
 
 blink::WebColorChooser* WebFrameTestClient::createColorChooser(
     blink::WebColorChooserClient* client,
     const blink::WebColor& color,
     const blink::WebVector<blink::WebColorSuggestion>& suggestions) {
   // This instance is deleted by WebCore::ColorInputType
-  return new MockColorChooser(client, delegate_, test_runner_);
+  return new MockColorChooser(client, delegate_, test_runner());
 }
 
 void WebFrameTestClient::runModalAlertDialog(const blink::WebString& message) {
   delegate_->PrintMessage(std::string("ALERT: ") + message.utf8().data() +
                           "\n");
 }
 
 bool WebFrameTestClient::runModalConfirmDialog(
     const blink::WebString& message) {
   delegate_->PrintMessage(std::string("CONFIRM: ") + message.utf8().data() +
                           "\n");
   return true;
 }
 
 bool WebFrameTestClient::runModalPromptDialog(
     const blink::WebString& message,
     const blink::WebString& default_value,
     blink::WebString* actual_value) {
   delegate_->PrintMessage(std::string("PROMPT: ") + message.utf8().data() +
                           ", default text: " + default_value.utf8().data() +
                           "\n");
   return true;
 }
 
 bool WebFrameTestClient::runModalBeforeUnloadDialog(bool is_reload) {
   delegate_->PrintMessage(std::string("CONFIRM NAVIGATION\n"));
-  return !test_runner_->shouldStayOnPageAfterHandlingBeforeUnload();
+  return !test_runner()->shouldStayOnPageAfterHandlingBeforeUnload();
 }
 
 blink::WebScreenOrientationClient*
 WebFrameTestClient::webScreenOrientationClient() {
-  return test_runner_->getMockScreenOrientationClient();
+  return test_runner()->getMockScreenOrientationClient();
 }
 
 void WebFrameTestClient::postAccessibilityEvent(const blink::WebAXObject& obj,
                                                 blink::WebAXEvent event) {
   // Only hook the accessibility events occured during the test run.
   // This check prevents false positives in WebLeakDetector.
   // The pending tasks in browser/renderer message queue may trigger
   // accessibility events,
   // and AccessibilityController will hold on to their target nodes if we don't
   // ignore them here.
-  if (!test_runner_->TestIsRunning())
+  if (!test_runner()->TestIsRunning())
     return;
 
   const char* event_name = NULL;
   switch (event) {
     case blink::WebAXEventActiveDescendantChanged:
       event_name = "ActiveDescendantChanged";
       break;
     case blink::WebAXEventAlert:
       event_name = "Alert";
       break;
@@ skipping 106 matching lines @@
         message += " - id:";
         message += element.getAttribute("id").utf8().data();
       }
     }
 
     delegate_->PrintMessage(message + "\n");
   }
 }
 
 void WebFrameTestClient::didChangeSelection(bool is_empty_callback) {
-  if (test_runner_->shouldDumpEditingCallbacks())
+  if (test_runner()->shouldDumpEditingCallbacks())
     delegate_->PrintMessage(
         "EDITING DELEGATE: "
         "webViewDidChangeSelection:WebViewDidChangeSelectionNotification\n");
 }
 
 blink::WebPlugin* WebFrameTestClient::createPlugin(
     blink::WebLocalFrame* frame,
     const blink::WebPluginParams& params) {
   if (TestPlugin::IsSupportedMimeType(params.mimeType))
     return TestPlugin::create(frame, params, delegate_);
   return delegate_->CreatePluginPlaceholder(frame, params);
 }
 
 void WebFrameTestClient::showContextMenu(
     const blink::WebContextMenuData& context_menu_data) {
   web_view_test_proxy_base_->event_sender()->SetContextMenuData(
       context_menu_data);
 }
 
 blink::WebUserMediaClient* WebFrameTestClient::userMediaClient() {
-  return test_runner_->getMockWebUserMediaClient();
+  return test_runner()->getMockWebUserMediaClient();
 }
 
 void WebFrameTestClient::loadURLExternally(
     const blink::WebURLRequest& request,
     blink::WebNavigationPolicy policy,
     const blink::WebString& suggested_name,
     bool replaces_current_history_item) {
-  if (test_runner_->shouldWaitUntilExternalURLLoad()) {
+  if (test_runner()->shouldWaitUntilExternalURLLoad()) {
     if (policy == blink::WebNavigationPolicyDownload) {
       delegate_->PrintMessage(
           std::string("Downloading URL with suggested filename \"") +
           suggested_name.utf8() + "\"\n");
     } else {
       delegate_->PrintMessage(std::string("Loading URL externally - \"") +
                               URLDescription(request.url()) + "\"\n");
     }
     delegate_->TestFinished();
   }
 }
 
 void WebFrameTestClient::didStartProvisionalLoad(blink::WebLocalFrame* frame,
                                                  double trigering_event_time) {
-  test_runner_->tryToSetTopLoadingFrame(frame);
+  test_runner()->tryToSetTopLoadingFrame(frame);
 
-  if (test_runner_->shouldDumpFrameLoadCallbacks()) {
+  if (test_runner()->shouldDumpFrameLoadCallbacks()) {
     PrintFrameDescription(delegate_, frame);
     delegate_->PrintMessage(" - didStartProvisionalLoadForFrame\n");
   }
 
-  if (test_runner_->shouldDumpUserGestureInFrameLoadCallbacks()) {
+  if (test_runner()->shouldDumpUserGestureInFrameLoadCallbacks()) {
     PrintFrameuserGestureStatus(delegate_, frame,
                                 " - in didStartProvisionalLoadForFrame\n");
   }
 }
 
 void WebFrameTestClient::didReceiveServerRedirectForProvisionalLoad(
     blink::WebLocalFrame* frame) {
-  if (test_runner_->shouldDumpFrameLoadCallbacks()) {
+  if (test_runner()->shouldDumpFrameLoadCallbacks()) {
     PrintFrameDescription(delegate_, frame);
     delegate_->PrintMessage(
         " - didReceiveServerRedirectForProvisionalLoadForFrame\n");
   }
 }
 
 void WebFrameTestClient::didFailProvisionalLoad(
     blink::WebLocalFrame* frame,
     const blink::WebURLError& error,
     blink::WebHistoryCommitType commit_type) {
-  if (test_runner_->shouldDumpFrameLoadCallbacks()) {
+  if (test_runner()->shouldDumpFrameLoadCallbacks()) {
     PrintFrameDescription(delegate_, frame);
     delegate_->PrintMessage(" - didFailProvisionalLoadWithError\n");
   }
 }
 
 void WebFrameTestClient::didCommitProvisionalLoad(
     blink::WebLocalFrame* frame,
     const blink::WebHistoryItem& history_item,
     blink::WebHistoryCommitType history_type) {
-  if (test_runner_->shouldDumpFrameLoadCallbacks()) {
+  if (test_runner()->shouldDumpFrameLoadCallbacks()) {
     PrintFrameDescription(delegate_, frame);
     delegate_->PrintMessage(" - didCommitLoadForFrame\n");
   }
 }
 
 void WebFrameTestClient::didReceiveTitle(blink::WebLocalFrame* frame,
                                          const blink::WebString& title,
                                          blink::WebTextDirection direction) {
-  if (test_runner_->shouldDumpFrameLoadCallbacks()) {
+  if (test_runner()->shouldDumpFrameLoadCallbacks()) {
     PrintFrameDescription(delegate_, frame);
     delegate_->PrintMessage(std::string(" - didReceiveTitle: ") + title.utf8() +
                             "\n");
   }
 
-  if (test_runner_->shouldDumpTitleChanges())
+  if (test_runner()->shouldDumpTitleChanges())
     delegate_->PrintMessage(std::string("TITLE CHANGED: '") + title.utf8() +
                             "'\n");
 }
 
 void WebFrameTestClient::didChangeIcon(blink::WebLocalFrame* frame,
                                        blink::WebIconURL::Type icon_type) {
-  if (test_runner_->shouldDumpIconChanges()) {
+  if (test_runner()->shouldDumpIconChanges()) {
     PrintFrameDescription(delegate_, frame);
     delegate_->PrintMessage(std::string(" - didChangeIcons\n"));
   }
 }
 
 void WebFrameTestClient::didFinishDocumentLoad(blink::WebLocalFrame* frame) {
-  if (test_runner_->shouldDumpFrameLoadCallbacks()) {
+  if (test_runner()->shouldDumpFrameLoadCallbacks()) {
     PrintFrameDescription(delegate_, frame);
     delegate_->PrintMessage(" - didFinishDocumentLoadForFrame\n");
   }
 }
 
 void WebFrameTestClient::didHandleOnloadEvents(blink::WebLocalFrame* frame) {
-  if (test_runner_->shouldDumpFrameLoadCallbacks()) {
+  if (test_runner()->shouldDumpFrameLoadCallbacks()) {
     PrintFrameDescription(delegate_, frame);
     delegate_->PrintMessage(" - didHandleOnloadEventsForFrame\n");
   }
 }
 
 void WebFrameTestClient::didFailLoad(blink::WebLocalFrame* frame,
                                      const blink::WebURLError& error,
                                      blink::WebHistoryCommitType commit_type) {
-  if (test_runner_->shouldDumpFrameLoadCallbacks()) {
+  if (test_runner()->shouldDumpFrameLoadCallbacks()) {
     PrintFrameDescription(delegate_, frame);
     delegate_->PrintMessage(" - didFailLoadWithError\n");
   }
 }
 
 void WebFrameTestClient::didFinishLoad(blink::WebLocalFrame* frame) {
-  if (test_runner_->shouldDumpFrameLoadCallbacks()) {
+  if (test_runner()->shouldDumpFrameLoadCallbacks()) {
     PrintFrameDescription(delegate_, frame);
     delegate_->PrintMessage(" - didFinishLoadForFrame\n");
   }
 }
 
 void WebFrameTestClient::didNavigateWithinPage(
     blink::WebLocalFrame* frame,
     const blink::WebHistoryItem& history_item,
     blink::WebHistoryCommitType commit_type,
     bool contentInitiated) {
-  test_runner_->OnNavigationEnd();
+  test_runner()->OnNavigationEnd();
 }
 
 void WebFrameTestClient::didStartLoading(bool to_different_document) {
-  test_runner_->OnNavigationBegin(web_frame_test_proxy_base_->web_frame());
+  test_runner()->OnNavigationBegin(web_frame_test_proxy_base_->web_frame());
 }
 
 void WebFrameTestClient::didStopLoading() {
-  test_runner_->tryToClearTopLoadingFrame(
+  test_runner()->tryToClearTopLoadingFrame(
       web_frame_test_proxy_base_->web_frame());
 }
 
 void WebFrameTestClient::didDetectXSS(const blink::WebURL& insecure_url,
                                       bool did_block_entire_page) {
-  if (test_runner_->shouldDumpFrameLoadCallbacks())
+  if (test_runner()->shouldDumpFrameLoadCallbacks())
     delegate_->PrintMessage("didDetectXSS\n");
 }
 
 void WebFrameTestClient::didDispatchPingLoader(const blink::WebURL& url) {
-  if (test_runner_->shouldDumpPingLoaderCallbacks())
+  if (test_runner()->shouldDumpPingLoaderCallbacks())
     delegate_->PrintMessage(std::string("PingLoader dispatched to '") +
                             URLDescription(url).c_str() + "'.\n");
 }
 
 void WebFrameTestClient::willSendRequest(blink::WebLocalFrame* frame,
                                          blink::WebURLRequest& request) {
   // Need to use GURL for host() and SchemeIs()
   GURL url = request.url();
   std::string request_url = url.possibly_invalid_spec();
 
   GURL main_document_url = request.firstPartyForCookies();
 
-  if (test_runner_->shouldDumpResourceLoadCallbacks()) {
+  if (test_runner()->shouldDumpResourceLoadCallbacks()) {
     delegate_->PrintMessage(DescriptionSuitableForTestResult(request_url));
     delegate_->PrintMessage(" - willSendRequest <NSURLRequest URL ");
     delegate_->PrintMessage(
         DescriptionSuitableForTestResult(request_url).c_str());
     delegate_->PrintMessage(", main document URL ");
     delegate_->PrintMessage(URLDescription(main_document_url).c_str());
     delegate_->PrintMessage(", http method ");
     delegate_->PrintMessage(request.httpMethod().utf8().data());
     delegate_->PrintMessage(">\n");
   }
 
-  if (test_runner_->httpHeadersToClear()) {
+  if (test_runner()->httpHeadersToClear()) {
     const std::set<std::string>* clearHeaders =
-        test_runner_->httpHeadersToClear();
+        test_runner()->httpHeadersToClear();
     for (std::set<std::string>::const_iterator header = clearHeaders->begin();
          header != clearHeaders->end(); ++header)
       request.clearHTTPHeaderField(blink::WebString::fromUTF8(*header));
   }
 
   std::string host = url.host();
   if (!host.empty() &&
       (url.SchemeIs(url::kHttpScheme) || url.SchemeIs(url::kHttpsScheme))) {
     if (!IsLocalHost(host) && !IsTestHost(host) &&
         !HostIsUsedBySomeTestsToGenerateError(host) &&
         ((!main_document_url.SchemeIs(url::kHttpScheme) &&
           !main_document_url.SchemeIs(url::kHttpsScheme)) ||
          IsLocalHost(main_document_url.host())) &&
         !delegate_->AllowExternalPages()) {
       delegate_->PrintMessage(std::string("Blocked access to external URL ") +
                               request_url + "\n");
       BlockRequest(request);
       return;
     }
   }
 
   // Set the new substituted URL.
   request.setURL(delegate_->RewriteLayoutTestsURL(
       request.url().string().utf8(),
-      test_runner_->is_web_platform_tests_mode()));
+      test_runner()->is_web_platform_tests_mode()));
 }
 
 void WebFrameTestClient::didReceiveResponse(
     const blink::WebURLResponse& response) {
-  if (test_runner_->shouldDumpResourceLoadCallbacks()) {
+  if (test_runner()->shouldDumpResourceLoadCallbacks()) {
     delegate_->PrintMessage(DescriptionSuitableForTestResult(
         GURL(response.url()).possibly_invalid_spec()));
     delegate_->PrintMessage(" - didReceiveResponse ");
     PrintResponseDescription(delegate_, response);
     delegate_->PrintMessage("\n");
   }
-  if (test_runner_->shouldDumpResourceResponseMIMETypes()) {
+  if (test_runner()->shouldDumpResourceResponseMIMETypes()) {
     GURL url = response.url();
     blink::WebString mime_type = response.mimeType();
     delegate_->PrintMessage(url.ExtractFileName());
     delegate_->PrintMessage(" has MIME type ");
     // Simulate NSURLResponse's mapping of empty/unknown MIME types to
     // application/octet-stream
     delegate_->PrintMessage(mime_type.isEmpty() ? "application/octet-stream"
                                                 : mime_type.utf8().data());
     delegate_->PrintMessage("\n");
   }
 }
 
 void WebFrameTestClient::didAddMessageToConsole(
     const blink::WebConsoleMessage& message,
     const blink::WebString& source_name,
     unsigned source_line,
     const blink::WebString& stack_trace) {
-  if (!test_runner_->ShouldDumpConsoleMessages())
+  if (!test_runner()->ShouldDumpConsoleMessages())
     return;
   std::string level;
   switch (message.level) {
     case blink::WebConsoleMessage::LevelDebug:
       level = "DEBUG";
       break;
     case blink::WebConsoleMessage::LevelLog:
       level = "MESSAGE";
       break;
     case blink::WebConsoleMessage::LevelInfo:
@@ skipping 20 matching lines @@
       new_message = new_message.substr(0, file_protocol) +
                     URLSuitableForTestResult(new_message.substr(file_protocol));
     }
     delegate_->PrintMessage(new_message);
   }
   delegate_->PrintMessage(std::string("\n"));
 }
 
 blink::WebNavigationPolicy WebFrameTestClient::decidePolicyForNavigation(
     const blink::WebFrameClient::NavigationPolicyInfo& info) {
-  if (test_runner_->shouldDumpNavigationPolicy()) {
+  if (test_runner()->shouldDumpNavigationPolicy()) {
     delegate_->PrintMessage("Default policy for navigation to '" +
                             URLDescription(info.urlRequest.url()) + "' is '" +
                             WebNavigationPolicyToString(info.defaultPolicy) +
                             "'\n");
   }
 
   blink::WebNavigationPolicy result;
-  if (!test_runner_->policyDelegateEnabled())
+  if (!test_runner()->policyDelegateEnabled())
     return info.defaultPolicy;
 
   delegate_->PrintMessage(
       std::string("Policy delegate: attempt to load ") +
       URLDescription(info.urlRequest.url()) + " with navigation type '" +
       WebNavigationTypeToString(info.navigationType) + "'\n");
-  if (test_runner_->policyDelegateIsPermissive())
+  if (test_runner()->policyDelegateIsPermissive())
     result = blink::WebNavigationPolicyCurrentTab;
   else
     result = blink::WebNavigationPolicyIgnore;
 
-  if (test_runner_->policyDelegateShouldNotifyDone()) {
-    test_runner_->policyDelegateDone();
+  if (test_runner()->policyDelegateShouldNotifyDone()) {
+    test_runner()->policyDelegateDone();
     result = blink::WebNavigationPolicyIgnore;
   }
 
   return result;
 }
 
 void WebFrameTestClient::checkIfAudioSinkExistsAndIsAuthorized(
     const blink::WebString& sink_id,
     const blink::WebSecurityOrigin& security_origin,
     blink::WebSetSinkIdCallbacks* web_callbacks) {
@@ skipping 15 matching lines @@
 bool WebFrameTestClient::runFileChooser(
     const blink::WebFileChooserParams& params,
     blink::WebFileChooserCompletion* completion) {
   delegate_->PrintMessage("Mock: Opening a file chooser.\n");
   // FIXME: Add ability to set file names to a file upload control.
   return false;
 }
 
 blink::WebEffectiveConnectionType
 WebFrameTestClient::getEffectiveConnectionType() {
-  return test_runner_->effective_connection_type();
+  return test_runner()->effective_connection_type();
+}
+
+TestRunner* WebFrameTestClient::test_runner() {
+  return web_view_test_proxy_base_->test_interfaces()->GetTestRunner();
 }
 
 }  // namespace test_runner