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 <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 {
+  if (lhs.resource_context != rhs.resource_context)
+    return lhs.resource_context < rhs.resource_context;
+
+  if (lhs.http_cache != rhs.http_cache)
+    return lhs.http_cache < rhs.http_cache;
+
+  return lhs.url_key < rhs.url_key;

[kinuko, 2015/11/19 07:00:29]

nit: I think now you could do

return std::tie(lhs.xxx, lhs.yyy, lhs.zzz) < std::tie(rhs.xxx, rhs.yyy, rhs.zzz)

[Adam Rice, 2015/11/19 21:13:52]

Done.

+}
+
+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. Since it never received the body of the stale
+    // resource, it is okay not to perform an async revalidation.
+    return;
+  }
+
+  int child_id = info->GetChildID();
+  int route_id = info->GetRouteID();
+
+  // ResourceMsgFilter::GetContexts requires a ResourceHostMsg_Request object be
+  // passed but only cares about the resource_type field.
+  ResourceHostMsg_Request dummy_resource_host_msg_request;
+  dummy_resource_host_msg_request.resource_type = info->GetResourceType();
+  ResourceContext* resource_context = nullptr;
+  net::URLRequestContext* request_context = nullptr;
+
+  // This |request_context| needs to be valid until
+  // RemoveResourceContext(resource_context) is called. This is currently
+  // correct, see the comment about member variable ordering in
+  // //chrome/browser/profiles/profile_io_data.h.
+  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, nullptr));
+  if (!insert_result.second) {
+    // A matching async revalidation is already in progress for this cache; we
+    // don't need another one.
+    return;
+  }
+  auto& async_revalidation = insert_result.first->second;
+  DCHECK(async_revalidation == nullptr);
+
+  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);
+
+  int load_flags = for_request->load_flags() &
+                   ~net::LOAD_SUPPORT_ASYNC_REVALIDATION &
+                   ~net::LOAD_MAIN_FRAME;
+  DCHECK_EQ(load_flags & net::LOAD_IGNORE_LIMITS, 0);
+  new_request->SetLoadFlags(load_flags);
+
+  scoped_ptr<ResourceThrottle> throttle =
+      scheduler->ScheduleRequest(child_id, route_id, false, new_request.get());
+  // This use of base::Unretained() is safe because the AsyncRevalidatonDriver
+  // object will be destroyed before this object is. The use of the raw iterator
+  // is safe because objects are only erased from the map after being deleted,
+  // and a deleted AsyncRevalidationDriver will not call the completion
+  // callback.
+  async_revalidation = new AsyncRevalidationDriver(

[kinuko, 2015/11/19 08:38:34]

Hmm it's slightly hard to follow that this is actually inserting the value
here... maybe move the lines 98-99 before the lines?

[Adam Rice, 2015/11/19 21:13:52]

Done.

+      new_request.Pass(), throttle.Pass(),
+      base::Bind(&AsyncRevalidationManager::OnAsyncRevalidationComplete,
+                 base::Unretained(this), insert_result.first));
+  async_revalidation->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).
+  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 is necessary to delete behind the iterator because an iterator can't
+    // be incremented once it has been removed from the map.
+    auto prev_it = it;
+    ++it;
+    prev_it->second->CancelRequest();
+    delete prev_it->second;
+    in_progress_.erase(prev_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, but don't leave it to chance.
+  if (request.request_body.get())
+    return false;
+  if (!request.url.SchemeIsHTTPOrHTTPS())
+    return false;
+
+  return true;
+}
+
+void AsyncRevalidationManager::OnAsyncRevalidationComplete(
+    AsyncRevalidationMap::iterator it) {
+  delete it->second;
+  in_progress_.erase(it);
+}
+
+}  // namespace content