| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (c) 2014, Google Inc. All rights reserved. | |
| 3 * | |
| 4 * Redistribution and use in source and binary forms, with or without | |
| 5 * modification, are permitted provided that the following conditions are | |
| 6 * met: | |
| 7 * | |
| 8 * * Redistributions of source code must retain the above copyright | |
| 9 * notice, this list of conditions and the following disclaimer. | |
| 10 * * Redistributions in binary form must reproduce the above | |
| 11 * copyright notice, this list of conditions and the following disclaimer | |
| 12 * in the documentation and/or other materials provided with the | |
| 13 * distribution. | |
| 14 * * Neither the name of Google Inc. nor the names of its | |
| 15 * contributors may be used to endorse or promote products derived from | |
| 16 * this software without specific prior written permission. | |
| 17 * | |
| 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
| 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
| 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
| 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
| 22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
| 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
| 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
| 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
| 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 29 */ | |
| 30 | |
| 31 #include "sky/engine/config.h" | |
| 32 | |
| 33 #include "sky/engine/core/fetch/ImageResource.h" | |
| 34 #include "sky/engine/core/fetch/MemoryCache.h" | |
| 35 #include "sky/engine/core/fetch/Resource.h" | |
| 36 #include "sky/engine/core/fetch/ResourceFetcher.h" | |
| 37 #include "sky/engine/core/fetch/ResourcePtr.h" | |
| 38 #include "sky/engine/core/html/HTMLDocument.h" | |
| 39 #include "sky/engine/platform/network/ResourceRequest.h" | |
| 40 #include "sky/engine/public/platform/Platform.h" | |
| 41 #include "sky/engine/wtf/OwnPtr.h" | |
| 42 #include "sky/engine/wtf/RefPtr.h" | |
| 43 | |
| 44 #include <gtest/gtest.h> | |
| 45 | |
| 46 using namespace blink; | |
| 47 | |
| 48 namespace { | |
| 49 | |
| 50 // An URL for the original request. | |
| 51 const char kResourceURL[] = "http://resource.com/"; | |
| 52 | |
| 53 // The origin time of our first request. | |
| 54 const char kOriginalRequestDateAsString[] = "Thu, 25 May 1977 18:30:00 GMT"; | |
| 55 const double kOriginalRequestDateAsDouble = 233433000.; | |
| 56 | |
| 57 const char kOneDayBeforeOriginalRequest[] = "Wed, 24 May 1977 18:30:00 GMT"; | |
| 58 const char kOneDayAfterOriginalRequest[] = "Fri, 26 May 1977 18:30:00 GMT"; | |
| 59 | |
| 60 const unsigned char kAConstUnsignedCharZero = 0; | |
| 61 | |
| 62 class CachingCorrectnessTest : public ::testing::Test { | |
| 63 protected: | |
| 64 void advanceClock(double seconds) | |
| 65 { | |
| 66 m_proxyPlatform.advanceClock(seconds); | |
| 67 } | |
| 68 | |
| 69 ResourcePtr<Resource> resourceFromResourceResponse(ResourceResponse response
, Resource::Type type = Resource::Raw) | |
| 70 { | |
| 71 if (response.url().isNull()) | |
| 72 response.setURL(KURL(ParsedURLString, kResourceURL)); | |
| 73 ResourcePtr<Resource> resource = | |
| 74 new Resource(ResourceRequest(response.url()), type); | |
| 75 resource->setResponse(response); | |
| 76 memoryCache()->add(resource.get()); | |
| 77 | |
| 78 return resource; | |
| 79 } | |
| 80 | |
| 81 ResourcePtr<Resource> resourceFromResourceRequest(ResourceRequest request, R
esource::Type type = Resource::Raw) | |
| 82 { | |
| 83 if (request.url().isNull()) | |
| 84 request.setURL(KURL(ParsedURLString, kResourceURL)); | |
| 85 ResourcePtr<Resource> resource = | |
| 86 new Resource(request, type); | |
| 87 resource->setResponse(ResourceResponse(KURL(ParsedURLString, kResourceUR
L), "text/html", 0, nullAtom, String())); | |
| 88 memoryCache()->add(resource.get()); | |
| 89 | |
| 90 return resource; | |
| 91 } | |
| 92 | |
| 93 ResourcePtr<Resource> fetchImage() | |
| 94 { | |
| 95 FetchRequest fetchRequest(ResourceRequest(KURL(ParsedURLString, kResourc
eURL)), FetchInitiatorInfo()); | |
| 96 return m_fetcher->fetchImage(fetchRequest); | |
| 97 } | |
| 98 | |
| 99 ResourceFetcher* fetcher() const { return m_fetcher.get(); } | |
| 100 | |
| 101 private: | |
| 102 // A simple platform that mocks out the clock, for cache freshness testing. | |
| 103 class ProxyPlatform : public blink::Platform { | |
| 104 public: | |
| 105 ProxyPlatform() : m_elapsedSeconds(0.) { } | |
| 106 | |
| 107 void advanceClock(double seconds) | |
| 108 { | |
| 109 m_elapsedSeconds += seconds; | |
| 110 } | |
| 111 | |
| 112 private: | |
| 113 // From blink::Platform: | |
| 114 virtual double currentTime() | |
| 115 { | |
| 116 return kOriginalRequestDateAsDouble + m_elapsedSeconds; | |
| 117 } | |
| 118 | |
| 119 // These blink::Platform methods must be overriden to make a usable obje
ct. | |
| 120 virtual const unsigned char* getTraceCategoryEnabledFlag(const char* cat
egoryName) | |
| 121 { | |
| 122 return &kAConstUnsignedCharZero; | |
| 123 } | |
| 124 | |
| 125 double m_elapsedSeconds; | |
| 126 }; | |
| 127 | |
| 128 virtual void SetUp() | |
| 129 { | |
| 130 m_savedPlatform = blink::Platform::current(); | |
| 131 blink::Platform::initialize(&m_proxyPlatform); | |
| 132 | |
| 133 // Save the global memory cache to restore it upon teardown. | |
| 134 m_globalMemoryCache = replaceMemoryCacheForTesting(MemoryCache::create()
); | |
| 135 | |
| 136 // Create a ResourceFetcher that has a real Document, but is not attache
d to a LocalFrame. | |
| 137 const KURL kDocumentURL(ParsedURLString, "http://document.com/"); | |
| 138 m_document = HTMLDocument::create(); | |
| 139 m_fetcher = ResourceFetcher::create(m_document.get()); | |
| 140 } | |
| 141 | |
| 142 virtual void TearDown() | |
| 143 { | |
| 144 memoryCache()->evictResources(); | |
| 145 | |
| 146 // Yield the ownership of the global memory cache back. | |
| 147 replaceMemoryCacheForTesting(m_globalMemoryCache.release()); | |
| 148 | |
| 149 blink::Platform::initialize(m_savedPlatform); | |
| 150 } | |
| 151 | |
| 152 blink::Platform* m_savedPlatform; | |
| 153 ProxyPlatform m_proxyPlatform; | |
| 154 | |
| 155 OwnPtr<MemoryCache> m_globalMemoryCache; | |
| 156 | |
| 157 RefPtr<HTMLDocument> m_document; | |
| 158 RefPtr<ResourceFetcher> m_fetcher; | |
| 159 }; | |
| 160 | |
| 161 TEST_F(CachingCorrectnessTest, FreshFromLastModified) | |
| 162 { | |
| 163 ResourceResponse fresh200Response; | |
| 164 fresh200Response.setHTTPStatusCode(200); | |
| 165 fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 166 fresh200Response.setHTTPHeaderField("Last-Modified", kOneDayBeforeOriginalRe
quest); | |
| 167 | |
| 168 ResourcePtr<Resource> fresh200 = resourceFromResourceResponse(fresh200Respon
se); | |
| 169 | |
| 170 // Advance the clock within the implicit freshness period of this resource b
efore we make a request. | |
| 171 advanceClock(600.); | |
| 172 | |
| 173 ResourcePtr<Resource> fetched = fetch(); | |
| 174 EXPECT_EQ(fresh200, fetched); | |
| 175 } | |
| 176 | |
| 177 TEST_F(CachingCorrectnessTest, FreshFromExpires) | |
| 178 { | |
| 179 ResourceResponse fresh200Response; | |
| 180 fresh200Response.setHTTPStatusCode(200); | |
| 181 fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 182 fresh200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest); | |
| 183 | |
| 184 ResourcePtr<Resource> fresh200 = resourceFromResourceResponse(fresh200Respon
se); | |
| 185 | |
| 186 // Advance the clock within the freshness period of this resource before we
make a request. | |
| 187 advanceClock(24. * 60. * 60. - 15.); | |
| 188 | |
| 189 ResourcePtr<Resource> fetched = fetch(); | |
| 190 EXPECT_EQ(fresh200, fetched); | |
| 191 } | |
| 192 | |
| 193 TEST_F(CachingCorrectnessTest, FreshFromMaxAge) | |
| 194 { | |
| 195 ResourceResponse fresh200Response; | |
| 196 fresh200Response.setHTTPStatusCode(200); | |
| 197 fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 198 fresh200Response.setHTTPHeaderField("Cache-Control", "max-age=600"); | |
| 199 | |
| 200 ResourcePtr<Resource> fresh200 = resourceFromResourceResponse(fresh200Respon
se); | |
| 201 | |
| 202 // Advance the clock within the freshness period of this resource before we
make a request. | |
| 203 advanceClock(500.); | |
| 204 | |
| 205 ResourcePtr<Resource> fetched = fetch(); | |
| 206 EXPECT_EQ(fresh200, fetched); | |
| 207 } | |
| 208 | |
| 209 // The strong validator causes a revalidation to be launched, and the proxy and
original resources leak because of their reference loop. | |
| 210 TEST_F(CachingCorrectnessTest, DISABLED_ExpiredFromLastModified) | |
| 211 { | |
| 212 ResourceResponse expired200Response; | |
| 213 expired200Response.setHTTPStatusCode(200); | |
| 214 expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 215 expired200Response.setHTTPHeaderField("Last-Modified", kOneDayBeforeOriginal
Request); | |
| 216 | |
| 217 ResourcePtr<Resource> expired200 = resourceFromResourceResponse(expired200Re
sponse); | |
| 218 | |
| 219 // Advance the clock beyond the implicit freshness period. | |
| 220 advanceClock(24. * 60. * 60. * 0.2); | |
| 221 | |
| 222 ResourcePtr<Resource> fetched = fetch(); | |
| 223 EXPECT_NE(expired200, fetched); | |
| 224 } | |
| 225 | |
| 226 TEST_F(CachingCorrectnessTest, ExpiredFromExpires) | |
| 227 { | |
| 228 ResourceResponse expired200Response; | |
| 229 expired200Response.setHTTPStatusCode(200); | |
| 230 expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 231 expired200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest
); | |
| 232 | |
| 233 ResourcePtr<Resource> expired200 = resourceFromResourceResponse(expired200Re
sponse); | |
| 234 | |
| 235 // Advance the clock within the expiredness period of this resource before w
e make a request. | |
| 236 advanceClock(24. * 60. * 60. + 15.); | |
| 237 | |
| 238 ResourcePtr<Resource> fetched = fetch(); | |
| 239 EXPECT_NE(expired200, fetched); | |
| 240 } | |
| 241 | |
| 242 // If the image hasn't been loaded in this "document" before, then it shouldn't
have list of available images logic. | |
| 243 TEST_F(CachingCorrectnessTest, NewImageExpiredFromExpires) | |
| 244 { | |
| 245 ResourceResponse expired200Response; | |
| 246 expired200Response.setHTTPStatusCode(200); | |
| 247 expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 248 expired200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest
); | |
| 249 | |
| 250 ResourcePtr<Resource> expired200 = resourceFromResourceResponse(expired200Re
sponse, Resource::Image); | |
| 251 | |
| 252 // Advance the clock within the expiredness period of this resource before w
e make a request. | |
| 253 advanceClock(24. * 60. * 60. + 15.); | |
| 254 | |
| 255 ResourcePtr<Resource> fetched = fetchImage(); | |
| 256 EXPECT_NE(expired200, fetched); | |
| 257 } | |
| 258 | |
| 259 // If the image has been loaded in this "document" before, then it should have l
ist of available images logic, and so | |
| 260 // normal cache testing should be bypassed. | |
| 261 TEST_F(CachingCorrectnessTest, ReuseImageExpiredFromExpires) | |
| 262 { | |
| 263 ResourceResponse expired200Response; | |
| 264 expired200Response.setHTTPStatusCode(200); | |
| 265 expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 266 expired200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest
); | |
| 267 | |
| 268 ResourcePtr<Resource> expired200 = resourceFromResourceResponse(expired200Re
sponse, Resource::Image); | |
| 269 | |
| 270 // Advance the clock within the freshness period, and make a request to add
this image to the document resources. | |
| 271 advanceClock(15.); | |
| 272 ResourcePtr<Resource> firstFetched = fetchImage(); | |
| 273 EXPECT_EQ(expired200, firstFetched); | |
| 274 | |
| 275 // Advance the clock within the expiredness period of this resource before w
e make a request. | |
| 276 advanceClock(24. * 60. * 60. + 15.); | |
| 277 | |
| 278 ResourcePtr<Resource> fetched = fetchImage(); | |
| 279 EXPECT_EQ(expired200, fetched); | |
| 280 } | |
| 281 | |
| 282 TEST_F(CachingCorrectnessTest, ExpiredFromMaxAge) | |
| 283 { | |
| 284 ResourceResponse expired200Response; | |
| 285 expired200Response.setHTTPStatusCode(200); | |
| 286 expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 287 expired200Response.setHTTPHeaderField("Cache-Control", "max-age=600"); | |
| 288 | |
| 289 ResourcePtr<Resource> expired200 = resourceFromResourceResponse(expired200Re
sponse); | |
| 290 | |
| 291 // Advance the clock within the expiredness period of this resource before w
e make a request. | |
| 292 advanceClock(700.); | |
| 293 | |
| 294 ResourcePtr<Resource> fetched = fetch(); | |
| 295 EXPECT_NE(expired200, fetched); | |
| 296 } | |
| 297 | |
| 298 TEST_F(CachingCorrectnessTest, FreshButNoCache) | |
| 299 { | |
| 300 ResourceResponse fresh200NocacheResponse; | |
| 301 fresh200NocacheResponse.setHTTPStatusCode(200); | |
| 302 fresh200NocacheResponse.setHTTPHeaderField("Date", kOriginalRequestDateAsStr
ing); | |
| 303 fresh200NocacheResponse.setHTTPHeaderField("Expires", kOneDayAfterOriginalRe
quest); | |
| 304 fresh200NocacheResponse.setHTTPHeaderField("Cache-Control", "no-cache"); | |
| 305 | |
| 306 ResourcePtr<Resource> fresh200Nocache = resourceFromResourceResponse(fresh20
0NocacheResponse); | |
| 307 | |
| 308 // Advance the clock within the freshness period of this resource before we
make a request. | |
| 309 advanceClock(24. * 60. * 60. - 15.); | |
| 310 | |
| 311 ResourcePtr<Resource> fetched = fetch(); | |
| 312 EXPECT_NE(fresh200Nocache, fetched); | |
| 313 } | |
| 314 | |
| 315 TEST_F(CachingCorrectnessTest, RequestWithNoCahe) | |
| 316 { | |
| 317 ResourceRequest noCacheRequest; | |
| 318 noCacheRequest.setHTTPHeaderField("Cache-Control", "no-cache"); | |
| 319 ResourcePtr<Resource> noCacheResource = resourceFromResourceRequest(noCacheR
equest); | |
| 320 ResourcePtr<Resource> fetched = fetch(); | |
| 321 EXPECT_NE(noCacheResource, fetched); | |
| 322 } | |
| 323 | |
| 324 TEST_F(CachingCorrectnessTest, FreshButNoStore) | |
| 325 { | |
| 326 ResourceResponse fresh200NostoreResponse; | |
| 327 fresh200NostoreResponse.setHTTPStatusCode(200); | |
| 328 fresh200NostoreResponse.setHTTPHeaderField("Date", kOriginalRequestDateAsStr
ing); | |
| 329 fresh200NostoreResponse.setHTTPHeaderField("Expires", kOneDayAfterOriginalRe
quest); | |
| 330 fresh200NostoreResponse.setHTTPHeaderField("Cache-Control", "no-store"); | |
| 331 | |
| 332 ResourcePtr<Resource> fresh200Nostore = resourceFromResourceResponse(fresh20
0NostoreResponse); | |
| 333 | |
| 334 // Advance the clock within the freshness period of this resource before we
make a request. | |
| 335 advanceClock(24. * 60. * 60. - 15.); | |
| 336 | |
| 337 ResourcePtr<Resource> fetched = fetch(); | |
| 338 EXPECT_NE(fresh200Nostore, fetched); | |
| 339 } | |
| 340 | |
| 341 TEST_F(CachingCorrectnessTest, RequestWithNoStore) | |
| 342 { | |
| 343 ResourceRequest noStoreRequest; | |
| 344 noStoreRequest.setHTTPHeaderField("Cache-Control", "no-store"); | |
| 345 ResourcePtr<Resource> noStoreResource = resourceFromResourceRequest(noStoreR
equest); | |
| 346 ResourcePtr<Resource> fetched = fetch(); | |
| 347 EXPECT_NE(noStoreResource, fetched); | |
| 348 } | |
| 349 | |
| 350 // FIXME: Determine if ignoring must-revalidate for blink is correct behaviour. | |
| 351 // See crbug.com/340088 . | |
| 352 TEST_F(CachingCorrectnessTest, DISABLED_FreshButMustRevalidate) | |
| 353 { | |
| 354 ResourceResponse fresh200MustRevalidateResponse; | |
| 355 fresh200MustRevalidateResponse.setHTTPStatusCode(200); | |
| 356 fresh200MustRevalidateResponse.setHTTPHeaderField("Date", kOriginalRequestDa
teAsString); | |
| 357 fresh200MustRevalidateResponse.setHTTPHeaderField("Expires", kOneDayAfterOri
ginalRequest); | |
| 358 fresh200MustRevalidateResponse.setHTTPHeaderField("Cache-Control", "must-rev
alidate"); | |
| 359 | |
| 360 ResourcePtr<Resource> fresh200MustRevalidate = resourceFromResourceResponse(
fresh200MustRevalidateResponse); | |
| 361 | |
| 362 // Advance the clock within the freshness period of this resource before we
make a request. | |
| 363 advanceClock(24. * 60. * 60. - 15.); | |
| 364 | |
| 365 ResourcePtr<Resource> fetched = fetch(); | |
| 366 EXPECT_NE(fresh200MustRevalidate, fetched); | |
| 367 } | |
| 368 | |
| 369 TEST_F(CachingCorrectnessTest, FreshWithFreshRedirect) | |
| 370 { | |
| 371 KURL redirectUrl(ParsedURLString, kResourceURL); | |
| 372 const char redirectTargetUrlString[] = "http://redirect-target.com"; | |
| 373 KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString); | |
| 374 | |
| 375 ResourcePtr<Resource> firstResource = new Resource(ResourceRequest(redirectU
rl), Resource::Raw); | |
| 376 | |
| 377 ResourceResponse fresh301Response; | |
| 378 fresh301Response.setURL(redirectUrl); | |
| 379 fresh301Response.setHTTPStatusCode(301); | |
| 380 fresh301Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 381 fresh301Response.setHTTPHeaderField("Location", redirectTargetUrlString); | |
| 382 fresh301Response.setHTTPHeaderField("Cache-Control", "max-age=600"); | |
| 383 | |
| 384 // Add the redirect to our request. | |
| 385 ResourceRequest redirectRequest = ResourceRequest(redirectTargetUrl); | |
| 386 firstResource->willSendRequest(redirectRequest, fresh301Response); | |
| 387 | |
| 388 // Add the final response to our request. | |
| 389 ResourceResponse fresh200Response; | |
| 390 fresh200Response.setURL(redirectTargetUrl); | |
| 391 fresh200Response.setHTTPStatusCode(200); | |
| 392 fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 393 fresh200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest); | |
| 394 | |
| 395 firstResource->setResponse(fresh200Response); | |
| 396 memoryCache()->add(firstResource.get()); | |
| 397 | |
| 398 advanceClock(500.); | |
| 399 | |
| 400 ResourcePtr<Resource> fetched = fetch(); | |
| 401 EXPECT_EQ(firstResource, fetched); | |
| 402 } | |
| 403 | |
| 404 TEST_F(CachingCorrectnessTest, FreshWithStaleRedirect) | |
| 405 { | |
| 406 KURL redirectUrl(ParsedURLString, kResourceURL); | |
| 407 const char redirectTargetUrlString[] = "http://redirect-target.com"; | |
| 408 KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString); | |
| 409 | |
| 410 ResourcePtr<Resource> firstResource = new Resource(ResourceRequest(redirectU
rl), Resource::Raw); | |
| 411 | |
| 412 ResourceResponse stale301Response; | |
| 413 stale301Response.setURL(redirectUrl); | |
| 414 stale301Response.setHTTPStatusCode(301); | |
| 415 stale301Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 416 stale301Response.setHTTPHeaderField("Location", redirectTargetUrlString); | |
| 417 | |
| 418 // Add the redirect to our request. | |
| 419 ResourceRequest redirectRequest = ResourceRequest(redirectTargetUrl); | |
| 420 firstResource->willSendRequest(redirectRequest, stale301Response); | |
| 421 | |
| 422 // Add the final response to our request. | |
| 423 ResourceResponse fresh200Response; | |
| 424 fresh200Response.setURL(redirectTargetUrl); | |
| 425 fresh200Response.setHTTPStatusCode(200); | |
| 426 fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 427 fresh200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest); | |
| 428 | |
| 429 firstResource->setResponse(fresh200Response); | |
| 430 memoryCache()->add(firstResource.get()); | |
| 431 | |
| 432 advanceClock(500.); | |
| 433 | |
| 434 ResourcePtr<Resource> fetched = fetch(); | |
| 435 EXPECT_NE(firstResource, fetched); | |
| 436 } | |
| 437 | |
| 438 TEST_F(CachingCorrectnessTest, 302RedirectNotImplicitlyFresh) | |
| 439 { | |
| 440 KURL redirectUrl(ParsedURLString, kResourceURL); | |
| 441 const char redirectTargetUrlString[] = "http://redirect-target.com"; | |
| 442 KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString); | |
| 443 | |
| 444 ResourcePtr<Resource> firstResource = new Resource(ResourceRequest(redirectU
rl), Resource::Raw); | |
| 445 | |
| 446 ResourceResponse fresh302Response; | |
| 447 fresh302Response.setURL(redirectUrl); | |
| 448 fresh302Response.setHTTPStatusCode(302); | |
| 449 fresh302Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 450 fresh302Response.setHTTPHeaderField("Last-Modified", kOneDayBeforeOriginalRe
quest); | |
| 451 fresh302Response.setHTTPHeaderField("Location", redirectTargetUrlString); | |
| 452 | |
| 453 // Add the redirect to our request. | |
| 454 ResourceRequest redirectRequest = ResourceRequest(redirectTargetUrl); | |
| 455 firstResource->willSendRequest(redirectRequest, fresh302Response); | |
| 456 | |
| 457 // Add the final response to our request. | |
| 458 ResourceResponse fresh200Response; | |
| 459 fresh200Response.setURL(redirectTargetUrl); | |
| 460 fresh200Response.setHTTPStatusCode(200); | |
| 461 fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 462 fresh200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest); | |
| 463 | |
| 464 firstResource->setResponse(fresh200Response); | |
| 465 memoryCache()->add(firstResource.get()); | |
| 466 | |
| 467 advanceClock(500.); | |
| 468 | |
| 469 ResourcePtr<Resource> fetched = fetch(); | |
| 470 EXPECT_NE(firstResource, fetched); | |
| 471 } | |
| 472 | |
| 473 TEST_F(CachingCorrectnessTest, 302RedirectExplicitlyFreshMaxAge) | |
| 474 { | |
| 475 KURL redirectUrl(ParsedURLString, kResourceURL); | |
| 476 const char redirectTargetUrlString[] = "http://redirect-target.com"; | |
| 477 KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString); | |
| 478 | |
| 479 ResourcePtr<Resource> firstResource = new Resource(ResourceRequest(redirectU
rl), Resource::Raw); | |
| 480 | |
| 481 ResourceResponse fresh302Response; | |
| 482 fresh302Response.setURL(redirectUrl); | |
| 483 fresh302Response.setHTTPStatusCode(302); | |
| 484 fresh302Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 485 fresh302Response.setHTTPHeaderField("Cache-Control", "max-age=600"); | |
| 486 fresh302Response.setHTTPHeaderField("Location", redirectTargetUrlString); | |
| 487 | |
| 488 // Add the redirect to our request. | |
| 489 ResourceRequest redirectRequest = ResourceRequest(redirectTargetUrl); | |
| 490 firstResource->willSendRequest(redirectRequest, fresh302Response); | |
| 491 | |
| 492 // Add the final response to our request. | |
| 493 ResourceResponse fresh200Response; | |
| 494 fresh200Response.setURL(redirectTargetUrl); | |
| 495 fresh200Response.setHTTPStatusCode(200); | |
| 496 fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 497 fresh200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest); | |
| 498 | |
| 499 firstResource->setResponse(fresh200Response); | |
| 500 memoryCache()->add(firstResource.get()); | |
| 501 | |
| 502 advanceClock(500.); | |
| 503 | |
| 504 ResourcePtr<Resource> fetched = fetch(); | |
| 505 EXPECT_EQ(firstResource, fetched); | |
| 506 } | |
| 507 | |
| 508 TEST_F(CachingCorrectnessTest, 302RedirectExplicitlyFreshExpires) | |
| 509 { | |
| 510 KURL redirectUrl(ParsedURLString, kResourceURL); | |
| 511 const char redirectTargetUrlString[] = "http://redirect-target.com"; | |
| 512 KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString); | |
| 513 | |
| 514 ResourcePtr<Resource> firstResource = new Resource(ResourceRequest(redirectU
rl), Resource::Raw); | |
| 515 | |
| 516 ResourceResponse fresh302Response; | |
| 517 fresh302Response.setURL(redirectUrl); | |
| 518 fresh302Response.setHTTPStatusCode(302); | |
| 519 fresh302Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 520 fresh302Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest); | |
| 521 fresh302Response.setHTTPHeaderField("Location", redirectTargetUrlString); | |
| 522 | |
| 523 // Add the redirect to our request. | |
| 524 ResourceRequest redirectRequest = ResourceRequest(redirectTargetUrl); | |
| 525 firstResource->willSendRequest(redirectRequest, fresh302Response); | |
| 526 | |
| 527 // Add the final response to our request. | |
| 528 ResourceResponse fresh200Response; | |
| 529 fresh200Response.setURL(redirectTargetUrl); | |
| 530 fresh200Response.setHTTPStatusCode(200); | |
| 531 fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 532 fresh200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest); | |
| 533 | |
| 534 firstResource->setResponse(fresh200Response); | |
| 535 memoryCache()->add(firstResource.get()); | |
| 536 | |
| 537 advanceClock(500.); | |
| 538 | |
| 539 ResourcePtr<Resource> fetched = fetch(); | |
| 540 EXPECT_EQ(firstResource, fetched); | |
| 541 } | |
| 542 | |
| 543 } // namespace | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 871383002:
Merge HTMLDocument into Document (Closed)
Base URL: git@github.com:domokit/mojo.git@master