| 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 "core/fetch/MemoryCache.h" | |
| 32 | |
| 33 #include "core/fetch/FetchContext.h" | |
| 34 #include "core/fetch/FetchRequest.h" | |
| 35 #include "core/fetch/MockFetchContext.h" | |
| 36 #include "core/fetch/MockResource.h" | |
| 37 #include "core/fetch/RawResource.h" | |
| 38 #include "core/fetch/Resource.h" | |
| 39 #include "core/fetch/ResourceFetcher.h" | |
| 40 #include "platform/network/ResourceRequest.h" | |
| 41 #include "platform/testing/TestingPlatformSupport.h" | |
| 42 #include "testing/gtest/include/gtest/gtest.h" | |
| 43 | |
| 44 namespace blink { | |
| 45 | |
| 46 namespace { | |
| 47 | |
| 48 // An URL for the original request. | |
| 49 constexpr char kResourceURL[] = "http://resource.com/"; | |
| 50 | |
| 51 // The origin time of our first request. | |
| 52 constexpr char kOriginalRequestDateAsString[] = "Thu, 25 May 1977 18:30:00 GMT"; | |
| 53 constexpr char kOneDayBeforeOriginalRequest[] = "Wed, 24 May 1977 18:30:00 GMT"; | |
| 54 constexpr char kOneDayAfterOriginalRequest[] = "Fri, 26 May 1977 18:30:00 GMT"; | |
| 55 | |
| 56 } // namespace | |
| 57 | |
| 58 class MemoryCacheCorrectnessTest : public ::testing::Test { | |
| 59 protected: | |
| 60 MockResource* resourceFromResourceResponse(ResourceResponse response) { | |
| 61 if (response.url().isNull()) | |
| 62 response.setURL(KURL(ParsedURLString, kResourceURL)); | |
| 63 MockResource* resource = | |
| 64 MockResource::create(ResourceRequest(response.url())); | |
| 65 resource->setResponse(response); | |
| 66 resource->finish(); | |
| 67 memoryCache()->add(resource); | |
| 68 | |
| 69 return resource; | |
| 70 } | |
| 71 MockResource* resourceFromResourceRequest(ResourceRequest request) { | |
| 72 if (request.url().isNull()) | |
| 73 request.setURL(KURL(ParsedURLString, kResourceURL)); | |
| 74 MockResource* resource = MockResource::create(request); | |
| 75 resource->setResponse(ResourceResponse(KURL(ParsedURLString, kResourceURL), | |
| 76 "text/html", 0, nullAtom, String())); | |
| 77 resource->finish(); | |
| 78 memoryCache()->add(resource); | |
| 79 | |
| 80 return resource; | |
| 81 } | |
| 82 // TODO(toyoshim): Consider to use MockResource for all tests instead of | |
| 83 // RawResource. | |
| 84 RawResource* fetchRawResource() { | |
| 85 ResourceRequest resourceRequest(KURL(ParsedURLString, kResourceURL)); | |
| 86 resourceRequest.setRequestContext(WebURLRequest::RequestContextInternal); | |
| 87 FetchRequest fetchRequest(resourceRequest, FetchInitiatorInfo()); | |
| 88 return RawResource::fetch(fetchRequest, fetcher()); | |
| 89 } | |
| 90 MockResource* fetchMockResource() { | |
| 91 FetchRequest fetchRequest( | |
| 92 ResourceRequest(KURL(ParsedURLString, kResourceURL)), | |
| 93 FetchInitiatorInfo()); | |
| 94 return MockResource::fetch(fetchRequest, fetcher()); | |
| 95 } | |
| 96 ResourceFetcher* fetcher() const { return m_fetcher.get(); } | |
| 97 void advanceClock(double seconds) { | |
| 98 m_platform->advanceClockSeconds(seconds); | |
| 99 } | |
| 100 | |
| 101 private: | |
| 102 // Overrides ::testing::Test. | |
| 103 void SetUp() override { | |
| 104 // Save the global memory cache to restore it upon teardown. | |
| 105 m_globalMemoryCache = replaceMemoryCacheForTesting(MemoryCache::create()); | |
| 106 | |
| 107 m_fetcher = ResourceFetcher::create( | |
| 108 MockFetchContext::create(MockFetchContext::kShouldNotLoadNewResource)); | |
| 109 } | |
| 110 void TearDown() override { | |
| 111 memoryCache()->evictResources(); | |
| 112 | |
| 113 // Yield the ownership of the global memory cache back. | |
| 114 replaceMemoryCacheForTesting(m_globalMemoryCache.release()); | |
| 115 } | |
| 116 | |
| 117 Persistent<MemoryCache> m_globalMemoryCache; | |
| 118 Persistent<ResourceFetcher> m_fetcher; | |
| 119 ScopedTestingPlatformSupport<TestingPlatformSupportWithMockScheduler> | |
| 120 m_platform; | |
| 121 }; | |
| 122 | |
| 123 TEST_F(MemoryCacheCorrectnessTest, FreshFromLastModified) { | |
| 124 ResourceResponse fresh200Response; | |
| 125 fresh200Response.setHTTPStatusCode(200); | |
| 126 fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 127 fresh200Response.setHTTPHeaderField("Last-Modified", | |
| 128 kOneDayBeforeOriginalRequest); | |
| 129 | |
| 130 MockResource* fresh200 = resourceFromResourceResponse(fresh200Response); | |
| 131 | |
| 132 // Advance the clock within the implicit freshness period of this resource | |
| 133 // before we make a request. | |
| 134 advanceClock(600.); | |
| 135 | |
| 136 MockResource* fetched = fetchMockResource(); | |
| 137 EXPECT_EQ(fresh200, fetched); | |
| 138 } | |
| 139 | |
| 140 TEST_F(MemoryCacheCorrectnessTest, FreshFromExpires) { | |
| 141 ResourceResponse fresh200Response; | |
| 142 fresh200Response.setHTTPStatusCode(200); | |
| 143 fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 144 fresh200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest); | |
| 145 | |
| 146 MockResource* fresh200 = resourceFromResourceResponse(fresh200Response); | |
| 147 | |
| 148 // Advance the clock within the freshness period of this resource before we | |
| 149 // make a request. | |
| 150 advanceClock(24. * 60. * 60. - 15.); | |
| 151 | |
| 152 MockResource* fetched = fetchMockResource(); | |
| 153 EXPECT_EQ(fresh200, fetched); | |
| 154 } | |
| 155 | |
| 156 TEST_F(MemoryCacheCorrectnessTest, FreshFromMaxAge) { | |
| 157 ResourceResponse fresh200Response; | |
| 158 fresh200Response.setHTTPStatusCode(200); | |
| 159 fresh200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 160 fresh200Response.setHTTPHeaderField("Cache-Control", "max-age=600"); | |
| 161 | |
| 162 MockResource* fresh200 = resourceFromResourceResponse(fresh200Response); | |
| 163 | |
| 164 // Advance the clock within the freshness period of this resource before we | |
| 165 // make a request. | |
| 166 advanceClock(500.); | |
| 167 | |
| 168 MockResource* fetched = fetchMockResource(); | |
| 169 EXPECT_EQ(fresh200, fetched); | |
| 170 } | |
| 171 | |
| 172 // The strong validator causes a revalidation to be launched, and the proxy and | |
| 173 // original resources leak because of their reference loop. | |
| 174 TEST_F(MemoryCacheCorrectnessTest, DISABLED_ExpiredFromLastModified) { | |
| 175 ResourceResponse expired200Response; | |
| 176 expired200Response.setHTTPStatusCode(200); | |
| 177 expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 178 expired200Response.setHTTPHeaderField("Last-Modified", | |
| 179 kOneDayBeforeOriginalRequest); | |
| 180 | |
| 181 MockResource* expired200 = resourceFromResourceResponse(expired200Response); | |
| 182 | |
| 183 // Advance the clock beyond the implicit freshness period. | |
| 184 advanceClock(24. * 60. * 60. * 0.2); | |
| 185 | |
| 186 MockResource* fetched = fetchMockResource(); | |
| 187 EXPECT_NE(expired200, fetched); | |
| 188 } | |
| 189 | |
| 190 TEST_F(MemoryCacheCorrectnessTest, ExpiredFromExpires) { | |
| 191 ResourceResponse expired200Response; | |
| 192 expired200Response.setHTTPStatusCode(200); | |
| 193 expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 194 expired200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest); | |
| 195 | |
| 196 MockResource* expired200 = resourceFromResourceResponse(expired200Response); | |
| 197 | |
| 198 // Advance the clock within the expiredness period of this resource before we | |
| 199 // make a request. | |
| 200 advanceClock(24. * 60. * 60. + 15.); | |
| 201 | |
| 202 MockResource* fetched = fetchMockResource(); | |
| 203 EXPECT_NE(expired200, fetched); | |
| 204 } | |
| 205 | |
| 206 // If the resource hasn't been loaded in this "document" before, then it | |
| 207 // shouldn't have list of available resources logic. | |
| 208 TEST_F(MemoryCacheCorrectnessTest, NewMockResourceExpiredFromExpires) { | |
| 209 ResourceResponse expired200Response; | |
| 210 expired200Response.setHTTPStatusCode(200); | |
| 211 expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 212 expired200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest); | |
| 213 | |
| 214 MockResource* expired200 = resourceFromResourceResponse(expired200Response); | |
| 215 | |
| 216 // Advance the clock within the expiredness period of this resource before we | |
| 217 // make a request. | |
| 218 advanceClock(24. * 60. * 60. + 15.); | |
| 219 | |
| 220 MockResource* fetched = fetchMockResource(); | |
| 221 EXPECT_NE(expired200, fetched); | |
| 222 } | |
| 223 | |
| 224 // If the resource has been loaded in this "document" before, then it should | |
| 225 // have list of available resources logic, and so normal cache testing should be | |
| 226 // bypassed. | |
| 227 TEST_F(MemoryCacheCorrectnessTest, ReuseMockResourceExpiredFromExpires) { | |
| 228 ResourceResponse expired200Response; | |
| 229 expired200Response.setHTTPStatusCode(200); | |
| 230 expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 231 expired200Response.setHTTPHeaderField("Expires", kOneDayAfterOriginalRequest); | |
| 232 | |
| 233 MockResource* expired200 = resourceFromResourceResponse(expired200Response); | |
| 234 | |
| 235 // Advance the clock within the freshness period, and make a request to add | |
| 236 // this resource to the document resources. | |
| 237 advanceClock(15.); | |
| 238 MockResource* firstFetched = fetchMockResource(); | |
| 239 EXPECT_EQ(expired200, firstFetched); | |
| 240 | |
| 241 // Advance the clock within the expiredness period of this resource before we | |
| 242 // make a request. | |
| 243 advanceClock(24. * 60. * 60. + 15.); | |
| 244 | |
| 245 MockResource* fetched = fetchMockResource(); | |
| 246 EXPECT_EQ(expired200, fetched); | |
| 247 } | |
| 248 | |
| 249 TEST_F(MemoryCacheCorrectnessTest, ExpiredFromMaxAge) { | |
| 250 ResourceResponse expired200Response; | |
| 251 expired200Response.setHTTPStatusCode(200); | |
| 252 expired200Response.setHTTPHeaderField("Date", kOriginalRequestDateAsString); | |
| 253 expired200Response.setHTTPHeaderField("Cache-Control", "max-age=600"); | |
| 254 | |
| 255 MockResource* expired200 = resourceFromResourceResponse(expired200Response); | |
| 256 | |
| 257 // Advance the clock within the expiredness period of this resource before we | |
| 258 // make a request. | |
| 259 advanceClock(700.); | |
| 260 | |
| 261 MockResource* fetched = fetchMockResource(); | |
| 262 EXPECT_NE(expired200, fetched); | |
| 263 } | |
| 264 | |
| 265 TEST_F(MemoryCacheCorrectnessTest, FreshButNoCache) { | |
| 266 ResourceResponse fresh200NocacheResponse; | |
| 267 fresh200NocacheResponse.setHTTPStatusCode(200); | |
| 268 fresh200NocacheResponse.setHTTPHeaderField(HTTPNames::Date, | |
| 269 kOriginalRequestDateAsString); | |
| 270 fresh200NocacheResponse.setHTTPHeaderField(HTTPNames::Expires, | |
| 271 kOneDayAfterOriginalRequest); | |
| 272 fresh200NocacheResponse.setHTTPHeaderField(HTTPNames::Cache_Control, | |
| 273 "no-cache"); | |
| 274 | |
| 275 MockResource* fresh200Nocache = | |
| 276 resourceFromResourceResponse(fresh200NocacheResponse); | |
| 277 | |
| 278 // Advance the clock within the freshness period of this resource before we | |
| 279 // make a request. | |
| 280 advanceClock(24. * 60. * 60. - 15.); | |
| 281 | |
| 282 MockResource* fetched = fetchMockResource(); | |
| 283 EXPECT_NE(fresh200Nocache, fetched); | |
| 284 } | |
| 285 | |
| 286 TEST_F(MemoryCacheCorrectnessTest, RequestWithNoCache) { | |
| 287 ResourceRequest noCacheRequest; | |
| 288 noCacheRequest.setHTTPHeaderField(HTTPNames::Cache_Control, "no-cache"); | |
| 289 MockResource* noCacheResource = resourceFromResourceRequest(noCacheRequest); | |
| 290 MockResource* fetched = fetchMockResource(); | |
| 291 EXPECT_NE(noCacheResource, fetched); | |
| 292 } | |
| 293 | |
| 294 TEST_F(MemoryCacheCorrectnessTest, FreshButNoStore) { | |
| 295 ResourceResponse fresh200NostoreResponse; | |
| 296 fresh200NostoreResponse.setHTTPStatusCode(200); | |
| 297 fresh200NostoreResponse.setHTTPHeaderField(HTTPNames::Date, | |
| 298 kOriginalRequestDateAsString); | |
| 299 fresh200NostoreResponse.setHTTPHeaderField(HTTPNames::Expires, | |
| 300 kOneDayAfterOriginalRequest); | |
| 301 fresh200NostoreResponse.setHTTPHeaderField(HTTPNames::Cache_Control, | |
| 302 "no-store"); | |
| 303 | |
| 304 MockResource* fresh200Nostore = | |
| 305 resourceFromResourceResponse(fresh200NostoreResponse); | |
| 306 | |
| 307 // Advance the clock within the freshness period of this resource before we | |
| 308 // make a request. | |
| 309 advanceClock(24. * 60. * 60. - 15.); | |
| 310 | |
| 311 MockResource* fetched = fetchMockResource(); | |
| 312 EXPECT_NE(fresh200Nostore, fetched); | |
| 313 } | |
| 314 | |
| 315 TEST_F(MemoryCacheCorrectnessTest, RequestWithNoStore) { | |
| 316 ResourceRequest noStoreRequest; | |
| 317 noStoreRequest.setHTTPHeaderField(HTTPNames::Cache_Control, "no-store"); | |
| 318 MockResource* noStoreResource = resourceFromResourceRequest(noStoreRequest); | |
| 319 MockResource* fetched = fetchMockResource(); | |
| 320 EXPECT_NE(noStoreResource, fetched); | |
| 321 } | |
| 322 | |
| 323 // FIXME: Determine if ignoring must-revalidate for blink is correct behaviour. | |
| 324 // See crbug.com/340088 . | |
| 325 TEST_F(MemoryCacheCorrectnessTest, DISABLED_FreshButMustRevalidate) { | |
| 326 ResourceResponse fresh200MustRevalidateResponse; | |
| 327 fresh200MustRevalidateResponse.setHTTPStatusCode(200); | |
| 328 fresh200MustRevalidateResponse.setHTTPHeaderField( | |
| 329 HTTPNames::Date, kOriginalRequestDateAsString); | |
| 330 fresh200MustRevalidateResponse.setHTTPHeaderField( | |
| 331 HTTPNames::Expires, kOneDayAfterOriginalRequest); | |
| 332 fresh200MustRevalidateResponse.setHTTPHeaderField(HTTPNames::Cache_Control, | |
| 333 "must-revalidate"); | |
| 334 | |
| 335 MockResource* fresh200MustRevalidate = | |
| 336 resourceFromResourceResponse(fresh200MustRevalidateResponse); | |
| 337 | |
| 338 // Advance the clock within the freshness period of this resource before we | |
| 339 // make a request. | |
| 340 advanceClock(24. * 60. * 60. - 15.); | |
| 341 | |
| 342 MockResource* fetched = fetchMockResource(); | |
| 343 EXPECT_NE(fresh200MustRevalidate, fetched); | |
| 344 } | |
| 345 | |
| 346 TEST_F(MemoryCacheCorrectnessTest, FreshWithFreshRedirect) { | |
| 347 KURL redirectUrl(ParsedURLString, kResourceURL); | |
| 348 const char redirectTargetUrlString[] = "http://redirect-target.com"; | |
| 349 KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString); | |
| 350 | |
| 351 MockResource* firstResource = | |
| 352 MockResource::create(ResourceRequest(redirectUrl)); | |
| 353 | |
| 354 ResourceResponse fresh301Response; | |
| 355 fresh301Response.setURL(redirectUrl); | |
| 356 fresh301Response.setHTTPStatusCode(301); | |
| 357 fresh301Response.setHTTPHeaderField(HTTPNames::Date, | |
| 358 kOriginalRequestDateAsString); | |
| 359 fresh301Response.setHTTPHeaderField(HTTPNames::Location, | |
| 360 redirectTargetUrlString); | |
| 361 fresh301Response.setHTTPHeaderField(HTTPNames::Cache_Control, "max-age=600"); | |
| 362 | |
| 363 // Add the redirect to our request. | |
| 364 ResourceRequest redirectRequest = ResourceRequest(redirectTargetUrl); | |
| 365 firstResource->willFollowRedirect(redirectRequest, fresh301Response); | |
| 366 | |
| 367 // Add the final response to our request. | |
| 368 ResourceResponse fresh200Response; | |
| 369 fresh200Response.setURL(redirectTargetUrl); | |
| 370 fresh200Response.setHTTPStatusCode(200); | |
| 371 fresh200Response.setHTTPHeaderField(HTTPNames::Date, | |
| 372 kOriginalRequestDateAsString); | |
| 373 fresh200Response.setHTTPHeaderField(HTTPNames::Expires, | |
| 374 kOneDayAfterOriginalRequest); | |
| 375 | |
| 376 firstResource->setResponse(fresh200Response); | |
| 377 firstResource->finish(); | |
| 378 memoryCache()->add(firstResource); | |
| 379 | |
| 380 advanceClock(500.); | |
| 381 | |
| 382 MockResource* fetched = fetchMockResource(); | |
| 383 EXPECT_EQ(firstResource, fetched); | |
| 384 } | |
| 385 | |
| 386 TEST_F(MemoryCacheCorrectnessTest, FreshWithStaleRedirect) { | |
| 387 KURL redirectUrl(ParsedURLString, kResourceURL); | |
| 388 const char redirectTargetUrlString[] = "http://redirect-target.com"; | |
| 389 KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString); | |
| 390 | |
| 391 MockResource* firstResource = | |
| 392 MockResource::create(ResourceRequest(redirectUrl)); | |
| 393 | |
| 394 ResourceResponse stale301Response; | |
| 395 stale301Response.setURL(redirectUrl); | |
| 396 stale301Response.setHTTPStatusCode(301); | |
| 397 stale301Response.setHTTPHeaderField(HTTPNames::Date, | |
| 398 kOriginalRequestDateAsString); | |
| 399 stale301Response.setHTTPHeaderField(HTTPNames::Location, | |
| 400 redirectTargetUrlString); | |
| 401 | |
| 402 // Add the redirect to our request. | |
| 403 ResourceRequest redirectRequest = ResourceRequest(redirectTargetUrl); | |
| 404 firstResource->willFollowRedirect(redirectRequest, stale301Response); | |
| 405 | |
| 406 // Add the final response to our request. | |
| 407 ResourceResponse fresh200Response; | |
| 408 fresh200Response.setURL(redirectTargetUrl); | |
| 409 fresh200Response.setHTTPStatusCode(200); | |
| 410 fresh200Response.setHTTPHeaderField(HTTPNames::Date, | |
| 411 kOriginalRequestDateAsString); | |
| 412 fresh200Response.setHTTPHeaderField(HTTPNames::Expires, | |
| 413 kOneDayAfterOriginalRequest); | |
| 414 | |
| 415 firstResource->setResponse(fresh200Response); | |
| 416 firstResource->finish(); | |
| 417 memoryCache()->add(firstResource); | |
| 418 | |
| 419 advanceClock(500.); | |
| 420 | |
| 421 MockResource* fetched = fetchMockResource(); | |
| 422 EXPECT_NE(firstResource, fetched); | |
| 423 } | |
| 424 | |
| 425 TEST_F(MemoryCacheCorrectnessTest, PostToSameURLTwice) { | |
| 426 ResourceRequest request1(KURL(ParsedURLString, kResourceURL)); | |
| 427 request1.setHTTPMethod(HTTPNames::POST); | |
| 428 RawResource* resource1 = | |
| 429 RawResource::create(ResourceRequest(request1.url()), Resource::Raw); | |
| 430 resource1->setStatus(Resource::Pending); | |
| 431 memoryCache()->add(resource1); | |
| 432 | |
| 433 ResourceRequest request2(KURL(ParsedURLString, kResourceURL)); | |
| 434 request2.setHTTPMethod(HTTPNames::POST); | |
| 435 FetchRequest fetch2(request2, FetchInitiatorInfo()); | |
| 436 RawResource* resource2 = RawResource::fetchSynchronously(fetch2, fetcher()); | |
| 437 | |
| 438 EXPECT_EQ(resource2, memoryCache()->resourceForURL(request2.url())); | |
| 439 EXPECT_NE(resource1, resource2); | |
| 440 } | |
| 441 | |
| 442 TEST_F(MemoryCacheCorrectnessTest, 302RedirectNotImplicitlyFresh) { | |
| 443 KURL redirectUrl(ParsedURLString, kResourceURL); | |
| 444 const char redirectTargetUrlString[] = "http://redirect-target.com"; | |
| 445 KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString); | |
| 446 | |
| 447 RawResource* firstResource = | |
| 448 RawResource::create(ResourceRequest(redirectUrl), Resource::Raw); | |
| 449 | |
| 450 ResourceResponse fresh302Response; | |
| 451 fresh302Response.setURL(redirectUrl); | |
| 452 fresh302Response.setHTTPStatusCode(302); | |
| 453 fresh302Response.setHTTPHeaderField(HTTPNames::Date, | |
| 454 kOriginalRequestDateAsString); | |
| 455 fresh302Response.setHTTPHeaderField(HTTPNames::Last_Modified, | |
| 456 kOneDayBeforeOriginalRequest); | |
| 457 fresh302Response.setHTTPHeaderField(HTTPNames::Location, | |
| 458 redirectTargetUrlString); | |
| 459 | |
| 460 // Add the redirect to our request. | |
| 461 ResourceRequest redirectRequest = ResourceRequest(redirectTargetUrl); | |
| 462 firstResource->willFollowRedirect(redirectRequest, fresh302Response); | |
| 463 | |
| 464 // Add the final response to our request. | |
| 465 ResourceResponse fresh200Response; | |
| 466 fresh200Response.setURL(redirectTargetUrl); | |
| 467 fresh200Response.setHTTPStatusCode(200); | |
| 468 fresh200Response.setHTTPHeaderField(HTTPNames::Date, | |
| 469 kOriginalRequestDateAsString); | |
| 470 fresh200Response.setHTTPHeaderField(HTTPNames::Expires, | |
| 471 kOneDayAfterOriginalRequest); | |
| 472 | |
| 473 firstResource->setResponse(fresh200Response); | |
| 474 firstResource->finish(); | |
| 475 memoryCache()->add(firstResource); | |
| 476 | |
| 477 advanceClock(500.); | |
| 478 | |
| 479 RawResource* fetched = fetchRawResource(); | |
| 480 EXPECT_NE(firstResource, fetched); | |
| 481 } | |
| 482 | |
| 483 TEST_F(MemoryCacheCorrectnessTest, 302RedirectExplicitlyFreshMaxAge) { | |
| 484 KURL redirectUrl(ParsedURLString, kResourceURL); | |
| 485 const char redirectTargetUrlString[] = "http://redirect-target.com"; | |
| 486 KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString); | |
| 487 | |
| 488 MockResource* firstResource = | |
| 489 MockResource::create(ResourceRequest(redirectUrl)); | |
| 490 | |
| 491 ResourceResponse fresh302Response; | |
| 492 fresh302Response.setURL(redirectUrl); | |
| 493 fresh302Response.setHTTPStatusCode(302); | |
| 494 fresh302Response.setHTTPHeaderField(HTTPNames::Date, | |
| 495 kOriginalRequestDateAsString); | |
| 496 fresh302Response.setHTTPHeaderField(HTTPNames::Cache_Control, "max-age=600"); | |
| 497 fresh302Response.setHTTPHeaderField(HTTPNames::Location, | |
| 498 redirectTargetUrlString); | |
| 499 | |
| 500 // Add the redirect to our request. | |
| 501 ResourceRequest redirectRequest = ResourceRequest(redirectTargetUrl); | |
| 502 firstResource->willFollowRedirect(redirectRequest, fresh302Response); | |
| 503 | |
| 504 // Add the final response to our request. | |
| 505 ResourceResponse fresh200Response; | |
| 506 fresh200Response.setURL(redirectTargetUrl); | |
| 507 fresh200Response.setHTTPStatusCode(200); | |
| 508 fresh200Response.setHTTPHeaderField(HTTPNames::Date, | |
| 509 kOriginalRequestDateAsString); | |
| 510 fresh200Response.setHTTPHeaderField(HTTPNames::Expires, | |
| 511 kOneDayAfterOriginalRequest); | |
| 512 | |
| 513 firstResource->setResponse(fresh200Response); | |
| 514 firstResource->finish(); | |
| 515 memoryCache()->add(firstResource); | |
| 516 | |
| 517 advanceClock(500.); | |
| 518 | |
| 519 MockResource* fetched = fetchMockResource(); | |
| 520 EXPECT_EQ(firstResource, fetched); | |
| 521 } | |
| 522 | |
| 523 TEST_F(MemoryCacheCorrectnessTest, 302RedirectExplicitlyFreshExpires) { | |
| 524 KURL redirectUrl(ParsedURLString, kResourceURL); | |
| 525 const char redirectTargetUrlString[] = "http://redirect-target.com"; | |
| 526 KURL redirectTargetUrl(ParsedURLString, redirectTargetUrlString); | |
| 527 | |
| 528 MockResource* firstResource = | |
| 529 MockResource::create(ResourceRequest(redirectUrl)); | |
| 530 | |
| 531 ResourceResponse fresh302Response; | |
| 532 fresh302Response.setURL(redirectUrl); | |
| 533 fresh302Response.setHTTPStatusCode(302); | |
| 534 fresh302Response.setHTTPHeaderField(HTTPNames::Date, | |
| 535 kOriginalRequestDateAsString); | |
| 536 fresh302Response.setHTTPHeaderField(HTTPNames::Expires, | |
| 537 kOneDayAfterOriginalRequest); | |
| 538 fresh302Response.setHTTPHeaderField(HTTPNames::Location, | |
| 539 redirectTargetUrlString); | |
| 540 | |
| 541 // Add the redirect to our request. | |
| 542 ResourceRequest redirectRequest = ResourceRequest(redirectTargetUrl); | |
| 543 firstResource->willFollowRedirect(redirectRequest, fresh302Response); | |
| 544 | |
| 545 // Add the final response to our request. | |
| 546 ResourceResponse fresh200Response; | |
| 547 fresh200Response.setURL(redirectTargetUrl); | |
| 548 fresh200Response.setHTTPStatusCode(200); | |
| 549 fresh200Response.setHTTPHeaderField(HTTPNames::Date, | |
| 550 kOriginalRequestDateAsString); | |
| 551 fresh200Response.setHTTPHeaderField(HTTPNames::Expires, | |
| 552 kOneDayAfterOriginalRequest); | |
| 553 | |
| 554 firstResource->setResponse(fresh200Response); | |
| 555 firstResource->finish(); | |
| 556 memoryCache()->add(firstResource); | |
| 557 | |
| 558 advanceClock(500.); | |
| 559 | |
| 560 MockResource* fetched = fetchMockResource(); | |
| 561 EXPECT_EQ(firstResource, fetched); | |
| 562 } | |
| 563 | |
| 564 } // namespace blink | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2584423002:
Loading: move core/fetch to platform/loader/fetch (Closed)
