content::ResourceDispatcherHostImpl changes for stale-while-revalidate

content/browser/loader/async_revalidation_manager.cc

Index: content/browser/loader/async_revalidation_manager.cc
diff --git a/content/browser/loader/async_revalidation_manager.cc b/content/browser/loader/async_revalidation_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..337c7063cb2359e68e68294e2c439b95c77ae37b
--- /dev/null
+++ b/content/browser/loader/async_revalidation_manager.cc
@@ -0,0 +1,192 @@
+// 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/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"
+#include "url/gurl.h"
+
+namespace content {
+
+AsyncRevalidationManager::AsyncRevalidationKey::AsyncRevalidationKey(
+    const ResourceContext* resource_context,
+    const net::HttpCache* http_cache,
+    const GURL& url)
+    : resource_context(resource_context),
+      http_cache(http_cache),
+      url_key(net::HttpUtil::SpecForRequest(url)) {}
+
+AsyncRevalidationManager::AsyncRevalidationKey::AsyncRevalidationKey(
+    const ResourceContext* resource_context)
+    : resource_context(resource_context), http_cache(nullptr), url_key() {}
+
+AsyncRevalidationManager::AsyncRevalidationKey::~AsyncRevalidationKey() {}
+
+bool AsyncRevalidationManager::AsyncRevalidationKey::LessThan::operator()(
+    const AsyncRevalidationKey& lhs,
+    const AsyncRevalidationKey& rhs) const {
+  return std::tie(lhs.resource_context, lhs.http_cache, lhs.url_key) <
+         std::tie(rhs.resource_context, rhs.http_cache, rhs.url_key);
+}
+
+AsyncRevalidationManager::AsyncRevalidationManager() {}
+
+AsyncRevalidationManager::~AsyncRevalidationManager() {
+  DCHECK(in_progress_.empty());
+}
+
+void AsyncRevalidationManager::BeginAsyncRevalidation(
+    net::URLRequest* for_request,
+    ResourceScheduler* scheduler) {
+  DCHECK_EQ(for_request->url_chain().size(), 1u);
+  ResourceRequestInfoImpl* info =
+      ResourceRequestInfoImpl::ForRequest(for_request);
+  DCHECK(info);
+  if (!info->filter()) {
+    // The child has gone away. This is a problem because now we have no way to
+    // get a ResourceContext and URLRequestContext to do the AsyncRevalidation
+    // with.
+    // TODO(ricea): Resolve these lifetime issues. crbug.com/561591
+    return;
+  }
+
+  int child_id = info->GetChildID();
+  int route_id = info->GetRouteID();
+
+  // ResourceMessageFilter::GetContexts requires a ResourceHostMsg_Request
+  // object to be passed but only cares about the resource_type and origin_pid
+  // fields.
+  // TODO(ricea): Fix this after landing crrev.com/1481583002
+  ResourceHostMsg_Request dummy_resource_host_msg_request;
+  dummy_resource_host_msg_request.resource_type = info->GetResourceType();
+  dummy_resource_host_msg_request.origin_pid = info->GetOriginPID();
+  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(dummy_resource_host_msg_request,
+                              &resource_context, &request_context);
+
+  AsyncRevalidationKey async_revalidation_key(
+      resource_context, request_context->http_transaction_factory()->GetCache(),
+      for_request->url());
+  std::pair<AsyncRevalidationMap::iterator, bool> insert_result =
+      in_progress_.insert(AsyncRevalidationMap::value_type(
+          async_revalidation_key, scoped_ptr<AsyncRevalidationDriver>()));
+  if (!insert_result.second) {
+    // A matching async revalidation is already in progress for this cache; we
+    // don't need another one.
+    //
+    // Complication: If the server response included a Vary header
+    // which included request headers which differed between the requests, we
+    // could fail to send an async revalidation which strictly speaking we
+    // should have sent. However, since the cache only stores one response per
+    // URL it will flip-flop between the two variants, and performing more
+    // requests will only cause more useless flip-flops.
+    //
+    // This scenario requires a very odd server configuration in which different
+    // variants of the same resource are supplied to the same user, and the
+    // max-age is short enough that the requests collide during the
+    // stale-while-revalidate interval.
+    //
+    // TODO(ricea): It's probably not hard to include |vary_data| in the key to
+    // AsyncRevalidationMap, but we need to decide if there is any benefit in
+    // doing so.

[kinuko, 2015/11/27 08:50:01]

nit: maybe record UMA to see how often this could happen?

[Adam Rice, 2015/11/27 14:45:13]

I just checked the code in net::HttpCache::Transaction and actually we never do
an asynchronous revalidation on a Vary mismatch. This makes sense because when
there is a Vary mismatch we have to revalidate regardless of whether the
response is stale or not. I should have checked it before I wrote the long
comment.

I have rewritten the comment to be much shorter. Sorry for the trouble.

+    return;
+  }
+
+  net::HttpRequestHeaders headers;
+  headers.AddHeadersFromString(info->original_headers());
+
+  // Construct the request.
+  scoped_ptr<net::URLRequest> new_request = request_context->CreateRequest(
+      for_request->url(), net::MINIMUM_PRIORITY, nullptr);
+
+  new_request->set_method(for_request->method());
+  new_request->set_first_party_for_cookies(
+      for_request->first_party_for_cookies());
+  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->SetExtraRequestHeaders(headers);
+
+  // Remove LOAD_SUPPORT_ASYNC_REVALIDATION and LOAD_MAIN_FRAME flags.
+  // Also remove things which shouldn't have been there to begin with,
+  // and unrecognised flags.
+  int 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_PREFETCH |
+       net::LOAD_MAYBE_USER_GESTURE | net::LOAD_DO_NOT_USE_EMBEDDED_IDENTITY);
+  new_request->SetLoadFlags(load_flags);
+
+  scoped_ptr<ResourceThrottle> throttle =
+      scheduler->ScheduleRequest(child_id, route_id, false, new_request.get());
+
+  // AsyncRevalidationDriver does not outlive its entry in |in_progress_|,
+  // so the iterator and |this| may be passed to base::Bind directly.
+  insert_result.first->second.reset(new AsyncRevalidationDriver(
+      std::move(new_request), std::move(throttle),
+      base::Bind(&AsyncRevalidationManager::OnAsyncRevalidationComplete,
+                 base::Unretained(this), insert_result.first)));
+  insert_result.first->second->StartRequest();
+}
+
+void AsyncRevalidationManager::CancelAsyncRevalidationsForResourceContext(
+    ResourceContext* resource_context) {
+  // For this algorithm to work, elements using |resource_context| must be
+  // contiguous in the map (ie. it must form the first part of the key).

[kinuko, 2015/11/27 08:50:01]

nit: feels a bit verbose, would something like following work?

|resource_context| is the first part of the key, so elements to be cancelled are
contiguous in the map.

[Adam Rice, 2015/11/27 14:45:13]

That is much clearer, thanks!

+  AsyncRevalidationKey partial_key(resource_context);
+  for (auto it = in_progress_.lower_bound(partial_key);
+       it != in_progress_.end() &&
+       it->first.resource_context == resource_context;) {
+    it->second->CancelRequest();
+    it = in_progress_.erase(it);
+  }
+}
+
+bool AsyncRevalidationManager::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 | net::LOAD_IGNORE_LIMITS)) {
+    return false;
+  }
+  if (request.method != "GET")
+    return false;
+  // A GET request should not have a body.
+  if (request.request_body.get())
+    return false;
+  if (!request.url.SchemeIsHTTPOrHTTPS())
+    return false;
+
+  return true;
+}
+
+void AsyncRevalidationManager::OnAsyncRevalidationComplete(
+    AsyncRevalidationMap::iterator it) {
+  in_progress_.erase(it);
+}
+
+}  // namespace content