content::ResourceDispatcherHostImpl changes for stale-while-revalidate

content/browser/loader/resource_dispatcher_host_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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
+#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/stl_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/time/time.h"
 #include "content/browser/appcache/appcache_interceptor.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/cert_store_impl.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/download/download_resource_handler.h"
 #include "content/browser/download/save_file_manager.h"
 #include "content/browser/download/save_file_resource_handler.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/frame_host/navigation_request_info.h"
 #include "content/browser/frame_host/navigator.h"
 #include "content/browser/loader/async_resource_handler.h"
 #include "content/browser/loader/buffered_resource_handler.h"
 #include "content/browser/loader/cross_site_resource_handler.h"
 #include "content/browser/loader/detachable_resource_handler.h"
 #include "content/browser/loader/navigation_resource_handler.h"
 #include "content/browser/loader/navigation_url_loader_impl_core.h"
+#include "content/browser/loader/null_resource_handler.h"
 #include "content/browser/loader/power_save_block_resource_throttle.h"
 #include "content/browser/loader/redirect_to_file_resource_handler.h"
 #include "content/browser/loader/resource_message_filter.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/browser/loader/stream_resource_handler.h"
 #include "content/browser/loader/sync_resource_handler.h"
 #include "content/browser/loader/throttling_resource_handler.h"
 #include "content/browser/loader/upload_data_stream_builder.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
@@ skipping 28 matching lines @@
 #include "net/base/load_flags.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/base/request_priority.h"
 #include "net/base/upload_data_stream.h"
 #include "net/cert/cert_status_flags.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
+#include "net/http/http_transaction_factory.h"
+#include "net/http/http_util.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_job_factory.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/blob/blob_url_request_job_factory.h"
 #include "storage/browser/blob/shareable_file_reference.h"
 #include "storage/browser/fileapi/file_permission_policy.h"
 #include "storage/browser/fileapi/file_system_context.h"
@@ skipping 307 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RenderFrameHostImpl* host =
       RenderFrameHostImpl::FromID(render_process_id, render_frame_id);
   if (host != NULL) {
     DCHECK(host->frame_tree_node()->IsMainFrame());
     host->frame_tree_node()->navigator()->LogResourceRequestTime(
         timestamp, url);
   }
 }
 
+bool QualifiesForAsyncRevalidation(const ResourceHostMsg_Request& request) {
+  if (request.load_flags &
+      (net::LOAD_BYPASS_CACHE | net::LOAD_DISABLE_CACHE |
+       net::LOAD_VALIDATE_CACHE | net::LOAD_PREFERRING_CACHE |
+       net::LOAD_ONLY_FROM_CACHE)) {
+    return false;
+  }
+  if (request.method != "GET")
+    return false;
+  // A GET request should not have a body, but don't leave it to chance.
+  if (request.request_body.get())
+    return false;
+  if (!request.url.SchemeIsHTTPOrHTTPS())
+    return false;
+  return true;
+}
+
+std::pair<net::HttpCache*, std::string> AsyncRevalidationKey(

[tyoshino (SeeGerritForStatus), 2015/06/15 09:30:39]

how about GetAsyncRevalidationKeyFor?

or Create...?

[Adam Rice, 2015/06/15 11:36:20]

I chose GenerateAsyncRevalidationKeyFor() to be like 
net::HttpCache::GenerateCacheKey().

+    net::HttpTransactionFactory* http_transaction_factory,
+    const GURL& url) {
+  net::HttpCache* http_cache = http_transaction_factory->GetCache();
+  std::string url_key = net::HttpUtil::SpecForRequest(url);
+  return std::make_pair(http_cache, url_key);
+}
+
 }  // namespace
 
 // static
 ResourceDispatcherHost* ResourceDispatcherHost::Get() {
   return g_resource_dispatcher_host;
 }
 
 ResourceDispatcherHostImpl::ResourceDispatcherHostImpl()
     : save_file_manager_(new SaveFileManager()),
       request_id_(-1),
       is_shutdown_(false),
       num_in_flight_requests_(0),
       max_num_in_flight_requests_(base::SharedMemory::GetHandleLimit()),
