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_message_filter.h" | |
13 #include "content/browser/loader/resource_request_info_impl.h" | |
14 #include "content/browser/loader/resource_scheduler.h" | |
15 #include "content/common/resource_messages.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 const net::URLRequest& for_request, | |
55 ResourceScheduler* scheduler) { | |
56 DCHECK_EQ(for_request.url_chain().size(), 1u); | |
57 const ResourceRequestInfoImpl* info = | |
58 ResourceRequestInfoImpl::ForRequest(&for_request); | |
59 DCHECK(info); | |
60 if (!info->filter()) { | |
61 // The child has gone away and we can no longer get ResourceContext and | |
62 // URLRequestContext to perform async revalidation. | |
63 // This can happen in the following cases, ordered from bad to not-so-bad | |
64 // | |
65 // 1. PlzNavigate (but it won't be enabled; see crbug.com/561609) | |
kinuko
2015/12/05 07:21:37
nit: won't be enabled -> is not enabled yet ?
Adam Rice
2015/12/07 16:29:23
I meant that it won't be enabled if we are executi
| |
66 // 2. <link rel=prefetch> may read a stale cache entry without a | |
67 // revalidation being performed if the original renderer goes away. This | |
68 // is a lost optimisation opportunity. | |
69 // | |
70 // Not an issue: | |
71 // 1. Implicit downloads. This method is called before | |
72 // MimeTypeResourceHandler calls set_is_download, so the renderer process | |
73 // must still exist for the request not to have been canceled. | |
74 // 2. Explicit downloads (ie. started via "Save As"). These never use | |
75 // stale-while-revalidate. | |
76 // 3. Non-PlzNavigate navigations between renderers. The old renderer | |
77 // still exists when this method is called. | |
78 // 4. <a ping>, navigation.sendBeacon() and Content-Security-Policy reports | |
79 // are POST requests, so they never use stale-while-revalidate. | |
80 // | |
81 // TODO(ricea): Resolve these lifetime issues. crbug.com/561591 | |
82 return; | |
83 } | |
84 | |
85 ResourceContext* resource_context = nullptr; | |
86 net::URLRequestContext* request_context = nullptr; | |
87 | |
88 // The embedder of //content needs to ensure that the URLRequestContext object | |
89 // remains valid until after the ResourceContext object is destroyed. | |
90 info->filter()->GetContexts(info->GetResourceType(), info->GetOriginPID(), | |
91 &resource_context, &request_context); | |
92 | |
93 AsyncRevalidationKey async_revalidation_key( | |
94 resource_context, request_context->http_transaction_factory()->GetCache(), | |
95 for_request.url()); | |
96 std::pair<AsyncRevalidationMap::iterator, bool> insert_result = | |
97 in_progress_.insert(AsyncRevalidationMap::value_type( | |
98 async_revalidation_key, scoped_ptr<AsyncRevalidationDriver>())); | |
99 if (!insert_result.second) { | |
100 // A matching async revalidation is already in progress for this cache; we | |
101 // don't need another one. An async revalidation is never triggered when a | |
102 // Vary mismatch occurs. This means that the response will be usable even if | |
103 // the request headers differ. | |
104 return; | |
105 } | |
106 | |
107 net::HttpRequestHeaders headers; | |
108 headers.AddHeadersFromString(info->original_headers()); | |
109 | |
110 // Construct the request. | |
111 scoped_ptr<net::URLRequest> new_request = request_context->CreateRequest( | |
112 for_request.url(), net::MINIMUM_PRIORITY, 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_first_party_url_policy( | |
118 for_request.first_party_url_policy()); | |
119 | |
120 new_request->SetReferrer(for_request.referrer()); | |
121 new_request->set_referrer_policy(for_request.referrer_policy()); | |
122 | |
123 new_request->SetExtraRequestHeaders(headers); | |
124 | |
125 // Remove LOAD_SUPPORT_ASYNC_REVALIDATION and LOAD_MAIN_FRAME flags. | |
126 // Also remove things which shouldn't have been there to begin with, | |
127 // and unrecognised flags. | |
128 int load_flags = | |
129 for_request.load_flags() & | |
130 (net::LOAD_DO_NOT_SAVE_COOKIES | net::LOAD_BYPASS_PROXY | | |
131 net::LOAD_VERIFY_EV_CERT | net::LOAD_DO_NOT_SEND_COOKIES | | |
132 net::LOAD_DO_NOT_SEND_AUTH_DATA | net::LOAD_PREFETCH | | |
133 net::LOAD_MAYBE_USER_GESTURE | net::LOAD_DO_NOT_USE_EMBEDDED_IDENTITY); | |
134 new_request->SetLoadFlags(load_flags); | |
135 | |
136 // These values would be -1 if the request was created by PlzNavigate. This | |
137 // would cause the async revalidation to start immediately. | |
138 // stale-while-revalidate is disabled when PlzNavigate is enabled | |
139 // to prevent this and other issues. See crbug.com/561610. | |
140 int child_id = info->GetChildID(); | |
141 int route_id = info->GetRouteID(); | |
142 | |
143 scoped_ptr<ResourceThrottle> throttle = | |
144 scheduler->ScheduleRequest(child_id, route_id, false, new_request.get()); | |
145 | |
146 // AsyncRevalidationDriver does not outlive its entry in |in_progress_|, | |
147 // so the iterator and |this| may be passed to base::Bind directly. | |
148 insert_result.first->second.reset(new AsyncRevalidationDriver( | |
149 std::move(new_request), std::move(throttle), | |
150 base::Bind(&AsyncRevalidationManager::OnAsyncRevalidationComplete, | |
151 base::Unretained(this), insert_result.first))); | |
152 insert_result.first->second->StartRequest(); | |
153 } | |
154 | |
155 void AsyncRevalidationManager::CancelAsyncRevalidationsForResourceContext( | |
156 ResourceContext* resource_context) { | |
157 // |resource_context| is the first part of the key, so elements to be | |
158 // cancelled are contiguous in the map. | |
159 AsyncRevalidationKey partial_key(resource_context); | |
160 for (auto it = in_progress_.lower_bound(partial_key); | |
161 it != in_progress_.end() && | |
162 it->first.resource_context == resource_context;) { | |
163 it->second->CancelRequest(); | |
164 it = in_progress_.erase(it); | |
165 } | |
166 } | |
167 | |
168 bool AsyncRevalidationManager::QualifiesForAsyncRevalidation( | |
169 const ResourceHostMsg_Request& request) { | |
170 if (request.load_flags & | |
171 (net::LOAD_BYPASS_CACHE | net::LOAD_DISABLE_CACHE | | |
172 net::LOAD_VALIDATE_CACHE | net::LOAD_PREFERRING_CACHE | | |
173 net::LOAD_ONLY_FROM_CACHE | net::LOAD_IGNORE_LIMITS)) { | |
174 return false; | |
175 } | |
176 if (request.method != "GET") | |
177 return false; | |
178 // A GET request should not have a body. | |
179 if (request.request_body.get()) | |
180 return false; | |
181 if (!request.url.SchemeIsHTTPOrHTTPS()) | |
182 return false; | |
183 | |
184 return true; | |
185 } | |
186 | |
187 void AsyncRevalidationManager::OnAsyncRevalidationComplete( | |
188 AsyncRevalidationMap::iterator it) { | |
189 in_progress_.erase(it); | |
190 } | |
191 | |
192 } // namespace content | |
OLD | NEW |