content::ResourceDispatcherHostImpl changes for stale-while-revalidate

content/browser/loader/resource_request_info_impl.cc

 // Copyright (c) 2012 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/resource_request_info_impl.h"
 
 #include "content/browser/loader/global_routing_id.h"
 #include "content/browser/loader/resource_message_filter.h"
 #include "content/common/net/url_request_user_data.h"
+#include "content/common/resource_messages.h"
 #include "content/public/browser/global_request_id.h"
 #include "content/public/common/process_type.h"
 #include "net/url_request/url_request.h"
 
 namespace content {
 
 // ----------------------------------------------------------------------------
 // ResourceRequestInfo
 
 // static
@@ skipping 14 matching lines @@
                                              bool allow_download,
                                              bool is_async) {
   // Make sure both |is_main_frame| and |parent_is_main_frame| aren't set at the
   // same time.
   DCHECK(!(is_main_frame && parent_is_main_frame));
 
   // Make sure RESOURCE_TYPE_MAIN_FRAME is declared as being fetched as part of
   // the main frame.
   DCHECK(resource_type != RESOURCE_TYPE_MAIN_FRAME || is_main_frame);
 
-  ResourceRequestInfoImpl* info =
-      new ResourceRequestInfoImpl(
-          PROCESS_TYPE_RENDERER,             // process_type
-          render_process_id,                 // child_id
-          render_view_id,                    // route_id
-          -1,                                // frame_tree_node_id
-          0,                                 // origin_pid
-          0,                                 // request_id
-          render_frame_id,                   // render_frame_id
-          is_main_frame,                     // is_main_frame
-          parent_is_main_frame,              // parent_is_main_frame
-          0,                                 // parent_render_frame_id
-          resource_type,                     // resource_type
-          ui::PAGE_TRANSITION_LINK,          // transition_type
-          false,                             // should_replace_current_entry
-          false,                             // is_download
-          false,                             // is_stream
-          allow_download,                    // allow_download
-          false,                             // has_user_gesture
-          false,                             // enable load timing
-          request->has_upload(),             // enable upload progress
-          false,                             // do_not_prompt_for_login
-          blink::WebReferrerPolicyDefault,   // referrer_policy
-          blink::WebPageVisibilityStateVisible,  // visibility_state
-          context,                           // context
-          base::WeakPtr<ResourceMessageFilter>(),  // filter
-          is_async);                         // is_async
+  ResourceRequestInfoImpl* info = new ResourceRequestInfoImpl(
+      PROCESS_TYPE_RENDERER,                   // process_type
+      render_process_id,                       // child_id
+      render_view_id,                          // route_id
+      -1,                                      // frame_tree_node_id
+      0,                                       // origin_pid
+      0,                                       // request_id
+      render_frame_id,                         // render_frame_id
+      is_main_frame,                           // is_main_frame
+      parent_is_main_frame,                    // parent_is_main_frame
+      0,                                       // parent_render_frame_id
+      resource_type,                           // resource_type
+      ui::PAGE_TRANSITION_LINK,                // transition_type
+      false,                                   // should_replace_current_entry
+      false,                                   // is_download
+      false,                                   // is_stream
+      allow_download,                          // allow_download
+      false,                                   // has_user_gesture
+      false,                                   // enable load timing
+      request->has_upload(),                   // enable upload progress
+      false,                                   // do_not_prompt_for_login
+      blink::WebReferrerPolicyDefault,         // referrer_policy
+      blink::WebPageVisibilityStateVisible,    // visibility_state
+      context,                                 // context
+      base::WeakPtr<ResourceMessageFilter>(),  // filter
+      is_async,                                // is_async
+      false,                                   // is_async_revalidation
+      NULL);                                   // original_request
   info->AssociateWithRequest(request);
 }
 
 // static
 bool ResourceRequestInfo::GetRenderFrameForRequest(
     const net::URLRequest* request,
     int* render_process_id,
     int* render_frame_id) {
   URLRequestUserData* user_data = static_cast<URLRequestUserData*>(
       request->GetUserData(URLRequestUserData::kUserDataKey));
@@ skipping 37 matching lines @@
     bool is_stream,
     bool allow_download,
     bool has_user_gesture,
     bool enable_load_timing,
     bool enable_upload_progress,
     bool do_not_prompt_for_login,
     blink::WebReferrerPolicy referrer_policy,
     blink::WebPageVisibilityState visibility_state,
     ResourceContext* context,
     base::WeakPtr<ResourceMessageFilter> filter,
-    bool is_async)
+    bool is_async,
+    bool is_async_revalidation,
+    const ResourceHostMsg_Request* original_request)
     : cross_site_handler_(NULL),
       detachable_handler_(NULL),
       process_type_(process_type),
       child_id_(child_id),
       route_id_(route_id),
       frame_tree_node_id_(frame_tree_node_id),
       origin_pid_(origin_pid),
       request_id_(request_id),
       render_frame_id_(render_frame_id),
       is_main_frame_(is_main_frame),
       parent_is_main_frame_(parent_is_main_frame),
       parent_render_frame_id_(parent_render_frame_id),
       should_replace_current_entry_(should_replace_current_entry),
       is_download_(is_download),
       is_stream_(is_stream),
       allow_download_(allow_download),
       has_user_gesture_(has_user_gesture),
       enable_load_timing_(enable_load_timing),
       enable_upload_progress_(enable_upload_progress),
       do_not_prompt_for_login_(do_not_prompt_for_login),
       was_ignored_by_handler_(false),
       counted_as_in_flight_request_(false),
       resource_type_(resource_type),
       transition_type_(transition_type),
       memory_cost_(0),
       referrer_policy_(referrer_policy),
       visibility_state_(visibility_state),
       context_(context),
       filter_(filter),