-      max_num_in_flight_requests_per_process_(
-          static_cast<int>(
-              max_num_in_flight_requests_ * kMaxRequestsPerProcessRatio)),
+      max_num_in_flight_requests_per_process_(static_cast<int>(
+          max_num_in_flight_requests_ * kMaxRequestsPerProcessRatio)),
       max_outstanding_requests_cost_per_process_(
           kMaxOutstandingRequestsCostPerProcess),
       filter_(NULL),
       delegate_(NULL),
-      allow_cross_origin_auth_prompt_(false) {
+      allow_cross_origin_auth_prompt_(false),
+      async_revalidation_enabled_(false) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!g_resource_dispatcher_host);
   g_resource_dispatcher_host = this;
 
   GetContentClient()->browser()->ResourceDispatcherHostCreated();
 
   ANNOTATE_BENIGN_RACE(
       &last_user_gesture_time_,
       "We don't care about the precise value, see http://crbug.com/92889");
 
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&ResourceDispatcherHostImpl::OnInit,
                                      base::Unretained(this)));
 
   update_load_states_timer_.reset(
       new base::RepeatingTimer<ResourceDispatcherHostImpl>());
+
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  if (base::FieldTrialList::FindFullName("StaleWhileRevalidate") == "Enabled" ||
+      command_line->HasSwitch(switches::kEnableStaleWhileRevalidate)) {
+    async_revalidation_enabled_ = true;
+  }
 }
 
 ResourceDispatcherHostImpl::~ResourceDispatcherHostImpl() {
   DCHECK(outstanding_requests_stats_map_.empty());
   DCHECK(g_resource_dispatcher_host);
   g_resource_dispatcher_host = NULL;
 }
 
 // static
 ResourceDispatcherHostImpl* ResourceDispatcherHostImpl::Get() {
@@ skipping 345 matching lines @@
       new_url));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &NotifyRedirectOnUI,
           render_process_id, render_frame_host, base::Passed(&detail)));
 }
 
 void ResourceDispatcherHostImpl::DidReceiveResponse(ResourceLoader* loader) {
   ResourceRequestInfoImpl* info = loader->GetRequestInfo();
-
-  if (loader->request()->was_fetched_via_proxy() &&
-      loader->request()->was_fetched_via_spdy() &&
-      loader->request()->url().SchemeIs(url::kHttpScheme)) {
+  net::URLRequest* request = loader->request();
+  if (request->was_fetched_via_proxy() &&
+      request->was_fetched_via_spdy() &&
+      request->url().SchemeIs(url::kHttpScheme)) {
     scheduler_->OnReceivedSpdyProxiedHttpResponse(
         info->GetChildID(), info->GetRouteID());
   }
 
+  if (request->response_info().async_revalidation_required)
+    BeginAsyncRevalidation(request);
+
   int render_process_id, render_frame_host;
   if (!info->GetAssociatedRenderFrame(&render_process_id, &render_frame_host))
     return;
 
   // Notify the observers on the UI thread.
   scoped_ptr<ResourceRequestDetails> detail(new ResourceRequestDetails(
-      loader->request(),
-      GetCertID(loader->request(), info->GetChildID())));
+      request,
+      GetCertID(request, info->GetChildID())));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &NotifyResponseOnUI,
           render_process_id, render_frame_host, base::Passed(&detail)));
 }
 
 void ResourceDispatcherHostImpl::DidFinishLoading(ResourceLoader* loader) {
   ResourceRequestInfo* info = loader->GetRequestInfo();
 
@@ skipping 331 matching lines @@
   }
 
   // Allow the observer to block/handle the request.
   if (delegate_ && !delegate_->ShouldBeginRequest(request_data.method,
                                                   request_data.url,
                                                   request_data.resource_type,
                                                   resource_context)) {
     AbortRequestBeforeItStarts(filter_, sync_result, request_id);
     return;
   }
+  bool is_async_revalidation = false;
+  BeginRequestFromData(request_id, request_data, sync_result, process_type,
+                       child_id, route_id, is_async_revalidation,
+                       request_context, resource_context);
+}
 
