203058 2019-10-16 15:31:34 -0700 HEAD requests are not cached 2022-06-07 14:31:57 -0700 1 1 1 Unclassified WebKit Page Loading WebKit Nightly Build All All NEW InRadar P2 Normal --- 1 nham nham ahmad.saleem792 beidson cdumez cgarcia ews-watchlist ggaren koivisto nham webkit-bug-importer oldest_to_newest 1580728 0 381123 nham 2019-10-16 15:31:34 -0700 Created attachment 381123 test case for GET followed by HEAD The warm Amazon page load on PLT5 shows a number of static resources that aren't cached. This is due to a GET followed by a HEAD for the same resource: 1. The main page has an <img src="foo.jpg"> which causes a GET for foo.jpg. 2. Some time later, they do a HEAD request for foo.jpg via an XHR (they extract Content-Length out of the response headers to power some other logic). I've attached a reduced test case that makes this request pattern. (Note that Amazon's home page even as of today shows this request pattern, so it's not entirely theoretical.) This request pattern causes misses in both our memory and disk caches. # Memory Cache In the memory cache, the GET has a type of ImageResource, while the HEAD has a type of RawResource. The mismatched types cause the memory cache to always reload the resource, as shown in `CachedResourceLoader::determineRevalidationPolicy`: ``` // If the same URL has been loaded as a different type, we need to reload. if (existingResource->type() != type) { LOG(ResourceLoading, "CachedResourceLoader::determineRevalidationPolicy reloading due to type mismatch."); logMemoryCacheResourceRequest(frame(), DiagnosticLoggingKeys::inMemoryCacheKey(), DiagnosticLoggingKeys::unusedReasonTypeMismatchKey()); return Reload; } ``` # Disk Cache In the disk cache, the first GET is cached to disk as expected. However, `makeStoreDecision` decides to not store HEAD responses: ``` if (originalRequest.httpMethod() != "GET") return StoreDecision::NoDueToHTTPMethod; ``` In response, `Cache::store` deletes the existing GET response from the disk cache: ``` StoreDecision storeDecision = makeStoreDecision(request, response, responseData ? responseData->size() : 0); if (storeDecision != StoreDecision::Yes) { LOG(NetworkCache, "(NetworkProcess) didn't store, storeDecision=%d", static_cast<int>(storeDecision)); auto key = makeCacheKey(request); auto isSuccessfulRevalidation = response.httpStatusCode() == 304; if (!isSuccessfulRevalidation) { // Make sure we don't keep a stale entry in the cache. remove(key); } return nullptr; } ``` So as a result, when the page load is complete, there is nothing at all cached for foo.jpg. So on reload, we actually end up fetching foo.jpg from the network again, for both the GET and HEAD requests. # Other Browsers Chrome is able to downgrade a cached GET response to a HEAD response. When loading the test case in Chrome: 1. On a cold load, foo.jpg is loaded from the network for the GET, and then the disk cache cache is used to satisfy the HEAD request. 2. On a warm load, both the GET and HEAD requests are served out of disk cache. 1580730 1 webkit-bug-importer 2019-10-16 15:32:11 -0700 <rdar://problem/56349558> 1580747 2 cdumez 2019-10-16 15:56:15 -0700 I am surprised we are not caching responses to HEAD requests. AFAIK, it is allowed and it would not be hard to implement. That said, it would be useful to get an estimate of the impact on PLT to see if it is worth doing. 1580759 3 nham 2019-10-16 16:15:54 -0700 I do not think it will be a huge win, because we are not blocking DOMContentLoaded or FirstMeaningfulPaint on these resources loading. It would impact AllSubresourcesLoaded time only. There are 13 resources on the Amazon snapshot in the test that exhibit this behavior. The other sites in the test would be unaffected. For PLT5: 1. On the cold run, we'd have to do the 13 GETs, but potentially the 13 HEADs could be served out of cache. 2. On the warm run, all 26 requests (13 GETs and 13 HEADs) could potentially be served out of cache. We open multiple connections to the PLT5 server in parallel, so we save on 6 parallel SSL session setups to the same hostname, plus 13-26 transmission delays which are parallelized onto those 6 concurrent connections. Probably looking at something 100-200 ms saved on the warm Amazon PLT. I can try to jerry-rig up some quick and dirty patch to try to get a better estimate from the A/B bots. Another consideration is that maybe we should not bother caching HEADs directly but just support the downgrade from a cached GET to a cached HEAD. 1580852 4 ggaren 2019-10-16 21:28:47 -0700 FWIW, in cases where the optimization is clear and not hard to do, my preference is just to do it. Even if it's no speedup in the end, it un-muddies the waters, and prevents the next person from tripping over the same issue. 1580869 5 koivisto 2019-10-16 22:31:19 -0700 We definitely should support it. Implementation is not totally trivial since you'd also want to support responding with cached GET results. The reason this wasn't done earlier is simply because we hadn't seen any interesting content using HEAD. 1585001 6 nham 2019-10-29 11:27:45 -0700 There seem to be two ways this is currently supported in the field: 1. Cache GET and HEAD requests separately without support for GET => HEAD downgrade (Firefox) 2. Don't cache HEAD requests directly, but support downgrade of a cached GET to a cached HEAD (Chrome) Obviously we could do both, but it would be a bit more complicated than doing one or the other (because we'd potentially now do two cache lookups for a HEAD request rather than just one). I've tried out a simple patch that treats GETs and HEADs separately and it doesn't have an effect on PLT even though it does properly result in cached HEADs in the warm trace. I suspected this would happen due to the requests not being on the critical path. Based on that, my vote is to do the simplest thing that adds this feature and is maintainable. 1585058 7 koivisto 2019-10-29 13:20:39 -0700 Caching HEAD itself seems pretty pointless. The Chrome behavior is probably the way to go. 1585060 8 koivisto 2019-10-29 13:25:54 -0700 In terms of implementation it should be pretty much a matter of replacing HEAD with GET in the cache key and maybe skipping the unneeded fetching of the body from the disk (though that can be later optimization if needed). 1585138 9 382236 nham 2019-10-29 15:28:49 -0700 Created attachment 382236 WIP: allow HEADs to use cached GETs 1585140 10 382238 nham 2019-10-29 15:29:15 -0700 Created attachment 382238 WIP: cache HEADs as well as GETs 1585142 11 nham 2019-10-29 15:31:19 -0700 Neither seems too complicated to implement, so I uploaded proposed patches for comment for both strategies (although it sounds like we want to go with the downgrading of cached GETs). Since I haven't written too many WK patches before I'm just looking to make sure I'm going down the right path. There aren't any test cases yet, but I'll add some test cases to the disk-cache suite soon. 1587413 12 ggaren 2019-11-05 09:02:24 -0800 Some details: - I clicked the "patch" box in the Details view so your changes now show up as patches, and can be seen as diffs and submitted to EWS. - You need a ChangeLog. I usually use the webkit-patch tool or the prepare-ChangeLog tool to help generate boilerplate, and then I fill it in with comments. 1587419 13 382236 ggaren 2019-11-05 09:13:36 -0800 Comment on attachment 382236 WIP: allow HEADs to use cached GETs View in context: https://bugs.webkit.org/attachment.cgi?id=382236&action=review > Source/WebKit/NetworkProcess/cache/NetworkCache.cpp:214 > + if (decision == UseDecision::Validate && isHead) { > + // Seems silly to validate a HEAD, so just force the real request to go out. > + return UseDecision::NoDueToHTTPMethod; > + } I don't fully understand from this comment why you went to the extra trouble to prohibit Validate on HEAD in the cache. Does silly in this context mean that it would be slow, or incorrect, or something else? If the behavior would be surprising but still correct, it might be best just to let it happen instead of special casing it. > Source/WebKit/NetworkProcess/cache/NetworkCache.cpp:327 > + bool isHead = request.httpMethod() == "HEAD"; > + auto retrieveDecision = makeRetrieveDecision(request, isHead); It's inconsistent to use a boolean to identify HEAD requests and a string comparison to identify GET requests. Let's pick one way and stick with it. If we do, the overall special casing and intrusion of HEAD into the cache's design will be smaller. I think string comparison may be fine for performance, since it's just three (GET) or four (HEAD) branches. So we could just use that. That said, if we want something better than string comparison, I'd suggest a refactoring patch to add httpMethodForCache() to ResourceRequest, and have it return an enum class { Get, Head, Other }. The ResourceRequest could initialize this member in its constructor, or lazily. 1587422 14 382238 ggaren 2019-11-05 09:16:28 -0800 Comment on attachment 382238 WIP: cache HEADs as well as GETs This patch looks good to me, and not particularly hard to maintain going forward. Based on this, I would support doing both. 1874571 15 ahmad.saleem792 2022-06-07 14:31:57 -0700 Despite this patch not landing (can verify via Webkit Github mirror), I am seeing below mentioned behavior with attached test case in Safari 15.5 on macOS 12.4. Link - https://github.com/WebKit/WebKit/blob/main/Source/WebKit/NetworkProcess/cache/NetworkCache.cpp Each time reliably on running test case attached, I get "HEAD XHR succeeded!" but when I use "Network" with "Method" column enabled, I can see both GET and HEAD responses. Despite enabling and disabling caches, I see both requests. Although, "Resource Size" is zero in case of HEAD request. Just wanted to update latest behavior and if I testing it wrong or incorrect. Happy to be corrected. Thanks! 381123 2019-10-16 15:31:34 -0700 2019-10-16 15:31:34 -0700 test case for GET followed by HEAD img-xhr-head-caching.html text/html 712 nham PCFkb2N0eXBlIGh0bWw+CjxoZWFkPgogIDx0aXRsZT5IVE1MIEhlYWQgQ2FjaGluZyBUZXN0PC90 aXRsZT4KICA8c2NyaXB0PgogICAgZnVuY3Rpb24gc2VuZEhlYWRSZXF1ZXN0KCkgewogICAgICBs ZXQgcmVxID0gbmV3IFhNTEh0dHBSZXF1ZXN0KCk7CiAgICAgIHJlcS5vcGVuKCdIRUFEJywgImh0 dHBzOi8vaW1hZ2VzLW5hLnNzbC1pbWFnZXMtYW1hem9uLmNvbS9pbWFnZXMvSS82MWE3ZDhnQW9D TC5fQUNfU1kyMDBfLmpwZyIpOwogICAgICByZXEub25yZWFkeXN0YXRlY2hhbmdlID0gZnVuY3Rp b24oKSB7CiAgICAgICAgaWYgKHRoaXMucmVhZHlTdGF0ZSA9PT0gdGhpcy5ET05FKSB7CiAgICAg ICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgic3RhdHVzIikuaW5uZXJUZXh0ID0gIkhFQUQg WEhSIHN1Y2NlZWRlZCEiOwogICAgICAgIH0KICAgICAgfQogICAgICByZXEuc2VuZCgpOwogICAg fQogICAgd2luZG93Lm9ubG9hZCA9IGZ1bmN0aW9uKCkgewogICAgICBzZXRUaW1lb3V0KHNlbmRI ZWFkUmVxdWVzdCwgMTAwMCk7CiAgICB9CiAgPC9zY3JpcHQ+CjwvaGVhZD4KPGJvZHk+CiAgPGlt ZyBzcmM9Imh0dHBzOi8vaW1hZ2VzLW5hLnNzbC1pbWFnZXMtYW1hem9uLmNvbS9pbWFnZXMvSS82 MWE3ZDhnQW9DTC5fQUNfU1kyMDBfLmpwZyI+CiAgPHAgaWQ9InN0YXR1cyI+U2VuZGluZyBIRUFE IFhIUi4uLjwvcD4KPC9ib2R5Pgo8L2h0bWw+Cg== 382236 2019-10-29 15:28:49 -0700 2019-11-05 09:00:54 -0800 WIP: allow HEADs to use cached GETs 0001-WIP-allow-HEAD-requests-to-use-cached-GETs.diff text/plain 5079 nham RnJvbSAxMDVkOTk4NjNlNTA3ZGIxMWFmMzQ1MzMzYjUwZGFjYjFjZDgzODUxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBCZW5qYW1pbiBOaGFtIDxuaGFtQGFwcGxlLmNvbT4KRGF0ZTog VHVlLCAyOSBPY3QgMjAxOSAxNDoyMzo0MyAtMDcwMApTdWJqZWN0OiBbUEFUQ0hdIFdJUDogYWxs b3cgSEVBRCByZXF1ZXN0cyB0byB1c2UgY2FjaGVkIEdFVHMKCi0tLQogLi4uL05ldHdvcmtQcm9j ZXNzL2NhY2hlL05ldHdvcmtDYWNoZS5jcHAgICAgIHwgMjcgKysrKysrKysrKysrKystLS0tLQog Li4uL05ldHdvcmtQcm9jZXNzL2NhY2hlL05ldHdvcmtDYWNoZS5oICAgICAgIHwgIDMgKystCiAy IGZpbGVzIGNoYW5nZWQsIDIyIGluc2VydGlvbnMoKyksIDggZGVsZXRpb25zKC0pCgpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vzcy9jYWNoZS9OZXR3b3JrQ2FjaGUuY3Bw IGIvU291cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vzcy9jYWNoZS9OZXR3b3JrQ2FjaGUuY3BwCmlu ZGV4IGYzNDRkMWFiYTY0Li5mNzJiMTgwYjM5MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9O ZXR3b3JrUHJvY2Vzcy9jYWNoZS9OZXR3b3JrQ2FjaGUuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQv TmV0d29ya1Byb2Nlc3MvY2FjaGUvTmV0d29ya0NhY2hlLmNwcApAQCAtMTgzLDcgKzE4Myw3IEBA IHN0YXRpYyBib29sIHJlc3BvbnNlTmVlZHNSZXZhbGlkYXRpb24oY29uc3QgV2ViQ29yZTo6UmVz b3VyY2VSZXNwb25zZSYgcmVzcG9uc2UsCiAgICAgcmV0dXJuIHJlc3BvbnNlSGFzRXhwaXJlZChy ZXNwb25zZSwgdGltZXN0YW1wLCByZXF1ZXN0RGlyZWN0aXZlcy5tYXhTdGFsZSk7CiB9CiAKLXN0 YXRpYyBVc2VEZWNpc2lvbiBtYWtlVXNlRGVjaXNpb24oTmV0d29ya1Byb2Nlc3MmIG5ldHdvcmtQ cm9jZXNzLCBjb25zdCBQQUw6OlNlc3Npb25JRCYgc2Vzc2lvbklELCBjb25zdCBFbnRyeSYgZW50 cnksIGNvbnN0IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKK3N0YXRpYyBVc2VE ZWNpc2lvbiBtYWtlVXNlRGVjaXNpb25JbnRlcm5hbChOZXR3b3JrUHJvY2VzcyYgbmV0d29ya1By b2Nlc3MsIGNvbnN0IFBBTDo6U2Vzc2lvbklEJiBzZXNzaW9uSUQsIGNvbnN0IEVudHJ5JiBlbnRy eSwgY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQogewogICAgIC8vIFRo ZSByZXF1ZXN0IGlzIGNvbmRpdGlvbmFsIHNvIHdlIGZvcmNlIHJldmFsaWRhdGlvbiBmcm9tIHRo ZSBuZXR3b3JrLiBXZSBtZXJlbHkgY2hlY2sgdGhlIGRpc2sgY2FjaGUKICAgICAvLyBzbyB3ZSBj YW4gdXBkYXRlIHRoZSBjYWNoZSBlbnRyeS4KQEAgLTIwNiwxMiArMjA2LDIwIEBAIHN0YXRpYyBV c2VEZWNpc2lvbiBtYWtlVXNlRGVjaXNpb24oTmV0d29ya1Byb2Nlc3MmIG5ldHdvcmtQcm9jZXNz LCBjb25zdCBQQUw6OlNlCiAgICAgcmV0dXJuIGVudHJ5LnJlZGlyZWN0UmVxdWVzdCgpID8gVXNl RGVjaXNpb246Ok5vRHVlVG9FeHBpcmVkUmVkaXJlY3QgOiBVc2VEZWNpc2lvbjo6VmFsaWRhdGU7 CiB9CiAKLXN0YXRpYyBSZXRyaWV2ZURlY2lzaW9uIG1ha2VSZXRyaWV2ZURlY2lzaW9uKGNvbnN0 IFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCkKK3N0YXRpYyBVc2VEZWNpc2lvbiBt YWtlVXNlRGVjaXNpb24oTmV0d29ya1Byb2Nlc3MmIG5ldHdvcmtQcm9jZXNzLCBjb25zdCBQQUw6 OlNlc3Npb25JRCYgc2Vzc2lvbklELCBjb25zdCBFbnRyeSYgZW50cnksIGNvbnN0IFdlYkNvcmU6 OlJlc291cmNlUmVxdWVzdCYgcmVxdWVzdCwgYm9vbCBpc0hlYWQpIHsKKyAgICBVc2VEZWNpc2lv biBkZWNpc2lvbiA9IG1ha2VVc2VEZWNpc2lvbkludGVybmFsKG5ldHdvcmtQcm9jZXNzLCBzZXNz aW9uSUQsIGVudHJ5LCByZXF1ZXN0KTsKKyAgICBpZiAoZGVjaXNpb24gPT0gVXNlRGVjaXNpb246 OlZhbGlkYXRlICYmIGlzSGVhZCkgeworICAgICAgICAvLyBTZWVtcyBzaWxseSB0byB2YWxpZGF0 ZSBhIEhFQUQsIHNvIGp1c3QgZm9yY2UgdGhlIHJlYWwgcmVxdWVzdCB0byBnbyBvdXQuCisgICAg ICAgIHJldHVybiBVc2VEZWNpc2lvbjo6Tm9EdWVUb0hUVFBNZXRob2Q7CisgICAgfQorICAgIHJl dHVybiBkZWNpc2lvbjsKK30KKworc3RhdGljIFJldHJpZXZlRGVjaXNpb24gbWFrZVJldHJpZXZl RGVjaXNpb24oY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBib29sIGlz SGVhZCkKIHsKICAgICBBU1NFUlQocmVxdWVzdC5jYWNoZVBvbGljeSgpICE9IFdlYkNvcmU6OlJl c291cmNlUmVxdWVzdENhY2hlUG9saWN5OjpEb05vdFVzZUFueUNhY2hlKTsKIAotICAgIC8vIEZJ WE1FOiBTdXBwb3J0IEhFQUQgcmVxdWVzdHMuCi0gICAgaWYgKHJlcXVlc3QuaHR0cE1ldGhvZCgp ICE9ICJHRVQiKQorICAgIGlmIChyZXF1ZXN0Lmh0dHBNZXRob2QoKSAhPSAiR0VUIiAmJiAhaXNI ZWFkKQogICAgICAgICByZXR1cm4gUmV0cmlldmVEZWNpc2lvbjo6Tm9EdWVUb0hUVFBNZXRob2Q7 CiAgICAgaWYgKHJlcXVlc3QuY2FjaGVQb2xpY3koKSA9PSBXZWJDb3JlOjpSZXNvdXJjZVJlcXVl c3RDYWNoZVBvbGljeTo6UmVsb2FkSWdub3JpbmdDYWNoZURhdGEgJiYgIXJlcXVlc3QuaXNDb25k aXRpb25hbCgpKQogICAgICAgICByZXR1cm4gUmV0cmlldmVEZWNpc2lvbjo6Tm9EdWVUb1JlbG9h ZElnbm9yaW5nQ2FjaGU7CkBAIC0zMTUsNyArMzIzLDggQEAgdm9pZCBDYWNoZTo6cmV0cmlldmUo Y29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBHbG9iYWxGcmFt ZUkKICAgICAgICAgbV9zcGVjdWxhdGl2ZUxvYWRNYW5hZ2VyLT5yZWdpc3RlckxvYWQoZnJhbWVJ RCwgcmVxdWVzdCwgc3RvcmFnZUtleSk7CiAjZW5kaWYKIAotICAgIGF1dG8gcmV0cmlldmVEZWNp c2lvbiA9IG1ha2VSZXRyaWV2ZURlY2lzaW9uKHJlcXVlc3QpOworICAgIGJvb2wgaXNIZWFkID0g cmVxdWVzdC5odHRwTWV0aG9kKCkgPT0gIkhFQUQiOworICAgIGF1dG8gcmV0cmlldmVEZWNpc2lv biA9IG1ha2VSZXRyaWV2ZURlY2lzaW9uKHJlcXVlc3QsIGlzSGVhZCk7CiAgICAgaWYgKHJldHJp ZXZlRGVjaXNpb24gIT0gUmV0cmlldmVEZWNpc2lvbjo6WWVzKSB7CiAgICAgICAgIGNvbXBsZXRl UmV0cmlldmUoV1RGTW92ZShjb21wbGV0aW9uSGFuZGxlciksIG51bGxwdHIsIGluZm8pOwogICAg ICAgICByZXR1cm47CkBAIC0zMzQsNyArMzQzLDcgQEAgdm9pZCBDYWNoZTo6cmV0cmlldmUoY29u c3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0LCBjb25zdCBHbG9iYWxGcmFtZUkK ICAgICB9CiAjZW5kaWYKIAotICAgIG1fc3RvcmFnZS0+cmV0cmlldmUoc3RvcmFnZUtleSwgcHJp b3JpdHksIFtyZXF1ZXN0LCBjb21wbGV0aW9uSGFuZGxlciA9IFdURk1vdmUoY29tcGxldGlvbkhh bmRsZXIpLCBpbmZvID0gV1RGTW92ZShpbmZvKSwgc3RvcmFnZUtleSwgbmV0d29ya1Byb2Nlc3Mg PSBtYWtlUmVmKG5ldHdvcmtQcm9jZXNzKCkpLCBzZXNzaW9uSUQgPSBtX3Nlc3Npb25JRF0oYXV0 byByZWNvcmQsIGF1dG8gdGltaW5ncykgbXV0YWJsZSB7CisgICAgbV9zdG9yYWdlLT5yZXRyaWV2 ZShzdG9yYWdlS2V5LCBwcmlvcml0eSwgW3JlcXVlc3QsIGlzSGVhZCwgY29tcGxldGlvbkhhbmRs ZXIgPSBXVEZNb3ZlKGNvbXBsZXRpb25IYW5kbGVyKSwgaW5mbyA9IFdURk1vdmUoaW5mbyksIHN0 b3JhZ2VLZXksIG5ldHdvcmtQcm9jZXNzID0gbWFrZVJlZihuZXR3b3JrUHJvY2VzcygpKSwgc2Vz c2lvbklEID0gbV9zZXNzaW9uSURdKGF1dG8gcmVjb3JkLCBhdXRvIHRpbWluZ3MpIG11dGFibGUg ewogICAgICAgICBpbmZvLnN0b3JhZ2VUaW1pbmdzID0gdGltaW5nczsKIAogICAgICAgICBpZiAo IXJlY29yZCkgewpAQCAtMzQ2LDkgKzM1NSwxMyBAQCB2b2lkIENhY2hlOjpyZXRyaWV2ZShjb25z dCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3QmIHJlcXVlc3QsIGNvbnN0IEdsb2JhbEZyYW1lSQog CiAgICAgICAgIEFTU0VSVChyZWNvcmQtPmtleSA9PSBzdG9yYWdlS2V5KTsKIAorICAgICAgICBp ZiAoaXNIZWFkKSB7CisgICAgICAgICAgICByZWNvcmQtPmJvZHkgPSBEYXRhOjplbXB0eSgpOwor ICAgICAgICB9CisKICAgICAgICAgYXV0byBlbnRyeSA9IEVudHJ5OjpkZWNvZGVTdG9yYWdlUmVj b3JkKCpyZWNvcmQpOwogCi0gICAgICAgIGF1dG8gdXNlRGVjaXNpb24gPSBlbnRyeSA/IG1ha2VV c2VEZWNpc2lvbihuZXR3b3JrUHJvY2Vzcywgc2Vzc2lvbklELCAqZW50cnksIHJlcXVlc3QpIDog VXNlRGVjaXNpb246Ok5vRHVlVG9EZWNvZGVGYWlsdXJlOworICAgICAgICBhdXRvIHVzZURlY2lz aW9uID0gZW50cnkgPyBtYWtlVXNlRGVjaXNpb24obmV0d29ya1Byb2Nlc3MsIHNlc3Npb25JRCwg KmVudHJ5LCByZXF1ZXN0LCBpc0hlYWQpIDogVXNlRGVjaXNpb246Ok5vRHVlVG9EZWNvZGVGYWls dXJlOwogICAgICAgICBzd2l0Y2ggKHVzZURlY2lzaW9uKSB7CiAgICAgICAgIGNhc2UgVXNlRGVj aXNpb246OlVzZToKICAgICAgICAgICAgIGJyZWFrOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9OZXR3b3JrUHJvY2Vzcy9jYWNoZS9OZXR3b3JrQ2FjaGUuaCBiL1NvdXJjZS9XZWJLaXQvTmV0 d29ya1Byb2Nlc3MvY2FjaGUvTmV0d29ya0NhY2hlLmgKaW5kZXggMGRlZTdmODhkZmYuLjZiZmU1 YjQxMGUwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL2NhY2hlL05l dHdvcmtDYWNoZS5oCisrKyBiL1NvdXJjZS9XZWJLaXQvTmV0d29ya1Byb2Nlc3MvY2FjaGUvTmV0 d29ya0NhY2hlLmgKQEAgLTg1LDcgKzg1LDggQEAgZW51bSBjbGFzcyBVc2VEZWNpc2lvbiB7CiAg ICAgTm9EdWVUb1ZhcnlpbmdIZWFkZXJNaXNtYXRjaCwKICAgICBOb0R1ZVRvTWlzc2luZ1ZhbGlk YXRvckZpZWxkcywKICAgICBOb0R1ZVRvRGVjb2RlRmFpbHVyZSwKLSAgICBOb0R1ZVRvRXhwaXJl ZFJlZGlyZWN0CisgICAgTm9EdWVUb0V4cGlyZWRSZWRpcmVjdCwKKyAgICBOb0R1ZVRvSFRUUE1l dGhvZAogfTsKIAogc3RydWN0IEdsb2JhbEZyYW1lSUQgewotLSAKMi4yMS4wIChBcHBsZSBHaXQt MTIyKQoK 382238 2019-10-29 15:29:15 -0700 2019-11-05 09:01:00 -0800 WIP: cache HEADs as well as GETs 0001-WIP-cache-HEADs-as-well-as-GETs.diff text/plain 2529 nham RnJvbSA1ODliNjdmZjdjYjgxMTAyNGJhM2QyNjJhYzc1MTI4NzJkYWYzODQzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBCZW5qYW1pbiBOaGFtIDxuaGFtQGFwcGxlLmNvbT4KRGF0ZTog TW9uLCAyOCBPY3QgMjAxOSAxNjo0NTo1OCAtMDcwMApTdWJqZWN0OiBbUEFUQ0hdIFdJUDogY2Fj aGUgSEVBRHMgYXMgd2VsbCBhcyBHRVRzCgotLS0KIC4uLi9XZWJLaXQvTmV0d29ya1Byb2Nlc3Mv Y2FjaGUvTmV0d29ya0NhY2hlLmNwcCAgfCAxNSArKysrKysrKysrKy0tLS0KIDEgZmlsZSBjaGFu Z2VkLCAxMSBpbnNlcnRpb25zKCspLCA0IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQvTmV0d29ya1Byb2Nlc3MvY2FjaGUvTmV0d29ya0NhY2hlLmNwcCBiL1NvdXJjZS9X ZWJLaXQvTmV0d29ya1Byb2Nlc3MvY2FjaGUvTmV0d29ya0NhY2hlLmNwcAppbmRleCBmMzQ0ZDFh YmE2NC4uNGY3OTY0NGVmOWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvTmV0d29ya1Byb2Nl c3MvY2FjaGUvTmV0d29ya0NhY2hlLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9j ZXNzL2NhY2hlL05ldHdvcmtDYWNoZS5jcHAKQEAgLTEzMiw3ICsxMzIsMTUgQEAgS2V5IENhY2hl OjptYWtlQ2FjaGVLZXkoY29uc3QgV2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0JiByZXF1ZXN0KQog ICAgIC8vIEZJWE1FOiBUaGlzIGltcGxlbWVudHMgbWluaW1hbCBSYW5nZSBoZWFkZXIgZGlzayBj YWNoZSBzdXBwb3J0LiBXZSBkb24ndCBwYXJzZQogICAgIC8vIHJhbmdlcyBzbyBvbmx5IHRoZSBz YW1lIGV4YWN0IHJhbmdlIHJlcXVlc3Qgd2lsbCBiZSBzZXJ2ZWQgZnJvbSB0aGUgY2FjaGUuCiAg ICAgU3RyaW5nIHJhbmdlID0gcmVxdWVzdC5odHRwSGVhZGVyRmllbGQoV2ViQ29yZTo6SFRUUEhl YWRlck5hbWU6OlJhbmdlKTsKLSAgICByZXR1cm4geyByZXF1ZXN0LmNhY2hlUGFydGl0aW9uKCks IHJlc291cmNlVHlwZSgpLCByYW5nZSwgcmVxdWVzdC51cmwoKS5zdHJpbmcoKSwgbV9zdG9yYWdl LT5zYWx0KCkgfTsKKyAgICBTdHJpbmcgaWQgPSByZXF1ZXN0LnVybCgpLnN0cmluZygpOworCisg ICAgaWYgKHJlcXVlc3QuaHR0cE1ldGhvZCgpID09ICJIRUFEIikgeworICAgICAgICBTdHJpbmcg dG1wKCJIRUFEICIpOworICAgICAgICB0bXAuYXBwZW5kKGlkKTsKKyAgICAgICAgaWQuc3dhcCh0 bXApOworICAgIH0KKworICAgIHJldHVybiB7IHJlcXVlc3QuY2FjaGVQYXJ0aXRpb24oKSwgcmVz b3VyY2VUeXBlKCksIHJhbmdlLCBpZCwgbV9zdG9yYWdlLT5zYWx0KCkgfTsKIH0KIAogc3RhdGlj IGJvb2wgY2FjaGVQb2xpY3lBbGxvd3NFeHBpcmVkKFdlYkNvcmU6OlJlc291cmNlUmVxdWVzdENh Y2hlUG9saWN5IHBvbGljeSkKQEAgLTIxMCw4ICsyMTgsNyBAQCBzdGF0aWMgUmV0cmlldmVEZWNp c2lvbiBtYWtlUmV0cmlldmVEZWNpc2lvbihjb25zdCBXZWJDb3JlOjpSZXNvdXJjZVJlcXVlc3Qm IHJlcQogewogICAgIEFTU0VSVChyZXF1ZXN0LmNhY2hlUG9saWN5KCkgIT0gV2ViQ29yZTo6UmVz b3VyY2VSZXF1ZXN0Q2FjaGVQb2xpY3k6OkRvTm90VXNlQW55Q2FjaGUpOwogCi0gICAgLy8gRklY TUU6IFN1cHBvcnQgSEVBRCByZXF1ZXN0cy4KLSAgICBpZiAocmVxdWVzdC5odHRwTWV0aG9kKCkg IT0gIkdFVCIpCisgICAgaWYgKHJlcXVlc3QuaHR0cE1ldGhvZCgpICE9ICJHRVQiICYmIHJlcXVl c3QuaHR0cE1ldGhvZCgpICE9ICJIRUFEIikKICAgICAgICAgcmV0dXJuIFJldHJpZXZlRGVjaXNp b246Ok5vRHVlVG9IVFRQTWV0aG9kOwogICAgIGlmIChyZXF1ZXN0LmNhY2hlUG9saWN5KCkgPT0g V2ViQ29yZTo6UmVzb3VyY2VSZXF1ZXN0Q2FjaGVQb2xpY3k6OlJlbG9hZElnbm9yaW5nQ2FjaGVE YXRhICYmICFyZXF1ZXN0LmlzQ29uZGl0aW9uYWwoKSkKICAgICAgICAgcmV0dXJuIFJldHJpZXZl RGVjaXNpb246Ok5vRHVlVG9SZWxvYWRJZ25vcmluZ0NhY2hlOwpAQCAtMjI5LDcgKzIzNiw3IEBA IHN0YXRpYyBTdG9yZURlY2lzaW9uIG1ha2VTdG9yZURlY2lzaW9uKGNvbnN0IFdlYkNvcmU6OlJl c291cmNlUmVxdWVzdCYgb3JpZ2luYWxSCiAgICAgaWYgKCFvcmlnaW5hbFJlcXVlc3QudXJsKCku cHJvdG9jb2xJc0luSFRUUEZhbWlseSgpIHx8ICFyZXNwb25zZS5pc0hUVFAoKSkKICAgICAgICAg cmV0dXJuIFN0b3JlRGVjaXNpb246Ok5vRHVlVG9Qcm90b2NvbDsKIAotICAgIGlmIChvcmlnaW5h bFJlcXVlc3QuaHR0cE1ldGhvZCgpICE9ICJHRVQiKQorICAgIGlmIChvcmlnaW5hbFJlcXVlc3Qu aHR0cE1ldGhvZCgpICE9ICJHRVQiICYmIG9yaWdpbmFsUmVxdWVzdC5odHRwTWV0aG9kKCkgIT0g IkhFQUQiKQogICAgICAgICByZXR1cm4gU3RvcmVEZWNpc2lvbjo6Tm9EdWVUb0hUVFBNZXRob2Q7 CiAKICAgICBhdXRvIHJlcXVlc3REaXJlY3RpdmVzID0gV2ViQ29yZTo6cGFyc2VDYWNoZUNvbnRy b2xEaXJlY3RpdmVzKG9yaWdpbmFsUmVxdWVzdC5odHRwSGVhZGVyRmllbGRzKCkpOwotLSAKMi4y MS4wIChBcHBsZSBHaXQtMTIyKQoK