| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2015 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "content/browser/loader/async_revalidation_manager.h" | |
| 6 | |
| 7 #include <tuple> | |
| 8 #include <utility> | |
| 9 | |
| 10 #include "base/logging.h" | |
| 11 #include "content/browser/loader/async_revalidation_driver.h" | |
| 12 #include "content/browser/loader/resource_request_info_impl.h" | |
| 13 #include "content/browser/loader/resource_scheduler.h" | |
| 14 #include "content/common/resource_messages.h" | |
| 15 #include "content/common/resource_request.h" | |
| 16 #include "content/public/browser/resource_throttle.h" | |
| 17 #include "net/base/load_flags.h" | |
| 18 #include "net/http/http_transaction_factory.h" | |
| 19 #include "net/http/http_util.h" | |
| 20 #include "net/url_request/url_request.h" | |
| 21 #include "net/url_request/url_request_context.h" | |
| 22 #include "url/gurl.h" | |
| 23 | |
| 24 namespace content { | |
| 25 | |
| 26 AsyncRevalidationManager::AsyncRevalidationKey::AsyncRevalidationKey( | |
| 27 const ResourceContext* resource_context, | |
| 28 const net::HttpCache* http_cache, | |
| 29 const GURL& url) | |
| 30 : resource_context(resource_context), | |
| 31 http_cache(http_cache), | |
| 32 url_key(net::HttpUtil::SpecForRequest(url)) {} | |
| 33 | |
| 34 AsyncRevalidationManager::AsyncRevalidationKey::AsyncRevalidationKey( | |
| 35 const ResourceContext* resource_context) | |
| 36 : resource_context(resource_context), http_cache(nullptr), url_key() {} | |
| 37 | |
| 38 AsyncRevalidationManager::AsyncRevalidationKey::~AsyncRevalidationKey() {} | |
| 39 | |
| 40 bool AsyncRevalidationManager::AsyncRevalidationKey::LessThan::operator()( | |
| 41 const AsyncRevalidationKey& lhs, | |
| 42 const AsyncRevalidationKey& rhs) const { | |
| 43 return std::tie(lhs.resource_context, lhs.http_cache, lhs.url_key) < | |
| 44 std::tie(rhs.resource_context, rhs.http_cache, rhs.url_key); | |
| 45 } | |
| 46 | |
| 47 AsyncRevalidationManager::AsyncRevalidationManager() {} | |
| 48 | |
| 49 AsyncRevalidationManager::~AsyncRevalidationManager() { | |
| 50 DCHECK(in_progress_.empty()); | |
| 51 } | |
| 52 | |
| 53 void AsyncRevalidationManager::BeginAsyncRevalidation( | |
| 54 net::URLRequest* for_request, | |
| 55 ResourceScheduler* scheduler) { | |
| 56 DCHECK_EQ(for_request->url_chain().size(), 1u); | |
| 57 ResourceRequestInfoImpl* info = | |
| 58 ResourceRequestInfoImpl::ForRequest(for_request); | |
| 59 DCHECK(info); | |
| 60 DCHECK(info->requester_info()->IsRenderer()); | |
| 61 if (!info->requester_info()->filter()) { | |
| 62 // The child has gone away and we can no longer get ResourceContext and | |
| 63 // URLRequestContext to perform async revalidation. | |
| 64 // This can happen in the following cases, ordered from bad to not-so-bad | |
| 65 // | |
| 66 // 1. PlzNavigate (but enabling PlzNavigate automatically disables | |
| 67 // stale-while-revalidate; see crbug.com/561609) | |
| 68 // 2. <link rel=prefetch> may read a stale cache entry without a | |
| 69 // revalidation being performed if the original renderer goes away. This | |
| 70 // is a lost optimisation opportunity. | |
| 71 // | |
| 72 // Not an issue: | |
| 73 // 1. Implicit downloads. This method is called before | |
| 74 // MimeTypeResourceHandler calls set_is_download, so the renderer process | |
| 75 // must still exist for the request not to have been canceled. | |
| 76 // 2. Explicit downloads (ie. started via "Save As"). These never use | |
| 77 // stale-while-revalidate. | |
| 78 // 3. Non-PlzNavigate navigations between renderers. The old renderer | |
| 79 // still exists when this method is called. | |
| 80 // 4. <a ping>, navigation.sendBeacon() and Content-Security-Policy reports | |
| 81 // are POST requests, so they never use stale-while-revalidate. | |
| 82 // | |
| 83 // TODO(ricea): Resolve these lifetime issues. crbug.com/561591 | |
| 84 return; | |
| 85 } | |
| 86 | |
| 87 ResourceContext* resource_context = nullptr; | |
| 88 net::URLRequestContext* request_context = nullptr; | |
| 89 | |
| 90 // The embedder of //content needs to ensure that the URLRequestContext object | |
| 91 // remains valid until after the ResourceContext object is destroyed. | |
| 92 info->requester_info()->GetContexts(info->GetResourceType(), | |
| 93 &resource_context, &request_context); | |
| 94 | |
| 95 AsyncRevalidationKey async_revalidation_key( | |
| 96 resource_context, request_context->http_transaction_factory()->GetCache(), | |
| 97 for_request->url()); | |
| 98 std::pair<AsyncRevalidationMap::iterator, bool> insert_result = | |
| 99 in_progress_.insert(AsyncRevalidationMap::value_type( | |
| 100 async_revalidation_key, std::unique_ptr<AsyncRevalidationDriver>())); | |
| 101 if (!insert_result.second) { | |
| 102 // A matching async revalidation is already in progress for this cache; we | |
| 103 // don't need another one. | |
| 104 return; | |
| 105 } | |
| 106 | |
| 107 net::HttpRequestHeaders headers; | |
| 108 headers.AddHeadersFromString(info->original_headers()); | |
| 109 | |
| 110 // Construct the request. | |
| 111 std::unique_ptr<net::URLRequest> new_request = | |
| 112 request_context->CreateRequest(for_request->url(), net::IDLE, nullptr); | |
| 113 | |
| 114 new_request->set_method(for_request->method()); | |
| 115 new_request->set_first_party_for_cookies( | |
| 116 for_request->first_party_for_cookies()); | |
| 117 new_request->set_initiator(for_request->initiator()); | |
| 118 new_request->set_first_party_url_policy( | |
| 119 for_request->first_party_url_policy()); | |
| 120 | |
| 121 new_request->SetReferrer(for_request->referrer()); | |
| 122 new_request->set_referrer_policy(for_request->referrer_policy()); | |
| 123 | |
| 124 new_request->SetExtraRequestHeaders(headers); | |
| 125 | |
| 126 // Remove LOAD_SUPPORT_ASYNC_REVALIDATION and LOAD_MAIN_FRAME_DEPRECATED | |
| 127 // flags. | |
| 128 // Also remove things which shouldn't have been there to begin with, | |
| 129 // and unrecognised flags. | |
| 130 int load_flags = | |
| 131 for_request->load_flags() & | |
| 132 (net::LOAD_DO_NOT_SAVE_COOKIES | net::LOAD_BYPASS_PROXY | | |
| 133 net::LOAD_VERIFY_EV_CERT | net::LOAD_DO_NOT_SEND_COOKIES | | |
| 134 net::LOAD_DO_NOT_SEND_AUTH_DATA | net::LOAD_MAYBE_USER_GESTURE | | |
| 135 net::LOAD_DO_NOT_USE_EMBEDDED_IDENTITY); | |
| 136 new_request->SetLoadFlags(load_flags); | |
| 137 | |
| 138 // These values would be -1 if the request was created by PlzNavigate. This | |
| 139 // would cause the async revalidation to start immediately. | |
| 140 // stale-while-revalidate is disabled when PlzNavigate is enabled | |
| 141 // to prevent this and other issues. See crbug.com/561610. | |
| 142 int child_id = info->GetChildID(); | |
| 143 int route_id = info->GetRouteID(); | |
| 144 | |
| 145 std::unique_ptr<ResourceThrottle> throttle = | |
| 146 scheduler->ScheduleRequest(child_id, route_id, false, new_request.get()); | |
| 147 | |
| 148 // AsyncRevalidationDriver does not outlive its entry in |in_progress_|, | |
| 149 // so the iterator and |this| may be passed to base::Bind directly. | |
| 150 insert_result.first->second.reset(new AsyncRevalidationDriver( | |
| 151 std::move(new_request), std::move(throttle), | |
| 152 base::Bind(&AsyncRevalidationManager::OnAsyncRevalidationComplete, | |
| 153 base::Unretained(this), insert_result.first))); | |
| 154 insert_result.first->second->StartRequest(); | |
| 155 } | |
| 156 | |
| 157 void AsyncRevalidationManager::CancelAsyncRevalidationsForResourceContext( | |
| 158 ResourceContext* resource_context) { | |
| 159 // |resource_context| is the first part of the key, so elements to be | |
| 160 // cancelled are contiguous in the map. | |
| 161 AsyncRevalidationKey partial_key(resource_context); | |
| 162 for (auto it = in_progress_.lower_bound(partial_key); | |
| 163 it != in_progress_.end() && | |
| 164 it->first.resource_context == resource_context;) { | |
| 165 it = in_progress_.erase(it); | |
| 166 } | |
| 167 } | |
| 168 | |
| 169 bool AsyncRevalidationManager::QualifiesForAsyncRevalidation( | |
| 170 const ResourceRequest& request) { | |
| 171 if (request.load_flags & | |
| 172 (net::LOAD_BYPASS_CACHE | net::LOAD_DISABLE_CACHE | | |
| 173 net::LOAD_VALIDATE_CACHE | net::LOAD_SKIP_CACHE_VALIDATION | | |
| 174 net::LOAD_ONLY_FROM_CACHE | net::LOAD_IGNORE_LIMITS | | |
| 175 net::LOAD_PREFETCH)) { | |
| 176 return false; | |
| 177 } | |
| 178 if (request.method != "GET") | |
| 179 return false; | |
| 180 // A GET request should not have a body. | |
| 181 if (request.request_body.get()) | |
| 182 return false; | |
| 183 if (!request.url.SchemeIsHTTPOrHTTPS()) | |
| 184 return false; | |
| 185 | |
| 186 return true; | |
| 187 } | |
| 188 | |
| 189 void AsyncRevalidationManager::OnAsyncRevalidationComplete( | |
| 190 AsyncRevalidationMap::iterator it) { | |
| 191 in_progress_.erase(it); | |
| 192 } | |
| 193 | |
| 194 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2764683002:
Remove stale-while-revalidate from content and chrome (Closed)
