Remove SharedBuffer::unlock() and keep Resource's SharedBuffer always locked

third_party/WebKit/Source/core/fetch/ResourceTest.cpp

 // 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);
     }
@@ skipping 36 matching lines @@
 
 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