+void ResourceDispatcherHostImpl::BeginRequestFromData(
+    int request_id,
+    const ResourceHostMsg_Request& request_data,
+    IPC::Message* sync_result,
+    int process_type,
+    int child_id,
+    int route_id,
+    bool is_async_revalidation,
+    net::URLRequestContext* request_context,
+    ResourceContext* resource_context) {
   // Construct the request.
   scoped_ptr<net::URLRequest> new_request;
   new_request = request_context->CreateRequest(
       request_data.url, request_data.priority, NULL);
 
   new_request->set_method(request_data.method);
   new_request->set_first_party_for_cookies(
       request_data.first_party_for_cookies);
 
   // If the request is a MAIN_FRAME request, the first-party URL gets updated on
@@ skipping 52 matching lines @@
     // Only block image loads, as the attack applies largely to the "src"
     // property of the <img> tag. It is common for web properties to allow
     // untrusted values for <img src>; this is considered a fair thing for an
     // HTML sanitizer to do. Conversely, any HTML sanitizer that didn't
     // filter sources for <script>, <link>, <embed>, <object>, <iframe> tags
     // would be considered vulnerable in and of itself.
     do_not_prompt_for_login = true;
     load_flags |= net::LOAD_DO_NOT_USE_EMBEDDED_IDENTITY;
   }
 
+  // Check if request is eligible for async revalidation.
+  bool support_async_revalidation =
+      (async_revalidation_enabled_ && !is_sync_load && !is_async_revalidation &&
+       QualifiesForAsyncRevalidation(request_data));

[tyoshino (SeeGerritForStatus), 2015/06/15 09:30:39]

Could you please move "!is_async_revalidation" to the head of this condition to
make it easier to know that this flag won't set when this method is called for
async revalidation?

The name "support_async_revalidation" looked a bit confusing when I saw it in
checking the call path from BeginAsyncRevalidation().

I tried to rename it to something else so that it's clear that this is set only
when this is not a BeginRequestFromData() call for BeginAsyncRevalidation. But
couldn't. So, I'd request only order change in this line.

[Adam Rice, 2015/06/15 11:36:20]

Done.

+  if (support_async_revalidation)
+    load_flags |= net::LOAD_SUPPORT_ASYNC_REVALIDATION;
+
   // Sync loads should have maximum priority and should be the only
   // requets that have the ignore limits flag set.
   if (is_sync_load) {
     DCHECK_EQ(request_data.priority, net::MAXIMUM_PRIORITY);
     DCHECK_NE(load_flags & net::LOAD_IGNORE_LIMITS, 0);
   } else {
     DCHECK_EQ(load_flags & net::LOAD_IGNORE_LIMITS, 0);
   }
   new_request->SetLoadFlags(load_flags);
 
@@ skipping 13 matching lines @@
       false,  // is download
       false,  // is stream
       allow_download,
       request_data.has_user_gesture,
       request_data.enable_load_timing,
       request_data.enable_upload_progress,
       do_not_prompt_for_login,
       request_data.referrer_policy,
       request_data.visiblity_state,
       resource_context, filter_->GetWeakPtr(),
-      !is_sync_load);
+      !is_sync_load,
+      is_async_revalidation,
+      support_async_revalidation ? &request_data : NULL);
   // Request takes ownership.
   extra_info->AssociateWithRequest(new_request.get());
 
   if (new_request->url().SchemeIs(url::kBlobScheme)) {
     // Hang on to a reference to ensure the blob is not released prior
     // to the job being started.
     storage::BlobProtocolHandler::SetRequestedBlobDataHandle(
         new_request.get(),
         filter_->blob_storage_context()->context()->GetBlobDataFromPublicURL(
             new_request->url()));
@@ skipping 14 matching lines @@
       request_data.fetch_request_context_type,
       request_data.fetch_frame_type,
       request_data.request_body);
 
   // Have the appcache associate its extra info with the request.
   AppCacheInterceptor::SetExtraRequestInfo(
       new_request.get(), filter_->appcache_service(), child_id,
       request_data.appcache_host_id, request_data.resource_type,
       request_data.should_reset_appcache);
 
