Move navigation specific logic in wilSendRequest to a separate method

content/renderer/render_frame_impl.cc

 // Copyright 2013 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/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 3943 matching lines @@
 
 void RenderFrameImpl::saveImageFromDataURL(const blink::WebString& data_url) {
   // Note: We should basically send GURL but we use size-limited string instead
   // in order to send a larger data url to save a image for <canvas> or <img>.
   if (data_url.length() < kMaxLengthOfDataURLString) {
     Send(new FrameHostMsg_SaveImageFromDataURL(
          render_view_->GetRoutingID(), routing_id_, data_url.utf8()));
   }
 }
 
-void RenderFrameImpl::willSendRequest(blink::WebLocalFrame* frame,
-                                      blink::WebURLRequest& request) {
-  DCHECK_EQ(frame_, frame);
-  // The request my be empty during tests.
-  if (request.url().isEmpty())
-    return;
-
+// Navigation specific logic belonging in willSendRequest.
+void RenderFrameImpl::WillSendNavigationRequest(
+    blink::WebLocalFrame* frame,
+    blink::WebURLRequest& request,
+    blink::WebDataSource* data_source,
+    RequestExtraData* new_extra_data) {
   // Set the first party for cookies url if it has not been set yet (new
   // requests). This value will be updated during redirects, consistent with
   // https://tools.ietf.org/html/draft-west-first-party-cookies-04#section-2.1.1
   if (request.firstPartyForCookies().isEmpty()) {
     if (request.getFrameType() == blink::WebURLRequest::FrameTypeTopLevel)
       request.setFirstPartyForCookies(request.url());
     else
       request.setFirstPartyForCookies(frame->document().firstPartyForCookies());
   }
 
   // Set the requestor origin to the same origin as the frame's document if it
   // hasn't yet been set.
   //
   // TODO(mkwst): It would be cleaner to adjust blink::ResourceRequest to
   // initialize itself with a `nullptr` initiator so that this can be a simple
   // `isNull()` check. https://crbug.com/625969
   if (request.requestorOrigin().isUnique() &&
       !frame->document().getSecurityOrigin().isUnique()) {
     request.setRequestorOrigin(frame->document().getSecurityOrigin());
   }
 
+  std::unique_ptr<StreamOverrideParameters> stream_override;
+  if (request.getExtraData()) {
+    stream_override = static_cast<RequestExtraData*>(request.getExtraData())
+                          ->TakeStreamOverrideOwnership();
+  }
+
+  // Add an empty HTTP origin header for non GET methods if none is currently
+  // present.
+  request.addHTTPOriginIfNeeded(WebString());
+
+  // Attach |should_replace_current_entry| state to requests so that, should
+  // this navigation later require a request transfer, all state is preserved
+  // when it is re-created in the new process.
+  new_extra_data->set_should_replace_current_entry(
+      data_source->replacesCurrentHistoryItem());
+
+  DCHECK(stream_override || !IsBrowserSideNavigationEnabled());
+  new_extra_data->set_stream_override(std::move(stream_override));
+}
+
+void RenderFrameImpl::willSendRequest(blink::WebLocalFrame* frame,
+                                      blink::WebURLRequest& request) {
+  DCHECK_EQ(frame_, frame);
+  // The request my be empty during tests.
+  if (request.url().isEmpty())
+    return;
+
   WebDataSource* provisional_data_source = frame->provisionalDataSource();
   WebDataSource* data_source =
       provisional_data_source ? provisional_data_source : frame->dataSource();
 
   DocumentState* document_state = DocumentState::FromDataSource(data_source);
   DCHECK(document_state);
+
   InternalDocumentStateData* internal_data =
       InternalDocumentStateData::FromDocumentState(document_state);
+  if (internal_data->is_cache_policy_override_set())
+    request.setCachePolicy(internal_data->cache_policy_override());
+
   NavigationStateImpl* navigation_state =
       static_cast<NavigationStateImpl*>(document_state->navigation_state());
   ui::PageTransition transition_type = navigation_state->GetTransitionType();
   if (provisional_data_source && provisional_data_source->isClientRedirect()) {
     transition_type = ui::PageTransitionFromInt(
         transition_type | ui::PAGE_TRANSITION_CLIENT_REDIRECT);
   }
 
   GURL request_url(request.url());
   GURL new_url;
   if (GetContentClient()->renderer()->WillSendRequest(
           frame,
           transition_type,
           request_url,
           request.firstPartyForCookies(),
           &new_url)) {
     request.setURL(WebURL(new_url));
   }
 
-  if (internal_data->is_cache_policy_override_set())
-    request.setCachePolicy(internal_data->cache_policy_override());
-
   // The request's extra data may indicate that we should set a custom user
   // agent. This needs to be done here, after WebKit is through with setting the
   // user agent on its own. Similarly, it may indicate that we should set an
   // X-Requested-With header. This must be done here to avoid breaking CORS
   // checks.
-  // PlzNavigate: there may also be a stream url associated with the request.
+  // This is used by pepper.
   WebString custom_user_agent;
   WebString requested_with;
-  std::unique_ptr<StreamOverrideParameters> stream_override;
   if (request.getExtraData()) {
     RequestExtraData* old_extra_data =
         static_cast<RequestExtraData*>(request.getExtraData());
 
     custom_user_agent = old_extra_data->custom_user_agent();
     if (!custom_user_agent.isNull()) {
       if (custom_user_agent.isEmpty())
         request.clearHTTPHeaderField("User-Agent");
       else
         request.setHTTPHeaderField("User-Agent", custom_user_agent);
     }
 
     requested_with = old_extra_data->requested_with();
     if (!requested_with.isNull()) {
       if (requested_with.isEmpty())
         request.clearHTTPHeaderField("X-Requested-With");
       else
         request.setHTTPHeaderField("X-Requested-With", requested_with);
     }
-    stream_override = old_extra_data->TakeStreamOverrideOwnership();
   }
 
-  // Add an empty HTTP origin header for non GET methods if none is currently
-  // present.
-  request.addHTTPOriginIfNeeded(WebString());
-
-  // Attach |should_replace_current_entry| state to requests so that, should
-  // this navigation later require a request transfer, all state is preserved
-  // when it is re-created in the new process.
-  bool should_replace_current_entry = data_source->replacesCurrentHistoryItem();
-
   int provider_id = kInvalidServiceWorkerProviderId;
   if (request.getFrameType() == blink::WebURLRequest::FrameTypeTopLevel ||
       request.getFrameType() == blink::WebURLRequest::FrameTypeNested) {
     // |provisionalDataSource| may be null in some content::ResourceFetcher
     // use cases, we don't hook those requests.
     if (frame->provisionalDataSource()) {
       ServiceWorkerNetworkProvider* provider =
           ServiceWorkerNetworkProvider::FromDocumentState(
               DocumentState::FromDataSource(frame->provisionalDataSource()));
       DCHECK(provider);
       provider_id = provider->provider_id();
     }
   } else if (frame->dataSource()) {
     ServiceWorkerNetworkProvider* provider =
         ServiceWorkerNetworkProvider::FromDocumentState(
             DocumentState::FromDataSource(frame->dataSource()));
     DCHECK(provider);
     provider_id = provider->provider_id();
     // Explicitly set the SkipServiceWorker flag here if the renderer process
     // hasn't received SetControllerServiceWorker message.
     if (!provider->IsControlledByServiceWorker() &&
         request.skipServiceWorker() !=
             blink::WebURLRequest::SkipServiceWorker::All)
       request.setSkipServiceWorker(
           blink::WebURLRequest::SkipServiceWorker::Controlling);
   }
 
+  RequestExtraData* extra_data = new RequestExtraData();
+  if (request.getFrameType() != WebURLRequest::FrameTypeNone)
+    WillSendNavigationRequest(frame, request, data_source, extra_data);
+
   WebFrame* parent = frame->parent();
   int parent_routing_id = parent ? GetRoutingIdForFrameOrProxy(parent) : -1;
 
-  RequestExtraData* extra_data = new RequestExtraData();
   extra_data->set_visibility_state(visibilityState());
   extra_data->set_custom_user_agent(custom_user_agent);
   extra_data->set_requested_with(requested_with);
   extra_data->set_render_frame_id(routing_id_);
   extra_data->set_is_main_frame(!parent);
   extra_data->set_frame_origin(
       blink::WebStringToGURL(frame->document().getSecurityOrigin().toString()));
   extra_data->set_parent_is_main_frame(parent && !parent->parent());
   extra_data->set_parent_render_frame_id(parent_routing_id);
   extra_data->set_allow_download(
       navigation_state->common_params().allow_download);
   extra_data->set_transition_type(transition_type);
-  extra_data->set_should_replace_current_entry(should_replace_current_entry);
   extra_data->set_transferred_request_child_id(
       navigation_state->start_params().transferred_request_child_id);
   extra_data->set_transferred_request_request_id(
       navigation_state->start_params().transferred_request_request_id);
   extra_data->set_service_worker_provider_id(provider_id);
-  extra_data->set_stream_override(std::move(stream_override));
   bool is_prefetch =
       GetContentClient()->renderer()->IsPrefetchOnly(this, request);
   extra_data->set_is_prefetch(is_prefetch);
   extra_data->set_download_to_network_cache_only(
       is_prefetch &&
       WebURLRequestToResourceType(request) != RESOURCE_TYPE_MAIN_FRAME);
   WebString error;
   extra_data->set_initiated_in_secure_context(
       frame->document().isSecureContext(error));
+
   request.setExtraData(extra_data);
 
   if (request.getLoFiState() == WebURLRequest::LoFiUnspecified) {
     if (is_main_frame_ && !navigation_state->request_committed()) {
       request.setLoFiState(static_cast<WebURLRequest::LoFiState>(
           navigation_state->common_params().lofi_state));
     } else {
       request.setLoFiState(
           is_using_lofi_ ? WebURLRequest::LoFiOn : WebURLRequest::LoFiOff);
     }
@@ skipping 2267 matching lines @@
   // event target. Potentially a Pepper plugin will receive the event.
   // In order to tell whether a plugin gets the last mouse event and which it
   // is, we set |pepper_last_mouse_event_target_| to null here. If a plugin gets
   // the event, it will notify us via DidReceiveMouseEvent() and set itself as
   // |pepper_last_mouse_event_target_|.
   pepper_last_mouse_event_target_ = nullptr;
 #endif
 }
 
 }  // namespace content