Introduce ResourceRequesterInfo to abstract the requester of resource request

content/browser/service_worker/link_header_support.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 "content/browser/service_worker/link_header_support.h"
 
 #include "base/command_line.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "components/link_header_util/link_header_util.h"
@@ skipping 16 matching lines @@
 
 namespace {
 
 void RegisterServiceWorkerFinished(int64_t trace_id, bool result) {
   TRACE_EVENT_ASYNC_END1("ServiceWorker",
                          "LinkHeaderResourceThrottle::HandleServiceWorkerLink",
                          trace_id, "Success", result);
 }
 
 void HandleServiceWorkerLink(
-    const net::URLRequest* request,
+    net::URLRequest* request,
     const std::string& url,
     const std::unordered_map<std::string, base::Optional<std::string>>& params,
     ServiceWorkerContextWrapper* service_worker_context_for_testing) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableExperimentalWebPlatformFeatures) &&
       !TrialTokenValidator::RequestEnablesFeature(request, "ForeignFetch")) {
     // TODO(mek): Log attempt to use without having correct token?
     return;
   }
 
   if (ContainsKey(params, "anchor"))
     return;
 
-  const ResourceRequestInfoImpl* request_info =
+  ResourceRequestInfoImpl* request_info =
       ResourceRequestInfoImpl::ForRequest(request);
-  ResourceMessageFilter* filter = request_info->filter();
   ServiceWorkerContext* service_worker_context =
-      filter ? filter->service_worker_context()
-             : service_worker_context_for_testing;
-  if (IsBrowserSideNavigationEnabled() &&
-      ServiceWorkerUtils::IsMainResourceType(request_info->GetResourceType()) &&
-      !service_worker_context) {
-    service_worker_context = request_info->service_worker_context();
-  }
+      service_worker_context_for_testing
+          ? service_worker_context_for_testing
+          : request_info->requester_info().service_worker_context();
 
   if (!service_worker_context)
     return;
 
   ServiceWorkerProviderHost* provider_host =
       ServiceWorkerRequestHandler::GetProviderHost(request);
 
   // If fetched from a service worker, make sure fetching service worker is
   // controlling at least one client to prevent a service worker from spawning
   // new service workers in the background.
@@ skipping 52 matching lines @@
   static int64_t trace_id = 0;
   TRACE_EVENT_ASYNC_BEGIN2(
       "ServiceWorker", "LinkHeaderResourceThrottle::HandleServiceWorkerLink",
       ++trace_id, "Pattern", scope_url.spec(), "Script URL", script_url.spec());
   service_worker_context->RegisterServiceWorker(
       scope_url, script_url,
       base::Bind(&RegisterServiceWorkerFinished, trace_id));
 }
 
 void ProcessLinkHeaderValueForRequest(
-    const net::URLRequest* request,
+    net::URLRequest* request,
     std::string::const_iterator value_begin,
     std::string::const_iterator value_end,
     ServiceWorkerContextWrapper* service_worker_context_for_testing) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   std::string url;
   std::unordered_map<std::string, base::Optional<std::string>> params;
   if (!link_header_util::ParseLinkHeaderValue(value_begin, value_end, &url,
                                               &params))
     return;
 
   auto rel_param = params.find("rel");
   if (rel_param == params.end() || !rel_param->second)
     return;
   for (const auto& rel : base::SplitStringPiece(rel_param->second.value(),
                                                 HTTP_LWS, base::TRIM_WHITESPACE,
                                                 base::SPLIT_WANT_NONEMPTY)) {
     if (base::EqualsCaseInsensitiveASCII(rel, "serviceworker"))
       HandleServiceWorkerLink(request, url, params,
                               service_worker_context_for_testing);
   }
 }
 
 }  // namespace
 
-void ProcessRequestForLinkHeaders(const net::URLRequest* request) {
+void ProcessRequestForLinkHeaders(net::URLRequest* request) {
   std::string link_header;
   request->GetResponseHeaderByName("link", &link_header);
   if (link_header.empty())
     return;
 
   ProcessLinkHeaderForRequest(request, link_header);
 }
 
 void ProcessLinkHeaderForRequest(
-    const net::URLRequest* request,
+    net::URLRequest* request,
     const std::string& link_header,
     ServiceWorkerContextWrapper* service_worker_context_for_testing) {
   for (const auto& value : link_header_util::SplitLinkHeader(link_header)) {
     ProcessLinkHeaderValueForRequest(request, value.first, value.second,
                                      service_worker_context_for_testing);
   }
 }
 
 }  // namespace content