Drop replacesCurrentHistoryItem, NavigationType

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 118 matching lines @@
 #else
     pos = 0;
 #endif
   }
   std::string filename = url.substr(pos + 1);
   if (filename.empty())
     return "file:";  // A WebKit test has this in its expected output.
   return filename;
 }
 
-// WebNavigationType debugging strings taken from PolicyDelegate.mm.
-const char* kLinkClickedString = "link clicked";
-const char* kFormSubmittedString = "form submitted";
-const char* kBackForwardString = "back/forward";
-const char* kReloadString = "reload";
-const char* kFormResubmittedString = "form resubmitted";
-const char* kOtherString = "other";
-const char* kIllegalString = "illegal value";
-
-// Get a debugging string from a WebNavigationType.
-const char* WebNavigationTypeToString(blink::WebNavigationType type) {
-  switch (type) {
-    case blink::WebNavigationTypeLinkClicked:
-      return kLinkClickedString;
-    case blink::WebNavigationTypeFormSubmitted:
-      return kFormSubmittedString;
-    case blink::WebNavigationTypeBackForward:
-      return kBackForwardString;
-    case blink::WebNavigationTypeReload:
-      return kReloadString;
-    case blink::WebNavigationTypeFormResubmitted:
-      return kFormResubmittedString;
-    case blink::WebNavigationTypeOther:
-      return kOtherString;
-  }
-  return kIllegalString;
-}
-
 }  // namespace
 
 WebFrameTestClient::WebFrameTestClient(
     WebTestDelegate* delegate,
     WebViewTestProxyBase* web_view_test_proxy_base,
     WebFrameTestProxyBase* web_frame_test_proxy_base)
     : delegate_(delegate),
       web_view_test_proxy_base_(web_view_test_proxy_base),
       web_frame_test_proxy_base_(web_frame_test_proxy_base) {
   DCHECK(delegate_);
@@ skipping 207 matching lines @@
 }
 
 blink::WebUserMediaClient* WebFrameTestClient::userMediaClient() {
   return test_runner()->getMockWebUserMediaClient();
 }
 
 void WebFrameTestClient::loadURLExternally(
     const blink::WebURLRequest& request,
     blink::WebNavigationPolicy policy,
     const blink::WebString& suggested_name,
-    bool replaces_current_history_item) {
+    blink::WebFrameLoadType load_type) {
   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::loadErrorPage(int reason) {
   if (test_runner()->shouldDumpFrameLoadCallbacks()) {
     delegate_->PrintMessage(base::StringPrintf(
         "- loadErrorPage: %s\n", net::ErrorToString(reason).c_str()));
   }
 }
 
-void WebFrameTestClient::didStartProvisionalLoad(blink::WebLocalFrame* frame) {
+void WebFrameTestClient::didStartProvisionalLoad(
+    blink::WebDataSource* data_source,
+    blink::WebFrameLoadType load_type) {
+  blink::WebFrame* frame = web_frame_test_proxy_base_->web_frame();
   test_runner()->tryToSetTopLoadingFrame(frame);
 
   if (test_runner()->shouldDumpFrameLoadCallbacks()) {
     PrintFrameDescription(delegate_, frame);
     delegate_->PrintMessage(" - didStartProvisionalLoadForFrame\n");
   }
 
   if (test_runner()->shouldDumpUserGestureInFrameLoadCallbacks()) {
     PrintFrameuserGestureStatus(delegate_, frame,
                                 " - in didStartProvisionalLoadForFrame\n");
@@ skipping 13 matching lines @@
     blink::WebLocalFrame* frame,
     const blink::WebURLError& error,
     blink::WebHistoryCommitType commit_type) {
   if (test_runner()->shouldDumpFrameLoadCallbacks()) {
     PrintFrameDescription(delegate_, frame);
     delegate_->PrintMessage(" - didFailProvisionalLoadWithError\n");
   }
 }
 
 void WebFrameTestClient::didCommitProvisionalLoad(
-    blink::WebLocalFrame* frame,
+    blink::WebDataSource* data_source,
+    blink::WebFrameLoadType load_type,
     const blink::WebHistoryItem& history_item,
     blink::WebHistoryCommitType history_type) {
   if (test_runner()->shouldDumpFrameLoadCallbacks()) {
-    PrintFrameDescription(delegate_, frame);
+    PrintFrameDescription(delegate_, web_frame_test_proxy_base_->web_frame());
     delegate_->PrintMessage(" - didCommitLoadForFrame\n");
   }
 }
 
 void WebFrameTestClient::didReceiveTitle(blink::WebLocalFrame* frame,
                                          const blink::WebString& title,
                                          blink::WebTextDirection direction) {
   if (test_runner()->shouldDumpFrameLoadCallbacks()) {
     PrintFrameDescription(delegate_, frame);
     delegate_->PrintMessage(std::string(" - didReceiveTitle: ") + title.utf8() +
@@ skipping 37 matching lines @@
 }
 
 void WebFrameTestClient::didFinishLoad(blink::WebLocalFrame* frame) {
   if (test_runner()->shouldDumpFrameLoadCallbacks()) {
     PrintFrameDescription(delegate_, frame);
     delegate_->PrintMessage(" - didFinishLoadForFrame\n");
   }
 }
 
 void WebFrameTestClient::didNavigateWithinPage(
-    blink::WebLocalFrame* frame,
+    blink::WebDataSource* data_source,
+    blink::WebFrameLoadType load_type,
     const blink::WebHistoryItem& history_item,
     blink::WebHistoryCommitType commit_type,
     bool contentInitiated) {
   test_runner()->OnNavigationEnd();
 }
 
 void WebFrameTestClient::didStartLoading(bool to_different_document) {
   test_runner()->OnNavigationBegin(web_frame_test_proxy_base_->web_frame());
 }
 
 void WebFrameTestClient::didStopLoading() {
   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())
     delegate_->PrintMessage("didDetectXSS\n");
 }
 
 void WebFrameTestClient::didDispatchPingLoader(const blink::WebURL& url) {
   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) {
+                                         blink::WebURLRequest& request,
+                                         blink::WebFrameLoadType load_type) {
   // PlzNavigate
   // Navigation requests initiated by the renderer will have been logged when
   // the navigation was sent to the browser. Please see
   // the RenderFrameImpl::BeginNavigation() function.
   if (delegate_->IsNavigationInitiatedByRenderer(request))
     return;
   // Need to use GURL for host() and SchemeIs()
   GURL url = request.url();
   std::string request_url = url.possibly_invalid_spec();
 
@@ skipping 110 matching lines @@
     delegate_->PrintMessage("Default policy for navigation to '" +
                             URLDescription(info.urlRequest.url()) + "' is '" +
                             WebNavigationPolicyToString(info.defaultPolicy) +
                             "'\n");
   }
 
   blink::WebNavigationPolicy result;
   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");
+  delegate_->PrintMessage(std::string("Policy delegate: attempt to load ") +
+                          URLDescription(info.urlRequest.url()) + "\n");
   if (test_runner()->policyDelegateIsPermissive())
     result = blink::WebNavigationPolicyCurrentTab;
   else
     result = blink::WebNavigationPolicyIgnore;
 
   if (test_runner()->policyDelegateShouldNotifyDone()) {
     test_runner()->policyDelegateDone();
     result = blink::WebNavigationPolicyIgnore;
   }
 
@@ skipping 31 matching lines @@
 blink::WebEffectiveConnectionType
 WebFrameTestClient::getEffectiveConnectionType() {
   return test_runner()->effective_connection_type();
 }
 
 TestRunner* WebFrameTestClient::test_runner() {
   return web_view_test_proxy_base_->test_interfaces()->GetTestRunner();
 }
 
 }  // namespace test_runner