| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (c) 2013, 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/ResourceFetcher.h" | |
| 32 | |
| 33 #include "core/fetch/FetchInitiatorInfo.h" | |
| 34 #include "core/fetch/FetchInitiatorTypeNames.h" | |
| 35 #include "core/fetch/FetchRequest.h" | |
| 36 #include "core/fetch/MemoryCache.h" | |
| 37 #include "core/fetch/MockFetchContext.h" | |
| 38 #include "core/fetch/MockResource.h" | |
| 39 #include "core/fetch/MockResourceClient.h" | |
| 40 #include "core/fetch/RawResource.h" | |
| 41 #include "core/fetch/ResourceLoader.h" | |
| 42 #include "platform/WebTaskRunner.h" | |
| 43 #include "platform/exported/WrappedResourceResponse.h" | |
| 44 #include "platform/heap/Handle.h" | |
| 45 #include "platform/heap/HeapAllocator.h" | |
| 46 #include "platform/heap/Member.h" | |
| 47 #include "platform/network/ResourceRequest.h" | |
| 48 #include "platform/network/ResourceTimingInfo.h" | |
| 49 #include "platform/scheduler/test/fake_web_task_runner.h" | |
| 50 #include "platform/testing/URLTestHelpers.h" | |
| 51 #include "platform/testing/weburl_loader_mock.h" | |
| 52 #include "platform/weborigin/KURL.h" | |
| 53 #include "public/platform/Platform.h" | |
| 54 #include "public/platform/WebURLLoaderMockFactory.h" | |
| 55 #include "public/platform/WebURLResponse.h" | |
| 56 #include "testing/gtest/include/gtest/gtest.h" | |
| 57 #include "wtf/Allocator.h" | |
| 58 #include "wtf/PtrUtil.h" | |
| 59 #include "wtf/Vector.h" | |
| 60 #include <memory> | |
| 61 | |
| 62 namespace blink { | |
| 63 | |
| 64 namespace { | |
| 65 constexpr char kTestResourceFilename[] = "white-1x1.png"; | |
| 66 constexpr char kTestResourceMimeType[] = "image/png"; | |
| 67 constexpr int kTestResourceSize = 103; // size of web/tests/data/white-1x1.png | |
| 68 } | |
| 69 | |
| 70 class ResourceFetcherTest : public ::testing::Test {}; | |
| 71 | |
| 72 TEST_F(ResourceFetcherTest, StartLoadAfterFrameDetach) { | |
| 73 KURL secureURL(ParsedURLString, "https://secureorigin.test/image.png"); | |
| 74 // Try to request a url. The request should fail, and a resource in an error | |
| 75 // state should be returned, and no resource should be present in the cache. | |
| 76 ResourceFetcher* fetcher = ResourceFetcher::create(nullptr); | |
| 77 ResourceRequest resourceRequest(secureURL); | |
| 78 resourceRequest.setRequestContext(WebURLRequest::RequestContextInternal); | |
| 79 FetchRequest fetchRequest = | |
| 80 FetchRequest(resourceRequest, FetchInitiatorInfo()); | |
| 81 Resource* resource = RawResource::fetch(fetchRequest, fetcher); | |
| 82 ASSERT_TRUE(resource); | |
| 83 EXPECT_TRUE(resource->errorOccurred()); | |
| 84 EXPECT_TRUE(resource->resourceError().isAccessCheck()); | |
| 85 EXPECT_FALSE(memoryCache()->resourceForURL(secureURL)); | |
| 86 | |
| 87 // Start by calling startLoad() directly, rather than via requestResource(). | |
| 88 // This shouldn't crash. | |
| 89 fetcher->startLoad(RawResource::create(secureURL, Resource::Raw)); | |
| 90 } | |
| 91 | |
| 92 TEST_F(ResourceFetcherTest, UseExistingResource) { | |
| 93 ResourceFetcher* fetcher = ResourceFetcher::create( | |
| 94 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource)); | |
| 95 | |
| 96 KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.html"); | |
| 97 ResourceResponse response; | |
| 98 response.setURL(url); | |
| 99 response.setHTTPStatusCode(200); | |
| 100 response.setHTTPHeaderField(HTTPNames::Cache_Control, "max-age=3600"); | |
| 101 URLTestHelpers::registerMockedURLLoadWithCustomResponse( | |
| 102 url, kTestResourceFilename, WebString::fromUTF8(""), | |
| 103 WrappedResourceResponse(response)); | |
| 104 | |
| 105 FetchRequest fetchRequest = FetchRequest(url, FetchInitiatorInfo()); | |
| 106 Resource* resource = MockResource::fetch(fetchRequest, fetcher); | |
| 107 ASSERT_TRUE(resource); | |
| 108 Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests(); | |
| 109 Platform::current()->getURLLoaderMockFactory()->unregisterURL(url); | |
| 110 EXPECT_TRUE(resource->isLoaded()); | |
| 111 EXPECT_TRUE(memoryCache()->contains(resource)); | |
| 112 | |
| 113 Resource* newResource = MockResource::fetch(fetchRequest, fetcher); | |
| 114 EXPECT_EQ(resource, newResource); | |
| 115 memoryCache()->remove(resource); | |
| 116 } | |
| 117 | |
| 118 TEST_F(ResourceFetcherTest, Vary) { | |
| 119 KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.html"); | |
| 120 Resource* resource = RawResource::create(url, Resource::Raw); | |
| 121 memoryCache()->add(resource); | |
| 122 ResourceResponse response; | |
| 123 response.setURL(url); | |
| 124 response.setHTTPStatusCode(200); | |
| 125 response.setHTTPHeaderField(HTTPNames::Cache_Control, "max-age=3600"); | |
| 126 response.setHTTPHeaderField(HTTPNames::Vary, "*"); | |
| 127 resource->responseReceived(response, nullptr); | |
| 128 resource->finish(); | |
| 129 ASSERT_TRUE(resource->hasVaryHeader()); | |
| 130 | |
| 131 ResourceFetcher* fetcher = ResourceFetcher::create( | |
| 132 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource)); | |
| 133 ResourceRequest resourceRequest(url); | |
| 134 resourceRequest.setRequestContext(WebURLRequest::RequestContextInternal); | |
| 135 FetchRequest fetchRequest = | |
| 136 FetchRequest(resourceRequest, FetchInitiatorInfo()); | |
| 137 Platform::current()->getURLLoaderMockFactory()->registerURL( | |
| 138 url, WebURLResponse(), ""); | |
| 139 Resource* newResource = RawResource::fetch(fetchRequest, fetcher); | |
| 140 EXPECT_NE(resource, newResource); | |
| 141 newResource->loader()->cancel(); | |
| 142 memoryCache()->remove(newResource); | |
| 143 Platform::current()->getURLLoaderMockFactory()->unregisterURL(url); | |
| 144 | |
| 145 memoryCache()->remove(resource); | |
| 146 } | |
| 147 | |
| 148 TEST_F(ResourceFetcherTest, NavigationTimingInfo) { | |
| 149 KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.html"); | |
| 150 ResourceResponse response; | |
| 151 response.setURL(url); | |
| 152 response.setHTTPStatusCode(200); | |
| 153 | |
| 154 ResourceFetcher* fetcher = ResourceFetcher::create( | |
| 155 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource)); | |
| 156 ResourceRequest resourceRequest(url); | |
| 157 resourceRequest.setFrameType(WebURLRequest::FrameTypeNested); | |
| 158 resourceRequest.setRequestContext(WebURLRequest::RequestContextForm); | |
| 159 FetchRequest fetchRequest = | |
| 160 FetchRequest(resourceRequest, FetchInitiatorInfo()); | |
| 161 Platform::current()->getURLLoaderMockFactory()->registerURL( | |
| 162 url, WebURLResponse(), ""); | |
| 163 Resource* resource = | |
| 164 RawResource::fetchMainResource(fetchRequest, fetcher, SubstituteData()); | |
| 165 resource->responseReceived(response, nullptr); | |
| 166 EXPECT_EQ(resource->getType(), Resource::MainResource); | |
| 167 | |
| 168 ResourceTimingInfo* navigationTimingInfo = fetcher->getNavigationTimingInfo(); | |
| 169 ASSERT_TRUE(navigationTimingInfo); | |
| 170 long long encodedDataLength = 123; | |
| 171 resource->loader()->didFinishLoading(0.0, encodedDataLength, 0); | |
| 172 EXPECT_EQ(navigationTimingInfo->transferSize(), encodedDataLength); | |
| 173 | |
| 174 // When there are redirects. | |
| 175 KURL redirectURL(ParsedURLString, "http://127.0.0.1:8000/redirect.html"); | |
| 176 ResourceResponse redirectResponse; | |
| 177 redirectResponse.setURL(redirectURL); | |
| 178 redirectResponse.setHTTPStatusCode(200); | |
| 179 long long redirectEncodedDataLength = 123; | |
| 180 redirectResponse.setEncodedDataLength(redirectEncodedDataLength); | |
| 181 ResourceRequest redirectResourceRequest(url); | |
| 182 fetcher->recordResourceTimingOnRedirect(resource, redirectResponse, false); | |
| 183 EXPECT_EQ(navigationTimingInfo->transferSize(), | |
| 184 encodedDataLength + redirectEncodedDataLength); | |
| 185 Platform::current()->getURLLoaderMockFactory()->unregisterURL(url); | |
| 186 } | |
| 187 | |
| 188 TEST_F(ResourceFetcherTest, VaryOnBack) { | |
| 189 MockFetchContext* context = | |
| 190 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource); | |
| 191 context->setCachePolicy(CachePolicyHistoryBuffer); | |
| 192 ResourceFetcher* fetcher = ResourceFetcher::create(context); | |
| 193 | |
| 194 KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.html"); | |
| 195 Resource* resource = RawResource::create(url, Resource::Raw); | |
| 196 memoryCache()->add(resource); | |
| 197 ResourceResponse response; | |
| 198 response.setURL(url); | |
| 199 response.setHTTPStatusCode(200); | |
| 200 response.setHTTPHeaderField(HTTPNames::Cache_Control, "max-age=3600"); | |
| 201 response.setHTTPHeaderField(HTTPNames::Vary, "*"); | |
| 202 resource->responseReceived(response, nullptr); | |
| 203 resource->finish(); | |
| 204 ASSERT_TRUE(resource->hasVaryHeader()); | |
| 205 | |
| 206 ResourceRequest resourceRequest(url); | |
| 207 resourceRequest.setRequestContext(WebURLRequest::RequestContextInternal); | |
| 208 FetchRequest fetchRequest = | |
| 209 FetchRequest(resourceRequest, FetchInitiatorInfo()); | |
| 210 Resource* newResource = RawResource::fetch(fetchRequest, fetcher); | |
| 211 EXPECT_EQ(resource, newResource); | |
| 212 | |
| 213 memoryCache()->remove(newResource); | |
| 214 } | |
| 215 | |
| 216 TEST_F(ResourceFetcherTest, VaryResource) { | |
| 217 ResourceFetcher* fetcher = ResourceFetcher::create( | |
| 218 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource)); | |
| 219 | |
| 220 KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.html"); | |
| 221 ResourceResponse response; | |
| 222 response.setURL(url); | |
| 223 response.setHTTPStatusCode(200); | |
| 224 response.setHTTPHeaderField(HTTPNames::Cache_Control, "max-age=3600"); | |
| 225 response.setHTTPHeaderField(HTTPNames::Vary, "*"); | |
| 226 URLTestHelpers::registerMockedURLLoadWithCustomResponse( | |
| 227 url, kTestResourceFilename, WebString::fromUTF8(""), | |
| 228 WrappedResourceResponse(response)); | |
| 229 | |
| 230 FetchRequest fetchRequestOriginal = FetchRequest(url, FetchInitiatorInfo()); | |
| 231 Resource* resource = MockResource::fetch(fetchRequestOriginal, fetcher); | |
| 232 ASSERT_TRUE(resource); | |
| 233 Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests(); | |
| 234 ASSERT_TRUE(resource->hasVaryHeader()); | |
| 235 | |
| 236 FetchRequest fetchRequest = FetchRequest(url, FetchInitiatorInfo()); | |
| 237 Resource* newResource = MockResource::fetch(fetchRequest, fetcher); | |
| 238 EXPECT_EQ(resource, newResource); | |
| 239 | |
| 240 memoryCache()->remove(newResource); | |
| 241 Platform::current()->getURLLoaderMockFactory()->unregisterURL(url); | |
| 242 } | |
| 243 | |
| 244 class RequestSameResourceOnComplete | |
| 245 : public GarbageCollectedFinalized<RequestSameResourceOnComplete>, | |
| 246 public RawResourceClient { | |
| 247 USING_GARBAGE_COLLECTED_MIXIN(RequestSameResourceOnComplete); | |
| 248 | |
| 249 public: | |
| 250 explicit RequestSameResourceOnComplete(Resource* resource) | |
| 251 : m_resource(resource), m_notifyFinishedCalled(false) {} | |
| 252 | |
| 253 void notifyFinished(Resource* resource) override { | |
| 254 EXPECT_EQ(m_resource, resource); | |
| 255 MockFetchContext* context = | |
| 256 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource); | |
| 257 context->setCachePolicy(CachePolicyRevalidate); | |
| 258 ResourceFetcher* fetcher2 = ResourceFetcher::create(context); | |
| 259 FetchRequest fetchRequest2(m_resource->url(), FetchInitiatorInfo()); | |
| 260 Resource* resource2 = MockResource::fetch(fetchRequest2, fetcher2); | |
| 261 EXPECT_EQ(m_resource, resource2); | |
| 262 m_notifyFinishedCalled = true; | |
| 263 } | |
| 264 bool notifyFinishedCalled() const { return m_notifyFinishedCalled; } | |
| 265 | |
| 266 DEFINE_INLINE_TRACE() { | |
| 267 visitor->trace(m_resource); | |
| 268 RawResourceClient::trace(visitor); | |
| 269 } | |
| 270 | |
| 271 String debugName() const override { return "RequestSameResourceOnComplete"; } | |
| 272 | |
| 273 private: | |
| 274 Member<Resource> m_resource; | |
| 275 bool m_notifyFinishedCalled; | |
| 276 }; | |
| 277 | |
| 278 TEST_F(ResourceFetcherTest, RevalidateWhileFinishingLoading) { | |
| 279 KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png"); | |
| 280 ResourceResponse response; | |
| 281 response.setURL(url); | |
| 282 response.setHTTPStatusCode(200); | |
| 283 response.setHTTPHeaderField(HTTPNames::Cache_Control, "max-age=3600"); | |
| 284 response.setHTTPHeaderField(HTTPNames::ETag, "1234567890"); | |
| 285 URLTestHelpers::registerMockedURLLoadWithCustomResponse( | |
| 286 url, kTestResourceFilename, WebString::fromUTF8(""), | |
| 287 WrappedResourceResponse(response)); | |
| 288 ResourceFetcher* fetcher1 = ResourceFetcher::create( | |
| 289 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource)); | |
| 290 ResourceRequest request1(url); | |
| 291 request1.setHTTPHeaderField(HTTPNames::Cache_Control, "no-cache"); | |
| 292 FetchRequest fetchRequest1 = FetchRequest(request1, FetchInitiatorInfo()); | |
| 293 Resource* resource1 = MockResource::fetch(fetchRequest1, fetcher1); | |
| 294 Persistent<RequestSameResourceOnComplete> client = | |
| 295 new RequestSameResourceOnComplete(resource1); | |
| 296 resource1->addClient(client); | |
| 297 Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests(); | |
| 298 Platform::current()->getURLLoaderMockFactory()->unregisterURL(url); | |
| 299 EXPECT_TRUE(client->notifyFinishedCalled()); | |
| 300 resource1->removeClient(client); | |
| 301 memoryCache()->remove(resource1); | |
| 302 } | |
| 303 | |
| 304 TEST_F(ResourceFetcherTest, DontReuseMediaDataUrl) { | |
| 305 ResourceFetcher* fetcher = ResourceFetcher::create( | |
| 306 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource)); | |
| 307 ResourceRequest request(KURL(ParsedURLString, "data:text/html,foo")); | |
| 308 request.setRequestContext(WebURLRequest::RequestContextVideo); | |
| 309 ResourceLoaderOptions options; | |
| 310 options.dataBufferingPolicy = DoNotBufferData; | |
| 311 FetchRequest fetchRequest = | |
| 312 FetchRequest(request, FetchInitiatorTypeNames::internal, options); | |
| 313 Resource* resource1 = RawResource::fetchMedia(fetchRequest, fetcher); | |
| 314 Resource* resource2 = RawResource::fetchMedia(fetchRequest, fetcher); | |
| 315 EXPECT_NE(resource1, resource2); | |
| 316 memoryCache()->remove(resource2); | |
| 317 } | |
| 318 | |
| 319 class ServeRequestsOnCompleteClient final | |
| 320 : public GarbageCollectedFinalized<ServeRequestsOnCompleteClient>, | |
| 321 public RawResourceClient { | |
| 322 USING_GARBAGE_COLLECTED_MIXIN(ServeRequestsOnCompleteClient); | |
| 323 | |
| 324 public: | |
| 325 void notifyFinished(Resource*) override { | |
| 326 Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests(); | |
| 327 } | |
| 328 | |
| 329 // No callbacks should be received except for the notifyFinished() triggered | |
| 330 // by ResourceLoader::cancel(). | |
| 331 void dataSent(Resource*, unsigned long long, unsigned long long) override { | |
| 332 ASSERT_TRUE(false); | |
| 333 } | |
| 334 void responseReceived(Resource*, | |
| 335 const ResourceResponse&, | |
| 336 std::unique_ptr<WebDataConsumerHandle>) override { | |
| 337 ASSERT_TRUE(false); | |
| 338 } | |
| 339 void setSerializedCachedMetadata(Resource*, const char*, size_t) override { | |
| 340 ASSERT_TRUE(false); | |
| 341 } | |
| 342 void dataReceived(Resource*, const char*, size_t) override { | |
| 343 ASSERT_TRUE(false); | |
| 344 } | |
| 345 bool redirectReceived(Resource*, | |
| 346 const ResourceRequest&, | |
| 347 const ResourceResponse&) override { | |
| 348 ADD_FAILURE(); | |
| 349 return true; | |
| 350 } | |
| 351 void dataDownloaded(Resource*, int) override { ASSERT_TRUE(false); } | |
| 352 void didReceiveResourceTiming(Resource*, const ResourceTimingInfo&) override { | |
| 353 ASSERT_TRUE(false); | |
| 354 } | |
| 355 | |
| 356 DEFINE_INLINE_TRACE() { RawResourceClient::trace(visitor); } | |
| 357 | |
| 358 String debugName() const override { return "ServeRequestsOnCompleteClient"; } | |
| 359 }; | |
| 360 | |
| 361 // Regression test for http://crbug.com/594072. | |
| 362 // This emulates a modal dialog triggering a nested run loop inside | |
| 363 // ResourceLoader::cancel(). If the ResourceLoader doesn't promptly cancel its | |
| 364 // WebURLLoader before notifying its clients, a nested run loop may send a | |
| 365 // network response, leading to an invalid state transition in ResourceLoader. | |
| 366 TEST_F(ResourceFetcherTest, ResponseOnCancel) { | |
| 367 KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png"); | |
| 368 URLTestHelpers::registerMockedURLLoad(url, kTestResourceFilename, | |
| 369 kTestResourceMimeType); | |
| 370 | |
| 371 ResourceFetcher* fetcher = ResourceFetcher::create( | |
| 372 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource)); | |
| 373 ResourceRequest resourceRequest(url); | |
| 374 resourceRequest.setRequestContext(WebURLRequest::RequestContextInternal); | |
| 375 FetchRequest fetchRequest = | |
| 376 FetchRequest(resourceRequest, FetchInitiatorInfo()); | |
| 377 Resource* resource = RawResource::fetch(fetchRequest, fetcher); | |
| 378 Persistent<ServeRequestsOnCompleteClient> client = | |
| 379 new ServeRequestsOnCompleteClient(); | |
| 380 resource->addClient(client); | |
| 381 resource->loader()->cancel(); | |
| 382 resource->removeClient(client); | |
| 383 Platform::current()->getURLLoaderMockFactory()->unregisterURL(url); | |
| 384 } | |
| 385 | |
| 386 class ScopedMockRedirectRequester { | |
| 387 STACK_ALLOCATED(); | |
| 388 WTF_MAKE_NONCOPYABLE(ScopedMockRedirectRequester); | |
| 389 | |
| 390 public: | |
| 391 ScopedMockRedirectRequester() : m_context(nullptr) {} | |
| 392 | |
| 393 ~ScopedMockRedirectRequester() { cleanUp(); } | |
| 394 | |
| 395 void registerRedirect(const WebString& fromURL, const WebString& toURL) { | |
| 396 KURL redirectURL(ParsedURLString, fromURL); | |
| 397 WebURLResponse redirectResponse; | |
| 398 redirectResponse.setURL(redirectURL); | |
| 399 redirectResponse.setHTTPStatusCode(301); | |
| 400 redirectResponse.setHTTPHeaderField(HTTPNames::Location, toURL); | |
| 401 redirectResponse.setEncodedDataLength(kRedirectResponseOverheadBytes); | |
| 402 Platform::current()->getURLLoaderMockFactory()->registerURL( | |
| 403 redirectURL, redirectResponse, ""); | |
| 404 } | |
| 405 | |
| 406 void registerFinalResource(const WebString& url) { | |
| 407 KURL finalURL(ParsedURLString, url); | |
| 408 URLTestHelpers::registerMockedURLLoad(finalURL, kTestResourceFilename); | |
| 409 } | |
| 410 | |
| 411 void request(const WebString& url) { | |
| 412 DCHECK(!m_context); | |
| 413 m_context = | |
| 414 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource); | |
| 415 ResourceFetcher* fetcher = ResourceFetcher::create(m_context); | |
| 416 ResourceRequest resourceRequest(url); | |
| 417 resourceRequest.setRequestContext(WebURLRequest::RequestContextInternal); | |
| 418 FetchRequest fetchRequest = | |
| 419 FetchRequest(resourceRequest, FetchInitiatorInfo()); | |
| 420 RawResource::fetch(fetchRequest, fetcher); | |
| 421 Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests(); | |
| 422 } | |
| 423 | |
| 424 void cleanUp() { | |
| 425 Platform::current()->getURLLoaderMockFactory()->unregisterAllURLs(); | |
| 426 memoryCache()->evictResources(); | |
| 427 } | |
| 428 | |
| 429 MockFetchContext* context() const { return m_context; } | |
| 430 | |
| 431 private: | |
| 432 Member<MockFetchContext> m_context; | |
| 433 }; | |
| 434 | |
| 435 TEST_F(ResourceFetcherTest, SameOriginRedirect) { | |
| 436 const char redirectURL[] = "http://127.0.0.1:8000/redirect.html"; | |
| 437 const char finalURL[] = "http://127.0.0.1:8000/final.html"; | |
| 438 ScopedMockRedirectRequester requester; | |
| 439 requester.registerRedirect(redirectURL, finalURL); | |
| 440 requester.registerFinalResource(finalURL); | |
| 441 requester.request(redirectURL); | |
| 442 | |
| 443 EXPECT_EQ(kRedirectResponseOverheadBytes + kTestResourceSize, | |
| 444 requester.context()->getTransferSize()); | |
| 445 } | |
| 446 | |
| 447 TEST_F(ResourceFetcherTest, CrossOriginRedirect) { | |
| 448 const char redirectURL[] = "http://otherorigin.test/redirect.html"; | |
| 449 const char finalURL[] = "http://127.0.0.1:8000/final.html"; | |
| 450 ScopedMockRedirectRequester requester; | |
| 451 requester.registerRedirect(redirectURL, finalURL); | |
| 452 requester.registerFinalResource(finalURL); | |
| 453 requester.request(redirectURL); | |
| 454 | |
| 455 EXPECT_EQ(kTestResourceSize, requester.context()->getTransferSize()); | |
| 456 } | |
| 457 | |
| 458 TEST_F(ResourceFetcherTest, ComplexCrossOriginRedirect) { | |
| 459 const char redirectURL1[] = "http://127.0.0.1:8000/redirect1.html"; | |
| 460 const char redirectURL2[] = "http://otherorigin.test/redirect2.html"; | |
| 461 const char redirectURL3[] = "http://127.0.0.1:8000/redirect3.html"; | |
| 462 const char finalURL[] = "http://127.0.0.1:8000/final.html"; | |
| 463 ScopedMockRedirectRequester requester; | |
| 464 requester.registerRedirect(redirectURL1, redirectURL2); | |
| 465 requester.registerRedirect(redirectURL2, redirectURL3); | |
| 466 requester.registerRedirect(redirectURL3, finalURL); | |
| 467 requester.registerFinalResource(finalURL); | |
| 468 requester.request(redirectURL1); | |
| 469 | |
| 470 EXPECT_EQ(kTestResourceSize, requester.context()->getTransferSize()); | |
| 471 } | |
| 472 | |
| 473 TEST_F(ResourceFetcherTest, SynchronousRequest) { | |
| 474 KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png"); | |
| 475 URLTestHelpers::registerMockedURLLoad(url, kTestResourceFilename, | |
| 476 kTestResourceMimeType); | |
| 477 | |
| 478 ResourceFetcher* fetcher = ResourceFetcher::create( | |
| 479 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource)); | |
| 480 ResourceRequest resourceRequest(url); | |
| 481 resourceRequest.setRequestContext(WebURLRequest::RequestContextInternal); | |
| 482 FetchRequest fetchRequest(resourceRequest, FetchInitiatorInfo()); | |
| 483 fetchRequest.makeSynchronous(); | |
| 484 Resource* resource = RawResource::fetch(fetchRequest, fetcher); | |
| 485 EXPECT_TRUE(resource->isLoaded()); | |
| 486 EXPECT_EQ(ResourceLoadPriorityHighest, | |
| 487 resource->resourceRequest().priority()); | |
| 488 | |
| 489 Platform::current()->getURLLoaderMockFactory()->unregisterURL(url); | |
| 490 memoryCache()->remove(resource); | |
| 491 } | |
| 492 | |
| 493 TEST_F(ResourceFetcherTest, PreloadResourceTwice) { | |
| 494 ResourceFetcher* fetcher = ResourceFetcher::create( | |
| 495 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource)); | |
| 496 | |
| 497 KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png"); | |
| 498 URLTestHelpers::registerMockedURLLoad(url, kTestResourceFilename, | |
| 499 kTestResourceMimeType); | |
| 500 | |
| 501 FetchRequest fetchRequestOriginal = FetchRequest(url, FetchInitiatorInfo()); | |
| 502 Resource* resource = MockResource::fetch(fetchRequestOriginal, fetcher); | |
| 503 ASSERT_TRUE(resource); | |
| 504 Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests(); | |
| 505 fetcher->preloadStarted(resource); | |
| 506 | |
| 507 FetchRequest fetchRequest = FetchRequest(url, FetchInitiatorInfo()); | |
| 508 Resource* newResource = MockResource::fetch(fetchRequest, fetcher); | |
| 509 EXPECT_EQ(resource, newResource); | |
| 510 fetcher->preloadStarted(resource); | |
| 511 | |
| 512 fetcher->clearPreloads(ResourceFetcher::ClearAllPreloads); | |
| 513 Platform::current()->getURLLoaderMockFactory()->unregisterURL(url); | |
| 514 EXPECT_FALSE(memoryCache()->contains(resource)); | |
| 515 EXPECT_FALSE(resource->isPreloaded()); | |
| 516 } | |
| 517 | |
| 518 TEST_F(ResourceFetcherTest, LinkPreloadResourceAndUse) { | |
| 519 ResourceFetcher* fetcher = ResourceFetcher::create( | |
| 520 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource)); | |
| 521 | |
| 522 KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png"); | |
| 523 URLTestHelpers::registerMockedURLLoad(url, kTestResourceFilename, | |
| 524 kTestResourceMimeType); | |
| 525 | |
| 526 // Link preload preload scanner | |
| 527 FetchRequest fetchRequestOriginal = FetchRequest(url, FetchInitiatorInfo()); | |
| 528 fetchRequestOriginal.setLinkPreload(true); | |
| 529 Resource* resource = MockResource::fetch(fetchRequestOriginal, fetcher); | |
| 530 ASSERT_TRUE(resource); | |
| 531 EXPECT_TRUE(resource->isLinkPreload()); | |
| 532 Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests(); | |
| 533 fetcher->preloadStarted(resource); | |
| 534 | |
| 535 // Resource created by preload scanner | |
| 536 FetchRequest fetchRequestPreloadScanner = | |
| 537 FetchRequest(url, FetchInitiatorInfo()); | |
| 538 Resource* preloadScannerResource = | |
| 539 MockResource::fetch(fetchRequestPreloadScanner, fetcher); | |
| 540 EXPECT_EQ(resource, preloadScannerResource); | |
| 541 EXPECT_FALSE(resource->isLinkPreload()); | |
| 542 fetcher->preloadStarted(resource); | |
| 543 | |
| 544 // Resource created by parser | |
| 545 FetchRequest fetchRequest = FetchRequest(url, FetchInitiatorInfo()); | |
| 546 Resource* newResource = MockResource::fetch(fetchRequest, fetcher); | |
| 547 Persistent<MockResourceClient> client = new MockResourceClient(newResource); | |
| 548 EXPECT_EQ(resource, newResource); | |
| 549 EXPECT_FALSE(resource->isLinkPreload()); | |
| 550 | |
| 551 // DCL reached | |
| 552 fetcher->clearPreloads(ResourceFetcher::ClearSpeculativeMarkupPreloads); | |
| 553 Platform::current()->getURLLoaderMockFactory()->unregisterURL(url); | |
| 554 EXPECT_TRUE(memoryCache()->contains(resource)); | |
| 555 EXPECT_FALSE(resource->isPreloaded()); | |
| 556 } | |
| 557 | |
| 558 TEST_F(ResourceFetcherTest, LinkPreloadResourceMultipleFetchersAndUse) { | |
| 559 ResourceFetcher* fetcher = ResourceFetcher::create( | |
| 560 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource)); | |
| 561 ResourceFetcher* fetcher2 = ResourceFetcher::create( | |
| 562 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource)); | |
| 563 | |
| 564 KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png"); | |
| 565 URLTestHelpers::registerMockedURLLoad(url, kTestResourceFilename, | |
| 566 kTestResourceMimeType); | |
| 567 | |
| 568 FetchRequest fetchRequestOriginal = FetchRequest(url, FetchInitiatorInfo()); | |
| 569 fetchRequestOriginal.setLinkPreload(true); | |
| 570 Resource* resource = MockResource::fetch(fetchRequestOriginal, fetcher); | |
| 571 ASSERT_TRUE(resource); | |
| 572 EXPECT_TRUE(resource->isLinkPreload()); | |
| 573 Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests(); | |
| 574 fetcher->preloadStarted(resource); | |
| 575 | |
| 576 FetchRequest fetchRequestSecond = FetchRequest(url, FetchInitiatorInfo()); | |
| 577 fetchRequestSecond.setLinkPreload(true); | |
| 578 Resource* secondResource = MockResource::fetch(fetchRequestSecond, fetcher2); | |
| 579 ASSERT_TRUE(secondResource); | |
| 580 EXPECT_TRUE(secondResource->isLinkPreload()); | |
| 581 Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests(); | |
| 582 fetcher2->preloadStarted(secondResource); | |
| 583 | |
| 584 // Link rel preload scanner | |
| 585 FetchRequest fetchRequestLinkPreloadScanner = | |
| 586 FetchRequest(url, FetchInitiatorInfo()); | |
| 587 fetchRequestLinkPreloadScanner.setLinkPreload(true); | |
| 588 Resource* linkPreloadScannerResource = | |
| 589 MockResource::fetch(fetchRequestLinkPreloadScanner, fetcher); | |
| 590 EXPECT_EQ(resource, linkPreloadScannerResource); | |
| 591 EXPECT_TRUE(resource->isLinkPreload()); | |
| 592 fetcher->preloadStarted(resource); | |
| 593 | |
| 594 // Resource created by preload scanner | |
| 595 FetchRequest fetchRequestPreloadScanner = | |
| 596 FetchRequest(url, FetchInitiatorInfo()); | |
| 597 Resource* preloadScannerResource = | |
| 598 MockResource::fetch(fetchRequestPreloadScanner, fetcher); | |
| 599 EXPECT_EQ(resource, preloadScannerResource); | |
| 600 EXPECT_FALSE(resource->isLinkPreload()); | |
| 601 fetcher->preloadStarted(resource); | |
| 602 | |
| 603 // Resource created by preload scanner on the second fetcher | |
| 604 FetchRequest fetchRequestPreloadScanner2 = | |
| 605 FetchRequest(url, FetchInitiatorInfo()); | |
| 606 Resource* preloadScannerResource2 = | |
| 607 MockResource::fetch(fetchRequestPreloadScanner2, fetcher2); | |
| 608 EXPECT_EQ(resource, preloadScannerResource2); | |
| 609 EXPECT_FALSE(resource->isLinkPreload()); | |
| 610 fetcher2->preloadStarted(resource); | |
| 611 | |
| 612 // Resource created by parser | |
| 613 FetchRequest fetchRequest = FetchRequest(url, FetchInitiatorInfo()); | |
| 614 Resource* newResource = MockResource::fetch(fetchRequest, fetcher); | |
| 615 Persistent<MockResourceClient> client = new MockResourceClient(newResource); | |
| 616 EXPECT_EQ(resource, newResource); | |
| 617 EXPECT_FALSE(resource->isLinkPreload()); | |
| 618 | |
| 619 // Resource created by parser on the second fetcher | |
| 620 FetchRequest fetchRequest2 = FetchRequest(url, FetchInitiatorInfo()); | |
| 621 Resource* newResource2 = MockResource::fetch(fetchRequest, fetcher2); | |
| 622 Persistent<MockResourceClient> client2 = new MockResourceClient(newResource2); | |
| 623 EXPECT_EQ(resource, newResource2); | |
| 624 EXPECT_FALSE(resource->isLinkPreload()); | |
| 625 | |
| 626 // DCL reached on first fetcher | |
| 627 EXPECT_TRUE(resource->isPreloaded()); | |
| 628 fetcher->clearPreloads(ResourceFetcher::ClearSpeculativeMarkupPreloads); | |
| 629 Platform::current()->getURLLoaderMockFactory()->unregisterURL(url); | |
| 630 EXPECT_TRUE(memoryCache()->contains(resource)); | |
| 631 EXPECT_TRUE(resource->isPreloaded()); | |
| 632 | |
| 633 // DCL reached on second fetcher | |
| 634 fetcher2->clearPreloads(ResourceFetcher::ClearSpeculativeMarkupPreloads); | |
| 635 EXPECT_TRUE(memoryCache()->contains(resource)); | |
| 636 EXPECT_FALSE(resource->isPreloaded()); | |
| 637 } | |
| 638 | |
| 639 TEST_F(ResourceFetcherTest, Revalidate304) { | |
| 640 KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.html"); | |
| 641 Resource* resource = RawResource::create(url, Resource::Raw); | |
| 642 memoryCache()->add(resource); | |
| 643 ResourceResponse response; | |
| 644 response.setURL(url); | |
| 645 response.setHTTPStatusCode(304); | |
| 646 response.setHTTPHeaderField("etag", "1234567890"); | |
| 647 resource->responseReceived(response, nullptr); | |
| 648 resource->finish(); | |
| 649 | |
| 650 ResourceFetcher* fetcher = ResourceFetcher::create( | |
| 651 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource)); | |
| 652 ResourceRequest resourceRequest(url); | |
| 653 resourceRequest.setRequestContext(WebURLRequest::RequestContextInternal); | |
| 654 FetchRequest fetchRequest = | |
| 655 FetchRequest(resourceRequest, FetchInitiatorInfo()); | |
| 656 Platform::current()->getURLLoaderMockFactory()->registerURL( | |
| 657 url, WebURLResponse(), ""); | |
| 658 Resource* newResource = RawResource::fetch(fetchRequest, fetcher); | |
| 659 fetcher->stopFetching(); | |
| 660 Platform::current()->getURLLoaderMockFactory()->unregisterURL(url); | |
| 661 | |
| 662 EXPECT_NE(resource, newResource); | |
| 663 } | |
| 664 | |
| 665 TEST_F(ResourceFetcherTest, LinkPreloadResourceMultipleFetchersAndMove) { | |
| 666 ResourceFetcher* fetcher = ResourceFetcher::create( | |
| 667 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource)); | |
| 668 ResourceFetcher* fetcher2 = ResourceFetcher::create( | |
| 669 MockFetchContext::create(MockFetchContext::kShouldLoadNewResource)); | |
| 670 | |
| 671 KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.png"); | |
| 672 URLTestHelpers::registerMockedURLLoad(url, kTestResourceFilename, | |
| 673 kTestResourceMimeType); | |
| 674 | |
| 675 FetchRequest fetchRequestOriginal = FetchRequest(url, FetchInitiatorInfo()); | |
| 676 fetchRequestOriginal.setLinkPreload(true); | |
| 677 Resource* resource = MockResource::fetch(fetchRequestOriginal, fetcher); | |
| 678 ASSERT_TRUE(resource); | |
| 679 EXPECT_TRUE(resource->isLinkPreload()); | |
| 680 fetcher->preloadStarted(resource); | |
| 681 | |
| 682 // Resource created by parser on the second fetcher | |
| 683 FetchRequest fetchRequest2 = FetchRequest(url, FetchInitiatorInfo()); | |
| 684 Resource* newResource2 = MockResource::fetch(fetchRequest2, fetcher2); | |
| 685 Persistent<MockResourceClient> client2 = new MockResourceClient(newResource2); | |
| 686 EXPECT_EQ(resource, newResource2); | |
| 687 EXPECT_FALSE(fetcher2->isFetching()); | |
| 688 Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests(); | |
| 689 Platform::current()->getURLLoaderMockFactory()->unregisterURL(url); | |
| 690 } | |
| 691 | |
| 692 } // namespace blink | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2584423002:
Loading: move core/fetch to platform/loader/fetch (Closed)