-  scoped_ptr<ResourceHandler> handler(
-       CreateResourceHandler(
-           new_request.get(),
-           request_data, sync_result, route_id, process_type, child_id,
-           resource_context));
+  scoped_ptr<ResourceHandler> handler(CreateResourceHandler(
+      new_request.get(), request_data, sync_result, route_id, process_type,
+      child_id, is_async_revalidation, resource_context));
 
   if (handler)
     BeginRequestInternal(new_request.Pass(), handler.Pass());
 }
 
 scoped_ptr<ResourceHandler> ResourceDispatcherHostImpl::CreateResourceHandler(
     net::URLRequest* request,
     const ResourceHostMsg_Request& request_data,
     IPC::Message* sync_result,
     int route_id,
     int process_type,
     int child_id,
+    bool is_async_revalidation,
     ResourceContext* resource_context) {
   // TODO(pkasting): Remove ScopedTracker below once crbug.com/456331 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "456331 ResourceDispatcherHostImpl::CreateResourceHandler"));
   // Construct the IPC resource handler.
   scoped_ptr<ResourceHandler> handler;
   if (sync_result) {
     // download_to_file is not supported for synchronous requests.
     if (request_data.download_to_file) {
       RecordAction(base::UserMetricsAction("BadMessageTerminate_RDH"));
       filter_->BadMessageReceived();
       return scoped_ptr<ResourceHandler>();
     }
 
     handler.reset(new SyncResourceHandler(request, sync_result, this));
+  } else if (is_async_revalidation) {
+    handler.reset(new NullResourceHandler(
+        request, this, base::TimeDelta::FromSeconds(
+                           kNullResourceHandlerDefaultReadTimeoutSecs)));
   } else {
     handler.reset(new AsyncResourceHandler(request, this));
 
     // The RedirectToFileResourceHandler depends on being next in the chain.
     if (request_data.download_to_file) {
       handler.reset(
           new RedirectToFileResourceHandler(handler.Pass(), request));
     }
   }
 
@@ skipping 20 matching lines @@
     if (!is_swappable_navigation &&
         base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kSitePerProcess)) {
       is_swappable_navigation =
           request_data.resource_type == RESOURCE_TYPE_SUB_FRAME;
     }
     if (is_swappable_navigation && process_type == PROCESS_TYPE_RENDERER)
       handler.reset(new CrossSiteResourceHandler(handler.Pass(), request));
   }
 
-  return AddStandardHandlers(request, request_data.resource_type,
-                             resource_context, filter_->appcache_service(),
-                             child_id, route_id, handler.Pass());
+  // The BufferedResourceHandler performs mime-type sniffing and redirecting of
+  // downloads and plugin-handled content. The first we don't need for an
+  // async_revalidation, and the second is dangerous.
+  if (!is_async_revalidation) {
+    handler = AddBufferedResourceHandler(request, handler.Pass());
+  }
+
+  return AddThrottlesAndSchedule(request, request_data.resource_type,
+                                 resource_context, filter_->appcache_service(),
+                                 child_id, route_id, handler.Pass());
 }
 
