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..16ea33a11ddfc1931e126f850b017d19fb176055 |
--- /dev/null |
+++ b/content/browser/loader/async_revalidation_manager.cc |
@@ -0,0 +1,174 @@ |
+// 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? J
Adam Rice
2015/12/03 14:20:43
I investigated the various cases and updated the c
|
+ // 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 ScheduleR
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 |