Introduce ResourceRequesterInfo to abstract the requester of resource request

content/browser/loader/async_revalidation_manager.cc

 // Copyright 2015 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/loader/async_revalidation_manager.h"
 
 #include <tuple>
 #include <utility>
 
 #include "base/logging.h"
 #include "content/browser/loader/async_revalidation_driver.h"
-#include "content/browser/loader/resource_message_filter.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/browser/loader/resource_scheduler.h"
 #include "content/common/resource_messages.h"
 #include "content/common/resource_request.h"
 #include "content/public/browser/resource_throttle.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
@@ skipping 22 matching lines @@
          std::tie(rhs.resource_context, rhs.http_cache, rhs.url_key);
 }
 
 AsyncRevalidationManager::AsyncRevalidationManager() {}
 
 AsyncRevalidationManager::~AsyncRevalidationManager() {
   DCHECK(in_progress_.empty());
 }
 
 void AsyncRevalidationManager::BeginAsyncRevalidation(
-    const net::URLRequest& for_request,
+    net::URLRequest* for_request,
     ResourceScheduler* scheduler) {
-  DCHECK_EQ(for_request.url_chain().size(), 1u);
-  const ResourceRequestInfoImpl* info =
-      ResourceRequestInfoImpl::ForRequest(&for_request);
+  DCHECK_EQ(for_request->url_chain().size(), 1u);
+  ResourceRequestInfoImpl* info =
+      ResourceRequestInfoImpl::ForRequest(for_request);
   DCHECK(info);
-  if (!info->filter()) {
+  DCHECK(info->requester_info()->IsRenderer());
+  if (!info->requester_info()->filter()) {
     // The child has gone away and we can no longer get ResourceContext and
     // URLRequestContext to perform async revalidation.
     // This can happen in the following cases, ordered from bad to not-so-bad
     //
     // 1. PlzNavigate (but enabling PlzNavigate automatically disables
     //    stale-while-revalidate; see crbug.com/561609)
     // 2. <link rel=prefetch> may read a stale cache entry without a
     //    revalidation being performed if the original renderer goes away. This
     //    is a lost optimisation opportunity.
     //
@@ skipping 10 matching lines @@
     //
     // TODO(ricea): Resolve these lifetime issues. crbug.com/561591
     return;
   }
 
   ResourceContext* resource_context = nullptr;
   net::URLRequestContext* request_context = nullptr;
 
   // The embedder of //content needs to ensure that the URLRequestContext object
   // remains valid until after the ResourceContext object is destroyed.
-  info->filter()->GetContexts(info->GetResourceType(), &resource_context,
-                              &request_context);
+  info->requester_info()->GetContexts(info->GetResourceType(),
+                                      &resource_context, &request_context);
 
   AsyncRevalidationKey async_revalidation_key(
       resource_context, request_context->http_transaction_factory()->GetCache(),
-      for_request.url());
+      for_request->url());
   std::pair<AsyncRevalidationMap::iterator, bool> insert_result =
       in_progress_.insert(AsyncRevalidationMap::value_type(
           async_revalidation_key, std::unique_ptr<AsyncRevalidationDriver>()));
   if (!insert_result.second) {
     // A matching async revalidation is already in progress for this cache; we
     // don't need another one.
     return;
   }
 
   net::HttpRequestHeaders headers;
   headers.AddHeadersFromString(info->original_headers());
 
   // Construct the request.
-  std::unique_ptr<net::URLRequest> new_request = request_context->CreateRequest(
-      for_request.url(), net::IDLE, nullptr);
+  std::unique_ptr<net::URLRequest> new_request =
+      request_context->CreateRequest(for_request->url(), net::IDLE, nullptr);
 
-  new_request->set_method(for_request.method());
+  new_request->set_method(for_request->method());
   new_request->set_first_party_for_cookies(
-      for_request.first_party_for_cookies());
-  new_request->set_initiator(for_request.initiator());
-  new_request->set_first_party_url_policy(for_request.first_party_url_policy());
+      for_request->first_party_for_cookies());
+  new_request->set_initiator(for_request->initiator());
+  new_request->set_first_party_url_policy(
+      for_request->first_party_url_policy());
 
-  new_request->SetReferrer(for_request.referrer());
-  new_request->set_referrer_policy(for_request.referrer_policy());
+  new_request->SetReferrer(for_request->referrer());
+  new_request->set_referrer_policy(for_request->referrer_policy());
 
   new_request->SetExtraRequestHeaders(headers);
 
   // Remove LOAD_SUPPORT_ASYNC_REVALIDATION and LOAD_MAIN_FRAME_DEPRECATED
   // flags.
   // Also remove things which shouldn't have been there to begin with,
   // and unrecognised flags.
   int load_flags =
-      for_request.load_flags() &
+      for_request->load_flags() &
       (net::LOAD_DO_NOT_SAVE_COOKIES | net::LOAD_BYPASS_PROXY |
        net::LOAD_VERIFY_EV_CERT | net::LOAD_DO_NOT_SEND_COOKIES |
        net::LOAD_DO_NOT_SEND_AUTH_DATA | net::LOAD_MAYBE_USER_GESTURE |
        net::LOAD_DO_NOT_USE_EMBEDDED_IDENTITY);
   new_request->SetLoadFlags(load_flags);
 
   // These values would be -1 if the request was created by PlzNavigate. This
   // would cause the async revalidation to start immediately.
   // stale-while-revalidate is disabled when PlzNavigate is enabled
   // to prevent this and other issues. See crbug.com/561610.
@@ skipping 43 matching lines @@
 
   return true;
 }
 
 void AsyncRevalidationManager::OnAsyncRevalidationComplete(
     AsyncRevalidationMap::iterator it) {
   in_progress_.erase(it);
 }
 
 }  // namespace content