content::ResourceDispatcherHostImpl changes for stale-while-revalidate

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/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(
+    const net::URLRequest& for_request,
+    ResourceScheduler* scheduler) {
+  DCHECK_EQ(for_request.url_chain().size(), 1u);
+  const 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.

[kinuko, 2015/12/03 07:51:41]

Could we make this comment a bit more specific?  Just saying "this is a problem"
makes me feel why we have this code now then.

E.g. "The child has gone away and we can no longer get ResourceContext and
URLRequestContext to perform async revalidation.  This should be okay for most
cases but not for downloads and PlzNavigate, where we might be returning stale
body. TODO(ricea)..."

(Feel free to rephrase with better English)

[Adam Rice, 2015/12/03 14:20:43]

I investigated the various cases and updated the comment. Apart from the known
issue with PlzNavigate, it is not as bad as I thought.

+    // TODO(ricea): Resolve these lifetime issues. crbug.com/561591
+    return;
+  }
+
+  int child_id = info->GetChildID();
+  int route_id = info->GetRouteID();

[kinuko, 2015/12/03 07:51:41]

Are these now only used on line 125 (for ScheduleRequest)? Please move these
down there then. Please also add a short comment to note that "this part doesn't
work with PlzNavigate" here too with a link to crbug.com/561610

[Adam Rice, 2015/12/03 14:20:43]

Done.

+
+  // ResourceMessageFilter::GetContexts requires a ResourceHostMsg_Request
+  // object to be passed but only cares about the resource_type and origin_pid
+  // fields.

[kinuko, 2015/12/03 07:51:41]

This comment looks stale now.

[Adam Rice, 2015/12/03 14:20:43]

Sorry. Removed.

+  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(), info->GetOriginPID(),
+                              &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. An async revalidation is never triggered when a
+    // Vary mismatch occurs. This means that the response will be usable even if
+    // the request headers differ.
+    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) {
+  // |resource_context| is the first part of the key, so elements to be
+  // cancelled are contiguous in the map.
+  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