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..be5cf572c7999ca370d3017d09be84d49e216b62 |
--- /dev/null |
+++ b/content/browser/loader/async_revalidation_manager.cc |
@@ -0,0 +1,182 @@ |
+// 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
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 actu
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 |