-      is_async_(is_async) {
+      is_async_(is_async),
+      is_async_revalidation_(is_async_revalidation) {
+  if (original_request) {
+    original_request_.reset(new ResourceHostMsg_Request(*original_request));

[tyoshino (SeeGerritForStatus), 2015/06/16 13:04:42]

write some analysis (maybe in the CL description?) about safety of this cloning.
The IPC protocol should have been designed assuming that there's only one code
that receives and handles this message. We should explain that it's ok to reuse
the values on it for another request (async revalidation).

[Adam Rice, 2015/06/17 10:05:15]

It's not an IPC::Message, it's just a struct, so there's no particular problem
with copying it. I've added an explanation of why we can copy it and a DCHECK
that the potentially dangerous |request_body| member is not set.

+  }
 }
 
 ResourceRequestInfoImpl::~ResourceRequestInfoImpl() {
 }
 
 ResourceContext* ResourceRequestInfoImpl::GetContext() const {
   return context_;
 }
 
 int ResourceRequestInfoImpl::GetChildID() const {
@@ skipping 67 matching lines @@
     *render_process_id = child_id_;
     *render_frame_id = render_frame_id_;
   }
   return true;
 }
 
 bool ResourceRequestInfoImpl::IsAsync() const {
   return is_async_;
 }
 
+bool ResourceRequestInfoImpl::IsAsyncRevalidation() const {
+  return is_async_revalidation_;
+}
+
 bool ResourceRequestInfoImpl::IsDownload() const {
   return is_download_;
 }
 
 void ResourceRequestInfoImpl::AssociateWithRequest(net::URLRequest* request) {
   request->SetUserData(NULL, this);
   int render_process_id;
   int render_frame_id;
   if (GetAssociatedRenderFrame(&render_process_id, &render_frame_id)) {
     request->SetUserData(
@@ skipping 19 matching lines @@
     base::WeakPtr<ResourceMessageFilter> filter) {
   child_id_ = child_id;
   route_id_ = route_id;
   origin_pid_ = origin_pid;
   request_id_ = request_id;
   parent_render_frame_id_ = parent_render_frame_id;
   filter_ = filter;
 }
 
 }  // namespace content