| // Copyright 2015 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "core/fetch/Resource.h" |
| |
| #include "core/fetch/MemoryCache.h" |
| #include "platform/SharedBuffer.h" |
| #include "platform/network/ResourceRequest.h" |
| #include "platform/network/ResourceResponse.h" |
| #include "platform/testing/TestingPlatformSupport.h" |
| #include "platform/testing/URLTestHelpers.h" |
| #include "public/platform/Platform.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "wtf/Vector.h" |
| |
| namespace blink { |
| |
| namespace { |
| |
| class UnlockableResource : public Resource { |
| public: |
| static UnlockableResource* create(const KURL& url) |
| { |
| return new UnlockableResource(ResourceRequest(url), Resource::Raw); |
| } |
| |
| private: |
| UnlockableResource(const ResourceRequest& request, Type type) |
| : Resource(request, type, ResourceLoaderOptions()) |
| { |
| } |
| |
| bool isSafeToUnlock() const override { return true; } |
| }; |
| |
| class MockPlatform final : public TestingPlatformSupport { |
| public: |
| MockPlatform() { } |
| ~MockPlatform() override { } |
| |
| // From blink::Platform: |
| void cacheMetadata(const WebURL& url, int64_t, const char*, size_t) override |
| { |
| m_cachedURLs.append(url); |
| } |
| |
| const Vector<WebURL>& cachedURLs() const |
| { |
| return m_cachedURLs; |
| } |
| |
| private: |
| Vector<WebURL> m_cachedURLs; |
| }; |
| |
| ResourceResponse createTestResourceResponse() |
| { |
| ResourceResponse response; |
| response.setURL(URLTestHelpers::toKURL("https://example.com/")); |
| response.setHTTPStatusCode(200); |
| return response; |
| } |
| |
| void createTestResourceAndSetCachedMetadata(const ResourceResponse& response) |
| { |
| const char testData[] = "test data"; |
| Resource* resource = Resource::create(ResourceRequest(response.url()), Resource::Raw); |
| resource->setResponse(response); |
| resource->cacheHandler()->setCachedMetadata(100, testData, sizeof(testData), CachedMetadataHandler::SendToPlatform); |
| return; |
| } |
| |
| } // anonymous namespace |
| |
| TEST(ResourceTest, SetCachedMetadata_SendsMetadataToPlatform) |
| { |
| MockPlatform mock; |
| ResourceResponse response(createTestResourceResponse()); |
| createTestResourceAndSetCachedMetadata(response); |
| EXPECT_EQ(1u, mock.cachedURLs().size()); |
| } |
| |
| TEST(ResourceTest, SetCachedMetadata_DoesNotSendMetadataToPlatformWhenFetchedViaServiceWorker) |
| { |
| MockPlatform mock; |
| ResourceResponse response(createTestResourceResponse()); |
| response.setWasFetchedViaServiceWorker(true); |
| createTestResourceAndSetCachedMetadata(response); |
| EXPECT_EQ(0u, mock.cachedURLs().size()); |
| } |
| |
| TEST(ResourceTest, LockFailureNoCrash) |
| { |
| ResourceResponse response(createTestResourceResponse()); |
| UnlockableResource* resource = UnlockableResource::create(response.url()); |
| memoryCache()->add(resource); |
| resource->setResponse(response); |
| |
| // A Resource won't be put in DiscardableMemory unless it is at least 16KiB. |
| Vector<char> dataVector(4*4096); |
| for (int i = 0; i < 4096; i++) |
| dataVector.append("test", 4); |
| resource->setResourceBuffer(SharedBuffer::adoptVector(dataVector)); |
| |
| resource->finish(currentTime()); |
| resource->prune(); |
| ASSERT_TRUE(resource->isPurgeable()); |
| bool didLock = resource->lock(); |
| ASSERT_FALSE(didLock); |
| EXPECT_EQ(nullptr, resource->resourceBuffer()); |
| EXPECT_EQ(size_t(0), resource->encodedSize()); |
| } |
| |
| TEST(ResourceTest, RevalidateWithFragment) |
| { |
| KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.html"); |
| ResourceResponse response; |
| response.setURL(url); |
| response.setHTTPStatusCode(200); |
| Resource* resource = Resource::create(url, Resource::Raw); |
| resource->responseReceived(response, nullptr); |
| resource->finish(); |
| |
| // Revalidating with a url that differs by only the fragment |
| // shouldn't trigger a securiy check. |
| url.setFragmentIdentifier("bar"); |
| resource->setRevalidatingRequest(ResourceRequest(url)); |
| ResourceResponse revalidatingResponse; |
| revalidatingResponse.setURL(url); |
| revalidatingResponse.setHTTPStatusCode(304); |
| resource->responseReceived(revalidatingResponse, nullptr); |
| } |
| |
| } // namespace blink |