Do not use FrameLoadRequest for CommitNavigation

There is a clear separation between fields used
for StartNavigation vs CommitNavigation.

For now, we can pass four parameters directly. In the
future, we should probably put all parameters to
WebNavigationParams.

Bug: none
Change-Id: I4b1a0dac46bb4057b950c1cc8044303903d39f10
Reviewed-on: https://chromium-review.googlesource.com/c/1250124
Commit-Queue: Dmitry Gozman <dgozman@chromium.org>
Reviewed-by: Nate Chapin <japhet@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Cr-Commit-Position: refs/heads/master@{#596449}

third_party/blink/renderer/core/css/style_environment_variables_test.cc

@@ -12,6 +12,7 @@
 #include "third_party/blink/renderer/core/html/html_element.h"
 #include "third_party/blink/renderer/core/style/computed_style.h"
 #include "third_party/blink/renderer/core/testing/page_test_base.h"
+#include "third_party/blink/renderer/platform/loader/fetch/substitute_data.h"
 #include "third_party/blink/renderer/platform/testing/unit_test_helpers.h"
 
 namespace blink {
@@ -81,9 +82,10 @@ class StyleEnvironmentVariablesTest : public PageTestBase {
 
   void SimulateNavigation() {
     const KURL& url = KURL(NullURL(), "https://www.example.com");
-    FrameLoadRequest request(nullptr, ResourceRequest(url),
-                             SubstituteData(SharedBuffer::Create()));
-    GetDocument().GetFrame()->Loader().CommitNavigation(request);
+    GetDocument().GetFrame()->Loader().CommitNavigation(
+        ResourceRequest(url), SubstituteData(SharedBuffer::Create()),
+        ClientRedirectPolicy::kNotClientRedirect,
+        base::UnguessableToken::Create());
     blink::test::RunPendingTasks();
     ASSERT_EQ(url.GetString(), GetDocument().Url().GetString());
   }

third_party/blink/renderer/core/exported/worker_shadow_page.cc

@@ -70,8 +70,10 @@ void WorkerShadowPage::Initialize(const KURL& script_url) {
   CString content("");
   scoped_refptr<SharedBuffer> buffer(
       SharedBuffer::Create(content.data(), content.length()));
-  main_frame_->GetFrame()->Loader().CommitNavigation(FrameLoadRequest(
-      nullptr, ResourceRequest(script_url), SubstituteData(buffer)));
+  main_frame_->GetFrame()->Loader().CommitNavigation(
+      ResourceRequest(script_url), SubstituteData(buffer),
+      ClientRedirectPolicy::kNotClientRedirect,
+      base::UnguessableToken::Create());
 }
 
 void WorkerShadowPage::DidFinishDocumentLoad() {

third_party/blink/renderer/core/frame/frame_test.cc

@@ -25,9 +25,10 @@ class FrameTest : public PageTestBase {
 
   void Navigate(const String& destinationUrl, bool user_activated) {
     const KURL& url = KURL(NullURL(), destinationUrl);
-    FrameLoadRequest request(nullptr, ResourceRequest(url),
-                             SubstituteData(SharedBuffer::Create()));
-    GetDocument().GetFrame()->Loader().CommitNavigation(request);
+    GetDocument().GetFrame()->Loader().CommitNavigation(
+        ResourceRequest(url), SubstituteData(SharedBuffer::Create()),
+        ClientRedirectPolicy::kNotClientRedirect,
+        base::UnguessableToken::Create());
     if (user_activated) {
       GetDocument()
           .GetFrame()

third_party/blink/renderer/core/frame/web_local_frame_impl.cc

@@ -912,8 +912,7 @@ void WebLocalFrameImpl::StartReload(WebFrameLoadType frame_load_type) {
 
   GetFrame()->Loader().StartNavigation(
       FrameLoadRequest(nullptr, request, /*frame_name=*/AtomicString(),
-                       kCheckContentSecurityPolicy,
-                       base::UnguessableToken::Create()),
+                       kCheckContentSecurityPolicy),
       frame_load_type);
 }
 
@@ -937,9 +936,9 @@ void WebLocalFrameImpl::StartNavigation(const WebURLRequest& request) {
     GetTextFinder()->ClearActiveFindMatch();
 
   GetFrame()->Loader().StartNavigation(
-      FrameLoadRequest(
-          nullptr, request.ToResourceRequest(), /*frame_name=*/AtomicString(),
-          kCheckContentSecurityPolicy, base::UnguessableToken::Create()),
+      FrameLoadRequest(nullptr, request.ToResourceRequest(),
+                       /*frame_name=*/AtomicString(),
+                       kCheckContentSecurityPolicy),
       WebFrameLoadType::kStandard);
 }
 
@@ -2050,19 +2049,15 @@ void WebLocalFrameImpl::CommitNavigation(
   DCHECK(GetFrame());
   DCHECK(!request.IsNull());
   DCHECK(!request.Url().ProtocolIs("javascript"));
-  const ResourceRequest& resource_request = request.ToResourceRequest();
-
   if (GetTextFinder())
     GetTextFinder()->ClearActiveFindMatch();
 
-  FrameLoadRequest frame_request =
-      FrameLoadRequest(nullptr, resource_request, /*frame_name=*/AtomicString(),
-                       kCheckContentSecurityPolicy, devtools_navigation_token);
-  if (is_client_redirect)
-    frame_request.SetClientRedirect(ClientRedirectPolicy::kClientRedirect);
   HistoryItem* history_item = item;
   GetFrame()->Loader().CommitNavigation(
-      frame_request, web_frame_load_type, history_item,
+      request.ToResourceRequest(), SubstituteData(),
+      is_client_redirect ? ClientRedirectPolicy::kClientRedirect
+                         : ClientRedirectPolicy::kNotClientRedirect,
+      devtools_navigation_token, web_frame_load_type, history_item,
       std::move(navigation_params), std::move(extra_data));
 }
 
@@ -2137,15 +2132,12 @@ void WebLocalFrameImpl::CommitDataNavigation(
     bool is_client_redirect,
     std::unique_ptr<WebNavigationParams> navigation_params,
     std::unique_ptr<WebDocumentLoader::ExtraData> navigation_data) {
-  FrameLoadRequest frame_request(
-      nullptr, request.ToResourceRequest(),
-      SubstituteData(data, mime_type, text_encoding, unreachable_url));
-  DCHECK(frame_request.GetSubstituteData().IsValid());
-  if (is_client_redirect)
-    frame_request.SetClientRedirect(ClientRedirectPolicy::kClientRedirect);
-
   GetFrame()->Loader().CommitNavigation(
-      frame_request, web_frame_load_type, history_item,
+      request.ToResourceRequest(),
+      SubstituteData(data, mime_type, text_encoding, unreachable_url),
+      is_client_redirect ? ClientRedirectPolicy::kClientRedirect
+                         : ClientRedirectPolicy::kNotClientRedirect,
+      base::UnguessableToken::Create(), web_frame_load_type, history_item,
       std::move(navigation_params), std::move(navigation_data));
 }
 

third_party/blink/renderer/core/html/html_anchor_element.cc

@@ -403,7 +403,6 @@ void HTMLAnchorElement::HandleClick(Event& event) {
   }
   if (HasRel(kRelationNoOpener))
     frame_request.SetShouldSetOpener(kNeverSetOpener);
-  frame_request.SetHrefTranslate(FastGetAttribute(hreftranslateAttr));
   frame_request.SetTriggeringEventInfo(
       event.isTrusted() ? WebTriggeringEventInfo::kFromTrustedEvent
                         : WebTriggeringEventInfo::kFromUntrustedEvent);

third_party/blink/renderer/core/loader/frame_load_request.cc

@@ -25,18 +25,7 @@ FrameLoadRequest::FrameLoadRequest(Document* origin_document,
     : FrameLoadRequest(origin_document,
                        resource_request,
                        frame_name,
-                       kCheckContentSecurityPolicy,
-                       base::UnguessableToken::Create()) {}
-
-FrameLoadRequest::FrameLoadRequest(Document* origin_document,
-                                   const ResourceRequest& resource_request,
-                                   const SubstituteData& substitute_data)
-    : FrameLoadRequest(origin_document,
-                       resource_request,
-                       AtomicString(),
-                       substitute_data,
-                       kCheckContentSecurityPolicy,
-                       base::UnguessableToken::Create()) {}
+                       kCheckContentSecurityPolicy) {}
 
 FrameLoadRequest::FrameLoadRequest(
     Document* origin_document,
@@ -44,44 +33,14 @@ FrameLoadRequest::FrameLoadRequest(
     const AtomicString& frame_name,
     ContentSecurityPolicyDisposition
         should_check_main_world_content_security_policy)
-    : FrameLoadRequest(origin_document,
-                       resource_request,
-                       frame_name,
-                       should_check_main_world_content_security_policy,
-                       base::UnguessableToken::Create()) {}
-
-FrameLoadRequest::FrameLoadRequest(
-    Document* origin_document,
-    const ResourceRequest& resource_request,
-    const AtomicString& frame_name,
-    ContentSecurityPolicyDisposition
-        should_check_main_world_content_security_policy,
-    const base::UnguessableToken& devtools_navigation_token)
-    : FrameLoadRequest(origin_document,
-                       resource_request,
-                       frame_name,
-                       SubstituteData(),
-                       should_check_main_world_content_security_policy,
-                       devtools_navigation_token) {}
-
-FrameLoadRequest::FrameLoadRequest(
-    Document* origin_document,
-    const ResourceRequest& resource_request,
-    const AtomicString& frame_name,
-    const SubstituteData& substitute_data,
-    ContentSecurityPolicyDisposition
-        should_check_main_world_content_security_policy,
-    const base::UnguessableToken& devtools_navigation_token)
     : origin_document_(origin_document),
       resource_request_(resource_request),
       frame_name_(frame_name),
-      substitute_data_(substitute_data),
       client_redirect_(ClientRedirectPolicy::kNotClientRedirect),
       should_send_referrer_(kMaybeSendReferrer),
       should_set_opener_(kMaybeSetOpener),
       should_check_main_world_content_security_policy_(
-          should_check_main_world_content_security_policy),
-      devtools_navigation_token_(devtools_navigation_token) {
+          should_check_main_world_content_security_policy) {
   // These flags are passed to a service worker which controls the page.
   resource_request_.SetFetchRequestMode(
       network::mojom::FetchRequestMode::kNavigate);

third_party/blink/renderer/core/loader/frame_load_request.h

@@ -26,7 +26,6 @@
 #ifndef THIRD_PARTY_BLINK_RENDERER_CORE_LOADER_FRAME_LOAD_REQUEST_H_
 #define THIRD_PARTY_BLINK_RENDERER_CORE_LOADER_FRAME_LOAD_REQUEST_H_
 
-#include "base/unguessable_token.h"
 #include "third_party/blink/public/mojom/blob/blob_url_store.mojom-blink.h"
 #include "third_party/blink/public/web/web_triggering_event_info.h"
 #include "third_party/blink/renderer/core/dom/document.h"
@@ -34,7 +33,6 @@
 #include "third_party/blink/renderer/core/loader/frame_loader_types.h"
 #include "third_party/blink/renderer/platform/loader/fetch/resource_loader_options.h"
 #include "third_party/blink/renderer/platform/loader/fetch/resource_request.h"
-#include "third_party/blink/renderer/platform/loader/fetch/substitute_data.h"
 
 namespace blink {
 
@@ -49,18 +47,10 @@ struct CORE_EXPORT FrameLoadRequest {
   FrameLoadRequest(Document* origin_document,
                    const ResourceRequest&,
                    const AtomicString& frame_name);
-  FrameLoadRequest(Document* origin_document,
-                   const ResourceRequest&,
-                   const SubstituteData&);
   FrameLoadRequest(Document* origin_document,
                    const ResourceRequest&,
                    const AtomicString& frame_name,
                    ContentSecurityPolicyDisposition);
-  FrameLoadRequest(Document* origin_document,
-                   const ResourceRequest&,
-                   const AtomicString& frame_name,
-                   ContentSecurityPolicyDisposition,
-                   const base::UnguessableToken& devtools_navigation_token);
 
   Document* OriginDocument() const { return origin_document_.Get(); }
 
@@ -74,8 +64,6 @@ struct CORE_EXPORT FrameLoadRequest {
     frame_name_ = frame_name;
   }
 
-  const SubstituteData& GetSubstituteData() const { return substitute_data_; }
-
   ClientRedirectPolicy ClientRedirect() const { return client_redirect_; }
   void SetClientRedirect(ClientRedirectPolicy client_redirect) {
     client_redirect_ = client_redirect;
@@ -104,21 +92,11 @@ struct CORE_EXPORT FrameLoadRequest {
     should_set_opener_ = should_set_opener;
   }
 
-  const AtomicString& HrefTranslate() { return href_translate_; }
-  void SetHrefTranslate(const AtomicString& translate) {
-    href_translate_ = translate;
-  }
-
   ContentSecurityPolicyDisposition ShouldCheckMainWorldContentSecurityPolicy()
       const {
     return should_check_main_world_content_security_policy_;
   }
 
-  // See DocumentLoader::devtools_navigation_token_ for documentation.
-  const base::UnguessableToken& GetDevToolsNavigationToken() const {
-    return devtools_navigation_token_;
-  }
-
   // Sets the BlobURLToken that should be used when fetching the resource. This
   // is needed for blob URLs, because the blob URL might be revoked before the
   // actual fetch happens, which would result in incorrect failures to fetch.
@@ -150,18 +128,9 @@ struct CORE_EXPORT FrameLoadRequest {
   base::TimeTicks GetInputStartTime() const { return input_start_time_; }
 
  private:
-  FrameLoadRequest(Document* origin_document,
-                   const ResourceRequest&,
-                   const AtomicString& frame_name,
-                   const SubstituteData&,
-                   ContentSecurityPolicyDisposition,
-                   const base::UnguessableToken& devtools_navigation_token);
-
   Member<Document> origin_document_;
   ResourceRequest resource_request_;
   AtomicString frame_name_;
-  AtomicString href_translate_;
-  SubstituteData substitute_data_;
   ClientRedirectPolicy client_redirect_;
   WebTriggeringEventInfo triggering_event_info_ =
       WebTriggeringEventInfo::kNotFromEvent;
@@ -170,7 +139,6 @@ struct CORE_EXPORT FrameLoadRequest {
   ShouldSetOpener should_set_opener_;
   ContentSecurityPolicyDisposition
       should_check_main_world_content_security_policy_;
-  base::UnguessableToken devtools_navigation_token_;
   scoped_refptr<base::RefCountedData<mojom::blink::BlobURLTokenPtr>>
       blob_url_token_;
   base::TimeTicks input_start_time_;

third_party/blink/renderer/core/loader/frame_loader.cc

@@ -40,6 +40,7 @@
 #include "base/auto_reset.h"
 #include "base/feature_list.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/unguessable_token.h"
 #include "services/network/public/mojom/request_context_frame_type.mojom-blink.h"
 #include "third_party/blink/public/common/features.h"
 #include "third_party/blink/public/platform/modules/fetch/fetch_api_request.mojom-shared.h"
@@ -629,7 +630,9 @@ void FrameLoader::SetReferrerForFrameRequest(FrameLoadRequest& frame_request) {
 }
 
 WebFrameLoadType FrameLoader::DetermineFrameLoadType(
-    const FrameLoadRequest& request,
+    const ResourceRequest& resource_request,
+    Document* origin_document,
+    const KURL& failing_url,
     WebFrameLoadType frame_load_type) {
   // TODO(dgozman): this method is rewriting the load type, which makes it hard
   // to reason about various navigations and their desired load type. We should
@@ -643,7 +646,7 @@ WebFrameLoadType FrameLoader::DetermineFrameLoadType(
         !state_machine_.CommittedFirstRealDocumentLoad())
       return WebFrameLoadType::kReplaceCurrentItem;
     if (!frame_->Tree().Parent() && !Client()->BackForwardLength()) {
-      if (Opener() && request.GetResourceRequest().Url().IsEmpty())
+      if (Opener() && resource_request.Url().IsEmpty())
         return WebFrameLoadType::kReplaceCurrentItem;
       return WebFrameLoadType::kStandard;
     }
@@ -651,9 +654,9 @@ WebFrameLoadType FrameLoader::DetermineFrameLoadType(
   if (frame_load_type != WebFrameLoadType::kStandard)
     return frame_load_type;
   CHECK_NE(mojom::FetchCacheMode::kValidateCache,
-           request.GetResourceRequest().GetCacheMode());
+           resource_request.GetCacheMode());
   CHECK_NE(mojom::FetchCacheMode::kBypassCache,
-           request.GetResourceRequest().GetCacheMode());
+           resource_request.GetCacheMode());
   // From the HTML5 spec for location.assign():
   // "If the browsing context's session history contains only one Document,
   // and that was the about:blank Document created when the browsing context
@@ -662,26 +665,23 @@ WebFrameLoadType FrameLoader::DetermineFrameLoadType(
        DeprecatedEqualIgnoringCase(frame_->GetDocument()->Url(), BlankURL())))
     return WebFrameLoadType::kReplaceCurrentItem;
 
-  if (request.GetResourceRequest().Url() == document_loader_->UrlForHistory()) {
-    if (request.GetResourceRequest().HttpMethod() == HTTPNames::POST)
+  if (resource_request.Url() == document_loader_->UrlForHistory()) {
+    if (resource_request.HttpMethod() == HTTPNames::POST)
       return WebFrameLoadType::kStandard;
-    if (!request.OriginDocument())
+    if (!origin_document)
       return WebFrameLoadType::kReload;
     return WebFrameLoadType::kReplaceCurrentItem;
   }
 
-  if (request.GetSubstituteData().FailingURL() ==
-          document_loader_->UrlForHistory() &&
+  if (failing_url == document_loader_->UrlForHistory() &&
       document_loader_->LoadType() == WebFrameLoadType::kReload)
     return WebFrameLoadType::kReload;
 
-  if (request.GetResourceRequest().Url().IsEmpty() &&
-      request.GetSubstituteData().FailingURL().IsEmpty()) {
+  if (resource_request.Url().IsEmpty() && failing_url.IsEmpty()) {
     return WebFrameLoadType::kReplaceCurrentItem;
   }
 
-  if (request.OriginDocument() &&
-      !request.OriginDocument()->CanCreateHistoryEntry())
+  if (origin_document && !origin_document->CanCreateHistoryEntry())
     return WebFrameLoadType::kReplaceCurrentItem;
 
   return WebFrameLoadType::kStandard;
@@ -773,7 +773,6 @@ static WebURLRequest::RequestContext DetermineRequestContextFromNavigationType(
 void FrameLoader::StartNavigation(const FrameLoadRequest& passed_request,
                                   WebFrameLoadType frame_load_type,
                                   NavigationPolicy policy) {
-  CHECK(!passed_request.GetSubstituteData().IsValid());
   CHECK(!IsBackForwardLoadType(frame_load_type));
   DCHECK(passed_request.TriggeringEventInfo() !=
          WebTriggeringEventInfo::kUnknown);
@@ -846,7 +845,8 @@ void FrameLoader::StartNavigation(const FrameLoadRequest& passed_request,
     return;
   }
 
-  frame_load_type = DetermineFrameLoadType(request, frame_load_type);
+  frame_load_type = DetermineFrameLoadType(resource_request, origin_document,
+                                           KURL(), frame_load_type);
 
   bool same_document_navigation =
       policy == kNavigationPolicyCurrentTab &&
@@ -940,12 +940,9 @@ void FrameLoader::StartNavigation(const FrameLoadRequest& passed_request,
     Client()->DispatchWillSubmitForm(request.Form());
 
   if (policy == kNavigationPolicyCurrentTab) {
-    FrameLoadRequest new_request(
-        nullptr, resource_request, AtomicString(),
-        request.ShouldCheckMainWorldContentSecurityPolicy(),
-        request.GetDevToolsNavigationToken());
-    new_request.SetClientRedirect(request.ClientRedirect());
-    CommitNavigation(new_request, frame_load_type, nullptr, nullptr, nullptr);
+    CommitNavigation(resource_request, SubstituteData(),
+                     request.ClientRedirect(), base::UnguessableToken::Create(),
+                     frame_load_type, nullptr, nullptr, nullptr);
     return;
   }
 
@@ -956,7 +953,8 @@ void FrameLoader::StartNavigation(const FrameLoadRequest& passed_request,
   }
 
   provisional_document_loader_ = CreateDocumentLoader(
-      resource_request, request, frame_load_type, navigation_type,
+      resource_request, SubstituteData(), request.ClientRedirect(),
+      base::UnguessableToken::Create(), frame_load_type, navigation_type,
       nullptr /* navigation_params */, nullptr /* extra_data */);
 
   provisional_document_loader_->AppendRedirect(
@@ -973,16 +971,14 @@ void FrameLoader::StartNavigation(const FrameLoadRequest& passed_request,
 }
 
 void FrameLoader::CommitNavigation(
-    const FrameLoadRequest& passed_request,
+    const ResourceRequest& request,
+    const SubstituteData& substitute_data,
+    ClientRedirectPolicy client_redirect_policy,
+    const base::UnguessableToken& devtools_navigation_token,
     WebFrameLoadType frame_load_type,
     HistoryItem* history_item,
     std::unique_ptr<WebNavigationParams> navigation_params,
     std::unique_ptr<WebDocumentLoader::ExtraData> extra_data) {
-  CHECK(!passed_request.OriginDocument());
-  CHECK(passed_request.FrameName().IsEmpty());
-  CHECK(!passed_request.Form());
-  CHECK(passed_request.TriggeringEventInfo() ==
-        WebTriggeringEventInfo::kNotFromEvent);
   DCHECK(frame_->GetDocument());
   DCHECK(Client()->HasWebView());
 
@@ -1004,12 +1000,19 @@ void FrameLoader::CommitNavigation(
   if (HTMLFrameOwnerElement* element = frame_->DeprecatedLocalOwner())
     element->CancelPendingLazyLoad();
 
-  FrameLoadRequest request(passed_request);
-  ResourceRequest& resource_request = request.GetResourceRequest();
+  ResourceRequest resource_request = request;
   resource_request.SetHasUserGesture(
       LocalFrame::HasTransientUserActivation(frame_));
+  resource_request.SetFetchRequestMode(
+      network::mojom::FetchRequestMode::kNavigate);
+  resource_request.SetFetchCredentialsMode(
+      network::mojom::FetchCredentialsMode::kInclude);
+  resource_request.SetFetchRedirectMode(
+      network::mojom::FetchRedirectMode::kManual);
 
-  frame_load_type = DetermineFrameLoadType(request, frame_load_type);
+  frame_load_type =
+      DetermineFrameLoadType(resource_request, nullptr /* origin_document */,
+                             substitute_data.FailingURL(), frame_load_type);
 
   // Note: we might actually classify this navigation as same document
   // right here in the following circumstances:
@@ -1043,7 +1046,8 @@ void FrameLoader::CommitNavigation(
   // TODO(dgozman): get rid of provisional document loader and most of the code
   // below. We should probably call DocumentLoader::CommitNavigation directly.
   provisional_document_loader_ = CreateDocumentLoader(
-      resource_request, request, frame_load_type, navigation_type,
+      resource_request, substitute_data, client_redirect_policy,
+      devtools_navigation_token, frame_load_type, navigation_type,
       std::move(navigation_params), std::move(extra_data));
   provisional_document_loader_->AppendRedirect(
       provisional_document_loader_->Url());
@@ -1744,18 +1748,18 @@ inline void FrameLoader::TakeObjectSnapshot() const {
 
 DocumentLoader* FrameLoader::CreateDocumentLoader(
     const ResourceRequest& request,
-    const FrameLoadRequest& frame_load_request,
+    const SubstituteData& substitute_data,
+    ClientRedirectPolicy client_redirect_policy,
+    const base::UnguessableToken& devtools_navigation_token,
     WebFrameLoadType load_type,
     WebNavigationType navigation_type,
     std::unique_ptr<WebNavigationParams> navigation_params,
     std::unique_ptr<WebDocumentLoader::ExtraData> extra_data) {
   DocumentLoader* loader = Client()->CreateDocumentLoader(
       frame_, request,
-      frame_load_request.GetSubstituteData().IsValid()
-          ? frame_load_request.GetSubstituteData()
-          : DefaultSubstituteDataForURL(request.Url()),
-      frame_load_request.ClientRedirect(),
-      frame_load_request.GetDevToolsNavigationToken(),
+      substitute_data.IsValid() ? substitute_data
+                                : DefaultSubstituteDataForURL(request.Url()),
+      client_redirect_policy, devtools_navigation_token,
       std::move(navigation_params), std::move(extra_data));
 
   loader->SetLoadType(load_type);

third_party/blink/renderer/core/loader/frame_loader.h

@@ -50,6 +50,10 @@
 
 #include <memory>
 
+namespace base {
+class UnguessableToken;
+}
+
 namespace blink {
 
 class Document;
@@ -103,8 +107,13 @@ class CORE_EXPORT FrameLoader final {
   // that browser process has already performed any checks necessary.
   // For history navigations, a history item should be provided and
   // an appropriate WebFrameLoadType should be given.
+  // See DocumentLoader::devtools_navigation_token_ for documentation on
+  // the token.
   void CommitNavigation(
-      const FrameLoadRequest&,
+      const ResourceRequest&,
+      const SubstituteData&,
+      ClientRedirectPolicy,
+      const base::UnguessableToken& devtools_navigation_token,
       WebFrameLoadType = WebFrameLoadType::kStandard,
       HistoryItem* = nullptr,
       std::unique_ptr<WebNavigationParams> navigation_params = nullptr,
@@ -229,8 +238,11 @@ class CORE_EXPORT FrameLoader final {
 
  private:
   bool PrepareRequestForThisFrame(FrameLoadRequest&);
-  WebFrameLoadType DetermineFrameLoadType(const FrameLoadRequest&,
-                                          WebFrameLoadType);
+  WebFrameLoadType DetermineFrameLoadType(
+      const ResourceRequest& resource_request,
+      Document* origin_document,
+      const KURL& failing_url,
+      WebFrameLoadType);
 
   SubstituteData DefaultSubstituteDataForURL(const KURL&);
 
@@ -268,7 +280,9 @@ class CORE_EXPORT FrameLoader final {
 
   DocumentLoader* CreateDocumentLoader(
       const ResourceRequest&,
-      const FrameLoadRequest&,
+      const SubstituteData&,
+      ClientRedirectPolicy,
+      const base::UnguessableToken& devtools_navigation_token,
       WebFrameLoadType,
       WebNavigationType,
       std::unique_ptr<WebNavigationParams>,

third_party/blink/renderer/core/loader/ping_loader_test.cc

@@ -48,9 +48,10 @@ class PingLoaderTest : public PageTestBase {
   }
 
   void SetDocumentURL(const KURL& url) {
-    FrameLoadRequest request(nullptr, ResourceRequest(url),
-                             SubstituteData(SharedBuffer::Create()));
-    GetFrame().Loader().CommitNavigation(request);
+    GetFrame().Loader().CommitNavigation(
+        ResourceRequest(url), SubstituteData(SharedBuffer::Create()),
+        ClientRedirectPolicy::kNotClientRedirect,
+        base::UnguessableToken::Create());
     blink::test::RunPendingTasks();
     ASSERT_EQ(url.GetString(), GetDocument().Url().GetString());
   }

third_party/blink/renderer/core/testing/page_test_base.cc

@@ -11,6 +11,7 @@
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/frame/local_frame_view.h"
 #include "third_party/blink/renderer/core/html/html_element.h"
+#include "third_party/blink/renderer/platform/loader/fetch/substitute_data.h"
 #include "third_party/blink/renderer/platform/testing/unit_test_helpers.h"
 
 namespace blink {