-scoped_ptr<ResourceHandler> ResourceDispatcherHostImpl::AddStandardHandlers(
+scoped_ptr<ResourceHandler>
+ResourceDispatcherHostImpl::AddBufferedResourceHandler(
+    net::URLRequest* request,
+    scoped_ptr<ResourceHandler> handler) {
+  PluginService* plugin_service = nullptr;
+#if defined(ENABLE_PLUGINS)
+  plugin_service = PluginService::GetInstance();
+#endif
+  // Insert a buffered event handler before the actual one.
+  return make_scoped_ptr(new BufferedResourceHandler(handler.Pass(), this,
+                                                     plugin_service, request));
+}
+
+scoped_ptr<ResourceHandler> ResourceDispatcherHostImpl::AddThrottlesAndSchedule(
     net::URLRequest* request,
     ResourceType resource_type,
     ResourceContext* resource_context,
     AppCacheService* appcache_service,
     int child_id,
     int route_id,
     scoped_ptr<ResourceHandler> handler) {
-
-  PluginService* plugin_service = nullptr;
-#if defined(ENABLE_PLUGINS)
-  plugin_service = PluginService::GetInstance();
-#endif
-  // Insert a buffered event handler before the actual one.
-  handler.reset(
-      new BufferedResourceHandler(
-          handler.Pass(), this, plugin_service, request));
-
   ScopedVector<ResourceThrottle> throttles;
   if (delegate_) {
     delegate_->RequestBeginning(request,
                                 resource_context,
                                 appcache_service,
                                 resource_type,
                                 &throttles);
   }
 
   if (request->has_upload()) {
@@ skipping 110 matching lines @@
       false,     // is_stream
       download,  // allow_download
       false,     // has_user_gesture
       false,     // enable_load_timing
       false,     // enable_upload_progress
       false,     // do_not_prompt_for_login
       blink::WebReferrerPolicyDefault,
       blink::WebPageVisibilityStateVisible,
       context,
       base::WeakPtr<ResourceMessageFilter>(),  // filter
-      true);                                   // is_async
+      true,                                    // is_async
+      false,                                   // is_async_revalidation
+      NULL);                                   // original_message

[tyoshino (SeeGerritForStatus), 2015/06/15 09:30:39]

original_request

[Adam Rice, 2015/06/15 11:36:20]

Done.

 }
 
 void ResourceDispatcherHostImpl::OnRenderViewHostCreated(int child_id,
                                                          int route_id,
                                                          bool is_visible,
                                                          bool is_audible) {
   scheduler_->OnClientCreated(child_id, route_id, is_visible, is_audible);
 }
 
 void ResourceDispatcherHostImpl::OnRenderViewHostDeleted(
@@ skipping 130 matching lines @@
 
     ResourceRequestInfoImpl* info = i->second->GetRequestInfo();
 
     GlobalRequestID id(child_id, i->first.request_id);
     DCHECK(id == i->first);
     // Don't cancel navigations that are expected to live beyond this process.
     if (IsTransferredNavigation(id))
       any_requests_transferring = true;
     if (info->detachable_handler()) {
       info->detachable_handler()->Detach();
-    } else if (!info->IsDownload() && !info->is_stream() &&
+    } else if (!info->IsDownload() &&
+               !info->is_stream() && !info->IsAsyncRevalidation() &&
                !IsTransferredNavigation(id) &&
                (route_id == -1 || route_id == info->GetRouteID())) {
       matching_requests.push_back(id);
     }
   }
 
   // Remove matches.
   for (size_t i = 0; i < matching_requests.size(); ++i) {
     LoaderMap::iterator iter = pending_loaders_.find(matching_requests[i]);
     // Although every matching request was in pending_requests_ when we built
@@ skipping 49 matching lines @@
   if (i == pending_loaders_.end()) {
     NOTREACHED() << "Trying to remove a request that's not here";
     return;
   }
   RemovePendingLoader(i);
 }
 
 void ResourceDispatcherHostImpl::RemovePendingLoader(
     const LoaderMap::iterator& iter) {
   ResourceRequestInfoImpl* info = iter->second->GetRequestInfo();
+  if (info->IsAsyncRevalidation()) {
+    net::URLRequest* request = iter->second->request();
+    auto async_revalidation_key =
+        AsyncRevalidationKey(request->context()->http_transaction_factory(),
+                             request->original_url());
+    bool erased =
+        in_progress_async_revalidations_.erase(async_revalidation_key);
+    DCHECK(erased);
+  }
 
   // Remove the memory credit that we added when pushing the request onto
   // the pending list.
   IncrementOutstandingRequestsMemory(-1, *info);
 
   pending_loaders_.erase(iter);
 }
 
 void ResourceDispatcherHostImpl::CancelRequest(int child_id,
                                                int request_id) {
@@ skipping 205 matching lines @@
       true,   // enable_load_timing
       false,  // enable_upload_progress
       false,  // do_not_prompt_for_login
       info.common_params.referrer.policy,
       // TODO(davidben): This is only used for prerenders. Replace
       // is_showing with something for that. Or maybe it just comes from the
       // same mechanism as the cookie one.
       blink::WebPageVisibilityStateVisible,
       resource_context,
       base::WeakPtr<ResourceMessageFilter>(),  // filter
-      true);
+      true,                                    // is_async
+      false,                                   // is_async_revalidation
+      NULL);                                   // original_message
   // Request takes ownership.
   extra_info->AssociateWithRequest(new_request.get());
 
   if (new_request->url().SchemeIs(url::kBlobScheme)) {
     // Hang on to a reference to ensure the blob is not released prior
     // to the job being started.
     ChromeBlobStorageContext* blob_context =
         GetChromeBlobStorageContextForResourceContext(resource_context);
     storage::BlobProtocolHandler::SetRequestedBlobDataHandle(
         new_request.get(),
         blob_context->context()->GetBlobDataFromPublicURL(new_request->url()));
   }
 
   // TODO(davidben): Attach ServiceWorkerRequestHandler.
   // TODO(michaeln): Help out with this and that.
   // TODO(davidben): Attach AppCacheInterceptor.
 
   scoped_ptr<ResourceHandler> handler(new NavigationResourceHandler(
       new_request.get(), loader));
 
   // TODO(davidben): Pass in the appropriate appcache_service. Also fix the
   // dependency on child_id/route_id. Those are used by the ResourceScheduler;
   // currently it's a no-op.
