Make prepareRequest() a separate callback of FetchContext

third_party/WebKit/Source/core/loader/FrameFetchContext.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 404 matching lines @@
 void FrameFetchContext::dispatchDidChangeResourcePriority(
     unsigned long identifier,
     ResourceLoadPriority loadPriority,
     int intraPriorityValue) {
   TRACE_EVENT1(
       "devtools.timeline", "ResourceChangePriority", "data",
       InspectorChangeResourcePriorityEvent::data(identifier, loadPriority));
   probe::didChangeResourcePriority(frame(), identifier, loadPriority);
 }
 
-void FrameFetchContext::prepareRequest(ResourceRequest& request) {
+void FrameFetchContext::prepareRequest(ResourceRequest& request,
+                                       RedirectType redirectType) {
   frame()->loader().applyUserAgent(request);
   localFrameClient()->dispatchWillSendRequest(request);
 
+  // ServiceWorker hook ups.
   if (masterDocumentLoader()->getServiceWorkerNetworkProvider()) {
     WrappedResourceRequest webreq(request);
     masterDocumentLoader()->getServiceWorkerNetworkProvider()->willSendRequest(
         webreq);
   }
+
+  // If it's not for redirect, hook up ApplicationCache here too.
+  if (redirectType == FetchContext::RedirectType::kNotForRedirect &&
+      m_documentLoader && !m_documentLoader->fetcher()->archive() &&
+      request.url().isValid()) {
+    m_documentLoader->applicationCacheHost()->willStartLoading(request);
+  }
 }
 
 void FrameFetchContext::dispatchWillSendRequest(
     unsigned long identifier,
     ResourceRequest& request,
     const ResourceResponse& redirectResponse,
     const FetchInitiatorInfo& initiatorInfo) {
-  // For initial requests, prepareRequest() is called in
-  // willStartLoadingResource(), before revalidation policy is determined. That
-  // call doesn't exist for redirects, so call preareRequest() here.
-  if (!redirectResponse.isNull()) {
-    prepareRequest(request);
-  } else {
+  if (redirectResponse.isNull()) {
+    // This is an initial requests, not for redirects.

[Nate Chapin, 2017/03/22 19:12:59]

This comment doesn't add much that the if() statement doesn't already state.
Maybe:
// Progress doesn't care about redirects, only notify it when an
// initial request is sent.
... or something like that?

[kinuko, 2017/03/23 05:12:17]

Sounds good, done.

     frame()->loader().progress().willStartLoading(identifier,
                                                   request.priority());
   }
   probe::willSendRequest(frame(), identifier, masterDocumentLoader(), request,
                          redirectResponse, initiatorInfo);
   if (frame()->frameScheduler())
     frame()->frameScheduler()->didStartLoading(identifier);
 }
 
 void FrameFetchContext::dispatchDidReceiveResponse(
@@ skipping 92 matching lines @@
 loadResourceTraceData(unsigned long identifier, const KURL& url, int priority) {
   String requestId = IdentifiersFactory::requestId(identifier);
 
   std::unique_ptr<TracedValue> value = TracedValue::create();
   value->setString("requestId", requestId);
   value->setString("url", url.getString());
   value->setInteger("priority", priority);
   return value;
 }
 
-void FrameFetchContext::willStartLoadingResource(
+void FrameFetchContext::recordLoadingActivity(
     unsigned long identifier,
-    ResourceRequest& request,
+    const ResourceRequest& request,
     Resource::Type type,
-    const AtomicString& fetchInitiatorName,
-    V8ActivityLoggingPolicy loggingPolicy) {
+    const AtomicString& fetchInitiatorName) {
   TRACE_EVENT_ASYNC_BEGIN1(
       "blink.net", "Resource", identifier, "data",
       loadResourceTraceData(identifier, request.url(), request.priority()));
-  prepareRequest(request);
-
   if (!m_documentLoader || m_documentLoader->fetcher()->archive() ||
       !request.url().isValid())
     return;
-  if (type == Resource::MainResource) {
-    m_documentLoader->applicationCacheHost()->willStartLoadingMainResource(
-        request);
+  V8DOMActivityLogger* activityLogger = nullptr;
+  if (fetchInitiatorName == FetchInitiatorTypeNames::xmlhttprequest) {
+    activityLogger = V8DOMActivityLogger::currentActivityLogger();
   } else {
-    m_documentLoader->applicationCacheHost()->willStartLoadingResource(request);
+    activityLogger =
+        V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
   }
-  if (loggingPolicy == V8ActivityLoggingPolicy::Log) {
-    V8DOMActivityLogger* activityLogger = nullptr;
-    if (fetchInitiatorName == FetchInitiatorTypeNames::xmlhttprequest) {
-      activityLogger = V8DOMActivityLogger::currentActivityLogger();
-    } else {
-      activityLogger =
-          V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
-    }
 
-    if (activityLogger) {
-      Vector<String> argv;
-      argv.push_back(Resource::resourceTypeToString(type, fetchInitiatorName));
-      argv.push_back(request.url());
-      activityLogger->logEvent("blinkRequestResource", argv.size(),
-                               argv.data());
-    }
+  if (activityLogger) {
+    Vector<String> argv;
+    argv.push_back(Resource::resourceTypeToString(type, fetchInitiatorName));
+    argv.push_back(request.url());
+    activityLogger->logEvent("blinkRequestResource", argv.size(), argv.data());
   }
 }
 
 void FrameFetchContext::didLoadResource(Resource* resource) {
   if (resource->isLoadEventBlockingResourceType())
     frame()->loader().checkCompleted();
   if (m_document)
     FirstMeaningfulPaintDetector::from(*m_document).checkNetworkStable();
 }
 
@@ skipping 452 matching lines @@
                                                     response);
 }
 
 DEFINE_TRACE(FrameFetchContext) {
   visitor->trace(m_document);
   visitor->trace(m_documentLoader);
   FetchContext::trace(visitor);
 }
 
 }  // namespace blink