-  handler = AddStandardHandlers(new_request.get(), resource_type,
-                                resource_context,
-                                nullptr,  // appcache_service
-                                -1,  // child_id
-                                -1,  // route_id
-                                handler.Pass());
+  handler = AddThrottlesAndSchedule(
+      new_request.get(), resource_type, resource_context,
+      nullptr,  // appcache_service
+      -1,       // child_id
+      -1,       // route_id
+      AddBufferedResourceHandler(new_request.get(), handler.Pass()));
 
   BeginRequestInternal(new_request.Pass(), handler.Pass());
 }
 
 // static
 int ResourceDispatcherHostImpl::CalculateApproximateMemoryCost(
     net::URLRequest* request) {
   // The following fields should be a minor size contribution (experimentally
   // on the order of 100). However since they are variable length, it could
   // in theory be a sizeable contribution.
@@ skipping 323 matching lines @@
   }
 
   // Add a flag to selectively bypass the data reduction proxy if the resource
   // type is not an image.
   if (request_data.resource_type != RESOURCE_TYPE_IMAGE)
     load_flags |= net::LOAD_BYPASS_DATA_REDUCTION_PROXY;
 
   return load_flags;
 }
 
+void ResourceDispatcherHostImpl::BeginAsyncRevalidation(
+    net::URLRequest* for_request) {
+  ResourceRequestInfoImpl* info =
+      ResourceRequestInfoImpl::ForRequest(for_request);
+  DCHECK(info);
+  DCHECK(!info->IsAsyncRevalidation());
+  ResourceHostMsg_Request* original_request_data = info->original_request();
+  DCHECK(original_request_data);
+
+  ResourceHostMsg_Request new_request_data = *original_request_data;
+  new_request_data.do_not_prompt_for_login = true;
+  new_request_data.allow_download = false;
+  new_request_data.enable_load_timing = false;
+  new_request_data.download_to_file = false;
+  new_request_data.transferred_request_child_id = -1;
+  new_request_data.transferred_request_request_id = -1;
+  new_request_data.priority = net::MINIMUM_PRIORITY;
+
+  int process_type = PROCESS_TYPE_BROWSER;
+  int child_id = info->GetChildID();
+  int route_id = info->GetRouteID();
+  int request_id = --request_id_;
+  bool is_async_revalidation = true;
+
+  ResourceContext* resource_context = NULL;
+  net::URLRequestContext* request_context = NULL;
+  // TODO(ricea): How can we ensure that resource_context and request_context
+  // live long enough to service the request?
+  info->filter()->GetContexts(new_request_data, &resource_context,
+                              &request_context);
+  if (is_shutdown_ || (delegate_ &&
+                       !delegate_->ShouldBeginRequest(
+                           new_request_data.method, new_request_data.url,
+                           new_request_data.resource_type, resource_context))) {
+    return;
+  }
+
+  auto async_revalidation_key = AsyncRevalidationKey(
+      request_context->http_transaction_factory(), original_request_data->url);
+  if (!in_progress_async_revalidations_.insert(async_revalidation_key).second) {
+    // A matching async revalidation is already in progress for this cache; we
+    // don't need another one.
+    return;
+  }
+  CHECK(ContainsKey(active_resource_contexts_, resource_context));
+
+  // TODO(ricea): Make filter_ be passed around in a sane way.
+  filter_ = info->filter();
+  BeginRequestFromData(request_id, new_request_data, NULL, process_type,
+                       child_id, route_id, is_async_revalidation,

[tyoshino (SeeGerritForStatus), 2015/06/15 09:30:39]

Do the similar as L2090?

I.e.

true,  // is_async_revalidation

[Adam Rice, 2015/06/15 11:36:20]

Done.

+                       request_context, resource_context);
+  filter_ = NULL;
+}
+
 }  // namespace content