Minimize direct use of ResourceClient::SetResource() and Resource::AddClient() in tests

Bug: 793028
Change-Id: Icff8fce73e745969e4022329a7cb0374ce43698c
Reviewed-on: https://chromium-review.googlesource.com/818197Reviewed-by: Hiroshige Hayashizaki <hiroshige@chromium.org>
Commit-Queue: Nate Chapin <japhet@chromium.org>
Cr-Commit-Position: refs/heads/master@{#523279}

third_party/WebKit/Source/core/loader/resource/ImageResourceTest.cpp

@@ -1237,14 +1237,10 @@ TEST(ImageResourceTest, FailedRevalidationSvgToSvg) {
 
 // Tests for pruning.
 
-TEST(ImageResourceTest, AddClientAfterPrune) {
+TEST(ImageResourceTest, Prune) {
   KURL url("http://127.0.0.1:8000/foo");
   ImageResource* image_resource = ImageResource::CreateForTest(url);
 
-  // Adds a ResourceClient but not ImageResourceObserver.
-  Persistent<MockResourceClient> client1 =
-      new MockResourceClient(image_resource);
-
   ReceiveResponse(image_resource, url, "image/jpeg",
                   reinterpret_cast<const char*>(kJpegImage),
                   sizeof(kJpegImage));
@@ -1255,9 +1251,6 @@ TEST(ImageResourceTest, AddClientAfterPrune) {
   EXPECT_EQ(kJpegImageWidth, image_resource->GetContent()->GetImage()->width());
   EXPECT_EQ(kJpegImageHeight,
             image_resource->GetContent()->GetImage()->height());
-  EXPECT_TRUE(client1->NotifyFinishedCalled());
-
-  client1->RemoveAsClient();
 
   EXPECT_FALSE(image_resource->IsAlive());
 
@@ -1265,17 +1258,12 @@ TEST(ImageResourceTest, AddClientAfterPrune) {
 
   EXPECT_TRUE(image_resource->GetContent()->HasImage());
 
-  // Re-adds a ResourceClient but not ImageResourceObserver.
-  Persistent<MockResourceClient> client2 =
-      new MockResourceClient(image_resource);
-
   blink::testing::RunPendingTasks();
   ASSERT_TRUE(image_resource->GetContent()->HasImage());
   EXPECT_FALSE(image_resource->GetContent()->GetImage()->IsNull());
   EXPECT_EQ(kJpegImageWidth, image_resource->GetContent()->GetImage()->width());
   EXPECT_EQ(kJpegImageHeight,
             image_resource->GetContent()->GetImage()->height());
-  EXPECT_TRUE(client2->NotifyFinishedCalled());
 }
 
 TEST(ImageResourceTest, CancelOnDecodeError) {

third_party/WebKit/Source/platform/loader/BUILD.gn

@@ -154,7 +154,6 @@ jumbo_source_set("test_support") {
     "testing/MockFetchContext.h",
     "testing/MockResource.cpp",
     "testing/MockResource.h",
-    "testing/MockResourceClient.cpp",
     "testing/MockResourceClient.h",
     "testing/WebURLLoaderFactoryWithMock.cpp",
     "testing/WebURLLoaderFactoryWithMock.h",

third_party/WebKit/Source/platform/loader/fetch/MemoryCacheCorrectnessTest.cpp

@@ -92,7 +92,7 @@ class MemoryCacheCorrectnessTest : public ::testing::Test {
   MockResource* FetchMockResource() {
     ResourceRequest resource_request{KURL(kResourceURL)};
     FetchParameters fetch_params(resource_request);
-    return MockResource::Fetch(fetch_params, Fetcher());
+    return MockResource::Fetch(fetch_params, Fetcher(), nullptr);
   }
   ResourceFetcher* Fetcher() const { return fetcher_.Get(); }
   void AdvanceClock(double seconds) { platform_->AdvanceClockSeconds(seconds); }

third_party/WebKit/Source/platform/loader/fetch/MemoryCacheTest.cpp

@@ -31,8 +31,10 @@
 #include "platform/loader/fetch/MemoryCache.h"
 
 #include "platform/loader/fetch/RawResource.h"
+#include "platform/loader/fetch/ResourceFetcher.h"
 #include "platform/loader/fetch/ResourceLoaderOptions.h"
 #include "platform/loader/fetch/ResourceRequest.h"
+#include "platform/loader/testing/MockFetchContext.h"
 #include "platform/loader/testing/MockResourceClient.h"
 #include "platform/testing/TestingPlatformSupportWithMockScheduler.h"
 #include "platform/testing/UnitTestHelpers.h"
@@ -42,32 +44,42 @@
 
 namespace blink {
 
-class MemoryCacheTest : public ::testing::Test {
+class FakeDecodedResource final : public Resource {
  public:
-  class FakeDecodedResource final : public Resource {
+  static FakeDecodedResource* Fetch(FetchParameters& params,
+                                    ResourceFetcher* fetcher,
+                                    ResourceClient* client) {
+    return static_cast<FakeDecodedResource*>(
+        fetcher->RequestResource(params, Factory(), client));
+  }
+
+  void AppendData(const char* data, size_t len) override {
+    Resource::AppendData(data, len);
+    SetDecodedSize(this->size());
+  }
+
+  void FakeEncodedSize(size_t size) { SetEncodedSize(size); }
+
+ private:
+  class Factory final : public NonTextResourceFactory {
    public:
-    static FakeDecodedResource* Create(const String& url, Type type) {
-      ResourceRequest request(url);
-      request.SetFetchCredentialsMode(
-          network::mojom::FetchCredentialsMode::kOmit);
-      ResourceLoaderOptions options;
-      return new FakeDecodedResource(request, type, options);
-    }
+    Factory() : NonTextResourceFactory(kMock) {}
 
-    void AppendData(const char* data, size_t len) override {
-      Resource::AppendData(data, len);
-      SetDecodedSize(this->size());
+    Resource* Create(const ResourceRequest& request,
+                     const ResourceLoaderOptions& options) const override {
+      return new FakeDecodedResource(request, options);
     }
+  };
 
-   private:
-    FakeDecodedResource(const ResourceRequest& request,
-                        Type type,
-                        const ResourceLoaderOptions& options)
-        : Resource(request, type, options) {}
+  FakeDecodedResource(const ResourceRequest& request,
+                      const ResourceLoaderOptions& options)
+      : Resource(request, kMock, options) {}
 
-    void DestroyDecodedDataIfPossible() override { SetDecodedSize(0); }
-  };
+  void DestroyDecodedDataIfPossible() override { SetDecodedSize(0); }
+};
 
+class MemoryCacheTest : public ::testing::Test {
+ public:
   class FakeResource final : public Resource {
    public:
     static FakeResource* Create(const char* url, Type type) {
@@ -83,8 +95,6 @@ class MemoryCacheTest : public ::testing::Test {
       return new FakeResource(request, type, options);
     }
 
-    void FakeEncodedSize(size_t size) { SetEncodedSize(size); }
-
    private:
     FakeResource(const ResourceRequest& request,
                  Type type,
@@ -96,6 +106,8 @@ class MemoryCacheTest : public ::testing::Test {
   void SetUp() override {
     // Save the global memory cache to restore it upon teardown.
     global_memory_cache_ = ReplaceMemoryCacheForTesting(MemoryCache::Create());
+    fetcher_ = ResourceFetcher::Create(
+        MockFetchContext::Create(MockFetchContext::kShouldLoadNewResource));
   }
 
   void TearDown() override {
@@ -103,6 +115,7 @@ class MemoryCacheTest : public ::testing::Test {
   }
 
   Persistent<MemoryCache> global_memory_cache_;
+  Persistent<ResourceFetcher> fetcher_;
   ScopedTestingPlatformSupport<TestingPlatformSupportWithMockScheduler>
       platform_;
 };
@@ -121,16 +134,16 @@ TEST_F(MemoryCacheTest, VeryLargeResourceAccounting) {
   const size_t kResourceSize1 = kSizeMax / 16;
   const size_t kResourceSize2 = kSizeMax / 20;
   GetMemoryCache()->SetCapacity(kTotalCapacity);
-  FakeResource* cached_resource =
-      FakeResource::Create("http://test/resource", Resource::kRaw);
+  Persistent<MockResourceClient> client = new MockResourceClient;
+  FetchParameters params(ResourceRequest("data:text/html,"));
+  FakeDecodedResource* cached_resource =
+      FakeDecodedResource::Fetch(params, fetcher_, client);
   cached_resource->FakeEncodedSize(kResourceSize1);
 
-  EXPECT_EQ(0u, GetMemoryCache()->size());
-  GetMemoryCache()->Add(cached_resource);
+  EXPECT_TRUE(GetMemoryCache()->Contains(cached_resource));
   EXPECT_EQ(cached_resource->size(), GetMemoryCache()->size());
 
-  Persistent<MockResourceClient> client =
-      new MockResourceClient(cached_resource);
+  client->RemoveAsClient();
   EXPECT_EQ(cached_resource->size(), GetMemoryCache()->size());
 
   cached_resource->FakeEncodedSize(kResourceSize2);
@@ -167,8 +180,9 @@ static void RunTask2(unsigned size_without_decode) {
   EXPECT_EQ(size_without_decode, GetMemoryCache()->size());
 }
 
-static void TestResourcePruningAtEndOfTask(Resource* resource1,
-                                           Resource* resource2) {
+static void TestResourcePruningAtEndOfTask(ResourceFetcher* fetcher,
+                                           const String& identifier1,
+                                           const String& identifier2) {
   GetMemoryCache()->SetDelayBeforeLiveDecodedPrune(0);
 
   // Enforce pruning by adding |dummyResource| and then call prune().
@@ -183,9 +197,19 @@ static void TestResourcePruningAtEndOfTask(Resource* resource1,
   EXPECT_EQ(0u, GetMemoryCache()->size());
 
   const char kData[6] = "abcde";
+  FetchParameters params1(ResourceRequest("data:text/html,resource1"));
+  Resource* resource1 = FakeDecodedResource::Fetch(params1, fetcher, nullptr);
+  GetMemoryCache()->Remove(resource1);
+  if (!identifier1.IsEmpty())
+    resource1->SetCacheIdentifier(identifier1);
   resource1->AppendData(kData, 3u);
   resource1->FinishForTest();
-  Persistent<MockResourceClient> client = new MockResourceClient(resource2);
+  FetchParameters params2(ResourceRequest("data:text/html,resource2"));
+  Persistent<MockResourceClient> client = new MockResourceClient;
+  Resource* resource2 = FakeDecodedResource::Fetch(params2, fetcher, client);
+  GetMemoryCache()->Remove(resource2);
+  if (!identifier2.IsEmpty())
+    resource2->SetCacheIdentifier(identifier2);
   resource2->AppendData(kData, 4u);
   resource2->FinishForTest();
 
@@ -204,31 +228,16 @@ static void TestResourcePruningAtEndOfTask(Resource* resource1,
 // Verified that when ordering a prune in a runLoop task, the prune
 // is deferred to the end of the task.
 TEST_F(MemoryCacheTest, ResourcePruningAtEndOfTask_Basic) {
-  Resource* resource1 =
-      FakeDecodedResource::Create("http://test/resource1", Resource::kRaw);
-  Resource* resource2 =
-      FakeDecodedResource::Create("http://test/resource2", Resource::kRaw);
-  TestResourcePruningAtEndOfTask(resource1, resource2);
+  TestResourcePruningAtEndOfTask(fetcher_, "", "");
 }
 
 TEST_F(MemoryCacheTest, ResourcePruningAtEndOfTask_MultipleResourceMaps) {
   {
-    Resource* resource1 =
-        FakeDecodedResource::Create("http://test/resource1", Resource::kRaw);
-    Resource* resource2 =
-        FakeDecodedResource::Create("http://test/resource2", Resource::kRaw);
-    resource1->SetCacheIdentifier("foo");
-    TestResourcePruningAtEndOfTask(resource1, resource2);
+    TestResourcePruningAtEndOfTask(fetcher_, "foo", "");
     GetMemoryCache()->EvictResources();
   }
   {
-    Resource* resource1 =
-        FakeDecodedResource::Create("http://test/resource1", Resource::kRaw);
-    Resource* resource2 =
-        FakeDecodedResource::Create("http://test/resource2", Resource::kRaw);
-    resource1->SetCacheIdentifier("foo");
-    resource2->SetCacheIdentifier("bar");
-    TestResourcePruningAtEndOfTask(resource1, resource2);
+    TestResourcePruningAtEndOfTask(fetcher_, "foo", "bar");
     GetMemoryCache()->EvictResources();
   }
 }
@@ -237,14 +246,28 @@ TEST_F(MemoryCacheTest, ResourcePruningAtEndOfTask_MultipleResourceMaps) {
 // - Resources are not pruned synchronously when ResourceClient is removed.
 // - size() is updated appropriately when Resources are added to MemoryCache
 //   and garbage collected.
-static void TestClientRemoval(Resource* resource1, Resource* resource2) {
+static void TestClientRemoval(ResourceFetcher* fetcher,
+                              const String& identifier1,
+                              const String& identifier2) {
+  GetMemoryCache()->SetCapacity(0);
   const char kData[6] = "abcde";
-  Persistent<MockResourceClient> client1 = new MockResourceClient(resource1);
+  Persistent<MockResourceClient> client1 = new MockResourceClient;
+  Persistent<MockResourceClient> client2 = new MockResourceClient;
+  FetchParameters params1(ResourceRequest("data:text/html,foo"));
+  Resource* resource1 = FakeDecodedResource::Fetch(params1, fetcher, client1);
+  FetchParameters params2(ResourceRequest("data:text/html,bar"));
+  Resource* resource2 = FakeDecodedResource::Fetch(params2, fetcher, client2);
   resource1->AppendData(kData, 4u);
-  Persistent<MockResourceClient> client2 = new MockResourceClient(resource2);
   resource2->AppendData(kData, 4u);
 
   GetMemoryCache()->SetCapacity(0);
+  // Remove and re-Add the resources, with proper cache identifiers.
+  GetMemoryCache()->Remove(resource1);
+  GetMemoryCache()->Remove(resource2);
+  if (!identifier1.IsEmpty())
+    resource1->SetCacheIdentifier(identifier1);
+  if (!identifier2.IsEmpty())
+    resource2->SetCacheIdentifier(identifier2);
   GetMemoryCache()->Add(resource1);
   GetMemoryCache()->Add(resource2);
 
@@ -287,40 +310,20 @@ static void TestClientRemoval(Resource* resource1, Resource* resource2) {
 }
 
 TEST_F(MemoryCacheTest, ClientRemoval_Basic) {
-  Resource* resource1 =
-      FakeDecodedResource::Create("http://foo.com", Resource::kRaw);
-  Resource* resource2 =
-      FakeDecodedResource::Create("http://test/resource", Resource::kRaw);
-  TestClientRemoval(resource1, resource2);
+  TestClientRemoval(fetcher_, "", "");
 }
 
 TEST_F(MemoryCacheTest, ClientRemoval_MultipleResourceMaps) {
   {
-    Resource* resource1 =
-        FakeDecodedResource::Create("http://foo.com", Resource::kRaw);
-    resource1->SetCacheIdentifier("foo");
-    Resource* resource2 =
-        FakeDecodedResource::Create("http://test/resource", Resource::kRaw);
-    TestClientRemoval(resource1, resource2);
+    TestClientRemoval(fetcher_, "foo", "");
     GetMemoryCache()->EvictResources();
   }
   {
-    Resource* resource1 =
-        FakeDecodedResource::Create("http://foo.com", Resource::kRaw);
-    Resource* resource2 =
-        FakeDecodedResource::Create("http://test/resource", Resource::kRaw);
-    resource2->SetCacheIdentifier("foo");
-    TestClientRemoval(resource1, resource2);
+    TestClientRemoval(fetcher_, "", "foo");
     GetMemoryCache()->EvictResources();
   }
   {
-    Resource* resource1 =
-        FakeDecodedResource::Create("http://test/resource", Resource::kRaw);
-    resource1->SetCacheIdentifier("foo");
-    Resource* resource2 =
-        FakeDecodedResource::Create("http://test/resource", Resource::kRaw);
-    resource2->SetCacheIdentifier("bar");
-    TestClientRemoval(resource1, resource2);
+    TestClientRemoval(fetcher_, "foo", "bar");
     GetMemoryCache()->EvictResources();
   }
 }

third_party/WebKit/Source/platform/loader/fetch/ResourceFetcherTest.cpp

@@ -135,13 +135,13 @@ TEST_F(ResourceFetcherTest, UseExistingResource) {
   RegisterMockedURLLoadWithCustomResponse(url, response);
 
   FetchParameters fetch_params{ResourceRequest(url)};
-  Resource* resource = MockResource::Fetch(fetch_params, fetcher);
+  Resource* resource = MockResource::Fetch(fetch_params, fetcher, nullptr);
   ASSERT_TRUE(resource);
   platform_->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
   EXPECT_TRUE(resource->IsLoaded());
   EXPECT_TRUE(GetMemoryCache()->Contains(resource));
 
-  Resource* new_resource = MockResource::Fetch(fetch_params, fetcher);
+  Resource* new_resource = MockResource::Fetch(fetch_params, fetcher, nullptr);
   EXPECT_EQ(resource, new_resource);
 }
 
@@ -240,13 +240,14 @@ TEST_F(ResourceFetcherTest, VaryResource) {
   RegisterMockedURLLoadWithCustomResponse(url, response);
 
   FetchParameters fetch_params_original{ResourceRequest(url)};
-  Resource* resource = MockResource::Fetch(fetch_params_original, fetcher);
+  Resource* resource =
+      MockResource::Fetch(fetch_params_original, fetcher, nullptr);
   ASSERT_TRUE(resource);
   platform_->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
   ASSERT_TRUE(resource->MustReloadDueToVaryHeader(ResourceRequest(url)));
 
   FetchParameters fetch_params{ResourceRequest(url)};
-  Resource* new_resource = MockResource::Fetch(fetch_params, fetcher);
+  Resource* new_resource = MockResource::Fetch(fetch_params, fetcher, nullptr);
   EXPECT_EQ(resource, new_resource);
 }
 
@@ -256,9 +257,10 @@ class RequestSameResourceOnComplete
   USING_GARBAGE_COLLECTED_MIXIN(RequestSameResourceOnComplete);
 
  public:
-  explicit RequestSameResourceOnComplete(Resource* resource)
+  explicit RequestSameResourceOnComplete(FetchParameters& params,
+                                         ResourceFetcher* fetcher)
       : notify_finished_called_(false) {
-    SetResource(resource);
+    MockResource::Fetch(params, fetcher, this);
   }
 
   void NotifyFinished(Resource* resource) override {
@@ -269,9 +271,10 @@ class RequestSameResourceOnComplete
     ResourceRequest resource_request2(GetResource()->Url());
     resource_request2.SetCacheMode(mojom::FetchCacheMode::kValidateCache);
     FetchParameters fetch_params2(resource_request2);
-    Resource* resource2 = MockResource::Fetch(fetch_params2, fetcher2);
+    Resource* resource2 = MockResource::Fetch(fetch_params2, fetcher2, nullptr);
     EXPECT_EQ(GetResource(), resource2);
     notify_finished_called_ = true;
+    ClearResource();
   }
   bool NotifyFinishedCalled() const { return notify_finished_called_; }
 
@@ -297,13 +300,10 @@ TEST_F(ResourceFetcherTest, RevalidateWhileFinishingLoading) {
   ResourceRequest request1(url);
   request1.SetHTTPHeaderField(HTTPNames::Cache_Control, "no-cache");
   FetchParameters fetch_params1(request1);
-  Resource* resource1 = MockResource::Fetch(fetch_params1, fetcher1);
   Persistent<RequestSameResourceOnComplete> client =
-      new RequestSameResourceOnComplete(resource1);
-  resource1->AddClient(client);
+      new RequestSameResourceOnComplete(fetch_params1, fetcher1);
   platform_->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
   EXPECT_TRUE(client->NotifyFinishedCalled());
-  resource1->RemoveClient(client);
 }
 
 TEST_F(ResourceFetcherTest, DontReuseMediaDataUrl) {
@@ -482,7 +482,8 @@ TEST_F(ResourceFetcherTest, PreloadResourceTwice) {
 
   FetchParameters fetch_params_original{ResourceRequest(url)};
   fetch_params_original.SetLinkPreload(true);
-  Resource* resource = MockResource::Fetch(fetch_params_original, fetcher);
+  Resource* resource =
+      MockResource::Fetch(fetch_params_original, fetcher, nullptr);
   ASSERT_TRUE(resource);
   EXPECT_TRUE(resource->IsLinkPreload());
   EXPECT_TRUE(fetcher->ContainsAsPreload(resource));
@@ -490,7 +491,7 @@ TEST_F(ResourceFetcherTest, PreloadResourceTwice) {
 
   FetchParameters fetch_params{ResourceRequest(url)};
   fetch_params.SetLinkPreload(true);
-  Resource* new_resource = MockResource::Fetch(fetch_params, fetcher);
+  Resource* new_resource = MockResource::Fetch(fetch_params, fetcher, nullptr);
   EXPECT_EQ(resource, new_resource);
   EXPECT_TRUE(fetcher->ContainsAsPreload(resource));
 
@@ -509,7 +510,8 @@ TEST_F(ResourceFetcherTest, LinkPreloadResourceAndUse) {
   // Link preload preload scanner
   FetchParameters fetch_params_original{ResourceRequest(url)};
   fetch_params_original.SetLinkPreload(true);
-  Resource* resource = MockResource::Fetch(fetch_params_original, fetcher);
+  Resource* resource =
+      MockResource::Fetch(fetch_params_original, fetcher, nullptr);
   ASSERT_TRUE(resource);
   EXPECT_TRUE(resource->IsLinkPreload());
   platform_->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
@@ -517,14 +519,14 @@ TEST_F(ResourceFetcherTest, LinkPreloadResourceAndUse) {
   // Resource created by preload scanner
   FetchParameters fetch_params_preload_scanner{ResourceRequest(url)};
   Resource* preload_scanner_resource =
-      MockResource::Fetch(fetch_params_preload_scanner, fetcher);
+      MockResource::Fetch(fetch_params_preload_scanner, fetcher, nullptr);
   EXPECT_EQ(resource, preload_scanner_resource);
   EXPECT_FALSE(resource->IsLinkPreload());
 
   // Resource created by parser
   FetchParameters fetch_params{ResourceRequest(url)};
-  Resource* new_resource = MockResource::Fetch(fetch_params, fetcher);
-  Persistent<MockResourceClient> client = new MockResourceClient(new_resource);
+  Persistent<MockResourceClient> client = new MockResourceClient;
+  Resource* new_resource = MockResource::Fetch(fetch_params, fetcher, client);
   EXPECT_EQ(resource, new_resource);
   EXPECT_FALSE(resource->IsLinkPreload());
 
@@ -541,7 +543,8 @@ TEST_F(ResourceFetcherTest, PreloadMatchWithBypassingCache) {
 
   FetchParameters fetch_params_original{ResourceRequest(url)};
   fetch_params_original.SetLinkPreload(true);
-  Resource* resource = MockResource::Fetch(fetch_params_original, fetcher);
+  Resource* resource =
+      MockResource::Fetch(fetch_params_original, fetcher, nullptr);
   ASSERT_TRUE(resource);
   EXPECT_TRUE(resource->IsLinkPreload());
   platform_->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
@@ -549,7 +552,8 @@ TEST_F(ResourceFetcherTest, PreloadMatchWithBypassingCache) {
   FetchParameters fetch_params_second{ResourceRequest(url)};
   fetch_params_second.MutableResourceRequest().SetCacheMode(
       mojom::FetchCacheMode::kBypassCache);
-  Resource* second_resource = MockResource::Fetch(fetch_params_second, fetcher);
+  Resource* second_resource =
+      MockResource::Fetch(fetch_params_second, fetcher, nullptr);
   EXPECT_EQ(resource, second_resource);
   EXPECT_FALSE(resource->IsLinkPreload());
 }
@@ -563,7 +567,8 @@ TEST_F(ResourceFetcherTest, CrossFramePreloadMatchIsNotAllowed) {
 
   FetchParameters fetch_params_original{ResourceRequest(url)};
   fetch_params_original.SetLinkPreload(true);
-  Resource* resource = MockResource::Fetch(fetch_params_original, fetcher);
+  Resource* resource =
+      MockResource::Fetch(fetch_params_original, fetcher, nullptr);
   ASSERT_TRUE(resource);
   EXPECT_TRUE(resource->IsLinkPreload());
   platform_->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
@@ -572,7 +577,7 @@ TEST_F(ResourceFetcherTest, CrossFramePreloadMatchIsNotAllowed) {
   fetch_params_second.MutableResourceRequest().SetCacheMode(
       mojom::FetchCacheMode::kBypassCache);
   Resource* second_resource =
-      MockResource::Fetch(fetch_params_second, fetcher2);
+      MockResource::Fetch(fetch_params_second, fetcher2, nullptr);
 
   EXPECT_NE(resource, second_resource);
   EXPECT_TRUE(resource->IsLinkPreload());
@@ -588,20 +593,23 @@ TEST_F(ResourceFetcherTest, RepetitiveLinkPreloadShouldBeMerged) {
   FetchParameters fetch_params_for_preload{ResourceRequest(url)};
   fetch_params_for_preload.SetLinkPreload(true);
 
-  Resource* resource1 = MockResource::Fetch(fetch_params_for_preload, fetcher);
+  Resource* resource1 =
+      MockResource::Fetch(fetch_params_for_preload, fetcher, nullptr);
   ASSERT_TRUE(resource1);
   EXPECT_TRUE(resource1->IsUnusedPreload());
   EXPECT_TRUE(fetcher->ContainsAsPreload(resource1));
   platform_->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
 
   // The second preload fetch returns the first preload.
-  Resource* resource2 = MockResource::Fetch(fetch_params_for_preload, fetcher);
+  Resource* resource2 =
+      MockResource::Fetch(fetch_params_for_preload, fetcher, nullptr);
   EXPECT_TRUE(fetcher->ContainsAsPreload(resource1));
   EXPECT_TRUE(resource1->IsUnusedPreload());
   EXPECT_EQ(resource1, resource2);
 
   // preload matching
-  Resource* resource3 = MockResource::Fetch(fetch_params_for_request, fetcher);
+  Resource* resource3 =
+      MockResource::Fetch(fetch_params_for_request, fetcher, nullptr);
   EXPECT_EQ(resource1, resource3);
   EXPECT_FALSE(fetcher->ContainsAsPreload(resource1));
   EXPECT_FALSE(resource1->IsUnusedPreload());
@@ -618,20 +626,23 @@ TEST_F(ResourceFetcherTest, RepetitiveSpeculativePreloadShouldBeMerged) {
   fetch_params_for_preload.SetSpeculativePreloadType(
       FetchParameters::SpeculativePreloadType::kInDocument);
 
-  Resource* resource1 = MockResource::Fetch(fetch_params_for_preload, fetcher);
+  Resource* resource1 =
+      MockResource::Fetch(fetch_params_for_preload, fetcher, nullptr);
   ASSERT_TRUE(resource1);
   EXPECT_TRUE(resource1->IsUnusedPreload());
   EXPECT_TRUE(fetcher->ContainsAsPreload(resource1));
   platform_->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
 
   // The second preload fetch returns the first preload.
-  Resource* resource2 = MockResource::Fetch(fetch_params_for_preload, fetcher);
+  Resource* resource2 =
+      MockResource::Fetch(fetch_params_for_preload, fetcher, nullptr);
   EXPECT_TRUE(fetcher->ContainsAsPreload(resource1));
   EXPECT_TRUE(resource1->IsUnusedPreload());
   EXPECT_EQ(resource1, resource2);
 
   // preload matching
-  Resource* resource3 = MockResource::Fetch(fetch_params_for_request, fetcher);
+  Resource* resource3 =
+      MockResource::Fetch(fetch_params_for_request, fetcher, nullptr);
   EXPECT_EQ(resource1, resource3);
   EXPECT_FALSE(fetcher->ContainsAsPreload(resource1));
   EXPECT_FALSE(resource1->IsUnusedPreload());
@@ -650,8 +661,8 @@ TEST_F(ResourceFetcherTest, SpeculativePreloadShouldBePromotedToLinkePreload) {
   FetchParameters fetch_params_for_link_preload{ResourceRequest(url)};
   fetch_params_for_link_preload.SetLinkPreload(true);
 
-  Resource* resource1 =
-      MockResource::Fetch(fetch_params_for_speculative_preload, fetcher);
+  Resource* resource1 = MockResource::Fetch(
+      fetch_params_for_speculative_preload, fetcher, nullptr);
   ASSERT_TRUE(resource1);
   EXPECT_TRUE(resource1->IsUnusedPreload());
   EXPECT_FALSE(resource1->IsLinkPreload());
@@ -660,14 +671,15 @@ TEST_F(ResourceFetcherTest, SpeculativePreloadShouldBePromotedToLinkePreload) {
 
   // The second preload fetch returns the first preload.
   Resource* resource2 =
-      MockResource::Fetch(fetch_params_for_link_preload, fetcher);
+      MockResource::Fetch(fetch_params_for_link_preload, fetcher, nullptr);
   EXPECT_TRUE(fetcher->ContainsAsPreload(resource1));
   EXPECT_TRUE(resource1->IsUnusedPreload());
   EXPECT_TRUE(resource1->IsLinkPreload());
   EXPECT_EQ(resource1, resource2);
 
   // preload matching
-  Resource* resource3 = MockResource::Fetch(fetch_params_for_request, fetcher);
+  Resource* resource3 =
+      MockResource::Fetch(fetch_params_for_request, fetcher, nullptr);
   EXPECT_EQ(resource1, resource3);
   EXPECT_FALSE(fetcher->ContainsAsPreload(resource1));
   EXPECT_FALSE(resource1->IsUnusedPreload());
@@ -705,16 +717,17 @@ TEST_F(ResourceFetcherTest, LinkPreloadResourceMultipleFetchersAndMove) {
 
   FetchParameters fetch_params_original{ResourceRequest(url)};
   fetch_params_original.SetLinkPreload(true);
-  Resource* resource = MockResource::Fetch(fetch_params_original, fetcher);
+  Resource* resource =
+      MockResource::Fetch(fetch_params_original, fetcher, nullptr);
   ASSERT_TRUE(resource);
   EXPECT_TRUE(resource->IsLinkPreload());
   EXPECT_EQ(0, fetcher->BlockingRequestCount());
 
   // Resource created by parser on the second fetcher
   FetchParameters fetch_params2{ResourceRequest(url)};
-  Resource* new_resource2 = MockResource::Fetch(fetch_params2, fetcher2);
-  Persistent<MockResourceClient> client2 =
-      new MockResourceClient(new_resource2);
+  Persistent<MockResourceClient> client2 = new MockResourceClient;
+  Resource* new_resource2 =
+      MockResource::Fetch(fetch_params2, fetcher2, client2);
   EXPECT_NE(resource, new_resource2);
   EXPECT_EQ(0, fetcher2->BlockingRequestCount());
   platform_->GetURLLoaderMockFactory()->ServeAsynchronousRequests();
@@ -723,7 +736,7 @@ TEST_F(ResourceFetcherTest, LinkPreloadResourceMultipleFetchersAndMove) {
 TEST_F(ResourceFetcherTest, ContentTypeDataURL) {
   ResourceFetcher* fetcher = ResourceFetcher::Create(Context());
   FetchParameters fetch_params{ResourceRequest("data:text/testmimetype,foo")};
-  Resource* resource = MockResource::Fetch(fetch_params, fetcher);
+  Resource* resource = MockResource::Fetch(fetch_params, fetcher, nullptr);
   ASSERT_TRUE(resource);
   EXPECT_EQ(ResourceStatus::kCached, resource->GetStatus());
   EXPECT_EQ("text/testmimetype", resource->GetResponse().MimeType());

third_party/WebKit/Source/platform/loader/fetch/ResourceTest.cpp

@@ -167,7 +167,8 @@ TEST(ResourceTest, RevalidationSucceeded) {
   // Simulate a successful revalidation.
   resource->SetRevalidatingRequest(ResourceRequest("data:text/html,"));
 
-  Persistent<MockResourceClient> client = new MockResourceClient(resource);
+  Persistent<MockResourceClient> client = new MockResourceClient;
+  resource->AddClient(client);
 
   ResourceResponse revalidating_response;
   revalidating_response.SetHTTPStatusCode(304);
@@ -179,7 +180,7 @@ TEST(ResourceTest, RevalidationSucceeded) {
             GetMemoryCache()->ResourceForURL(KURL("data:text/html,")));
   GetMemoryCache()->Remove(resource);
 
-  client->RemoveAsClient();
+  resource->RemoveClient(client);
   EXPECT_FALSE(resource->IsAlive());
   EXPECT_FALSE(client->NotifyFinishedCalled());
 }
@@ -197,7 +198,8 @@ TEST(ResourceTest, RevalidationSucceededForResourceWithoutBody) {
   // Simulate a successful revalidation.
   resource->SetRevalidatingRequest(ResourceRequest("data:text/html,"));
 
-  Persistent<MockResourceClient> client = new MockResourceClient(resource);
+  Persistent<MockResourceClient> client = new MockResourceClient;
+  resource->AddClient(client);
 
   ResourceResponse revalidating_response;
   revalidating_response.SetHTTPStatusCode(304);
@@ -209,7 +211,7 @@ TEST(ResourceTest, RevalidationSucceededForResourceWithoutBody) {
             GetMemoryCache()->ResourceForURL(KURL("data:text/html,")));
   GetMemoryCache()->Remove(resource);
 
-  client->RemoveAsClient();
+  resource->RemoveClient(client);
   EXPECT_FALSE(resource->IsAlive());
   EXPECT_FALSE(client->NotifyFinishedCalled());
 }
@@ -249,7 +251,8 @@ TEST(ResourceTest, RevalidationSucceededUpdateHeaders) {
   EXPECT_EQ("custom value",
             resource->GetResponse().HttpHeaderField("x-custom"));
 
-  Persistent<MockResourceClient> client = new MockResourceClient(resource);
+  Persistent<MockResourceClient> client = new MockResourceClient;
+  resource->AddClient(client);
 
   // Perform a revalidation step.
   ResourceResponse revalidating_response;
@@ -282,8 +285,6 @@ TEST(ResourceTest, RevalidationSucceededUpdateHeaders) {
             resource->GetResponse().HttpHeaderField("proxy-connection"));
   EXPECT_EQ("updated", resource->GetResponse().HttpHeaderField("x-custom"));
 
-  client->RemoveAsClient();
-
   resource->RemoveClient(client);
   EXPECT_FALSE(resource->IsAlive());
   EXPECT_FALSE(client->NotifyFinishedCalled());
@@ -317,7 +318,8 @@ TEST(ResourceTest, RedirectDuringRevalidation) {
   EXPECT_EQ("https://example.com/1",
             resource->LastResourceRequest().Url().GetString());
 
-  Persistent<MockResourceClient> client = new MockResourceClient(resource);
+  Persistent<MockResourceClient> client = new MockResourceClient;
+  resource->AddClient(client);
 
   // The revalidating request is redirected.
   ResourceResponse redirect_response;
@@ -355,7 +357,8 @@ TEST(ResourceTest, RedirectDuringRevalidation) {
   EXPECT_TRUE(client->NotifyFinishedCalled());
 
   // Test the case where a client is added after revalidation is completed.
-  Persistent<MockResourceClient> client2 = new MockResourceClient(resource);
+  Persistent<MockResourceClient> client2 = new MockResourceClient;
+  resource->AddClient(client2);
 
   // Because the client is added asynchronously,
   // |runUntilIdle()| is called to make |client2| to be notified.
@@ -365,8 +368,8 @@ TEST(ResourceTest, RedirectDuringRevalidation) {
 
   GetMemoryCache()->Remove(resource);
 
-  client->RemoveAsClient();
-  client2->RemoveAsClient();
+  resource->RemoveClient(client);
+  resource->RemoveClient(client2);
   EXPECT_FALSE(resource->IsAlive());
 }
 

third_party/WebKit/Source/platform/loader/testing/MockResource.cpp

@@ -26,10 +26,11 @@ class MockResourceFactory final : public NonTextResourceFactory {
 
 // static
 MockResource* MockResource::Fetch(FetchParameters& params,
-                                  ResourceFetcher* fetcher) {
+                                  ResourceFetcher* fetcher,
+                                  ResourceClient* client) {
   params.SetRequestContext(WebURLRequest::kRequestContextSubresource);
-  Resource* resource = fetcher->RequestResource(params, MockResourceFactory());
-  return static_cast<MockResource*>(resource);
+  return static_cast<MockResource*>(
+      fetcher->RequestResource(params, MockResourceFactory(), client));
 }
 
 // static

third_party/WebKit/Source/platform/loader/testing/MockResource.h

@@ -20,7 +20,9 @@ struct ResourceLoaderOptions;
 // class to verify classes that consume Resource sub-classes in a simple way.
 class MockResource final : public Resource {
  public:
-  static MockResource* Fetch(FetchParameters&, ResourceFetcher*);
+  static MockResource* Fetch(FetchParameters&,
+                             ResourceFetcher*,
+                             ResourceClient*);
   static MockResource* Create(const ResourceRequest&);
   MockResource(const ResourceRequest&, const ResourceLoaderOptions&);
 };

third_party/WebKit/Source/platform/loader/testing/MockResourceClient.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 "platform/loader/testing/MockResourceClient.h"
-
-namespace blink {
-
-MockResourceClient::MockResourceClient(Resource* resource)
-    : resource_(resource),
-      notify_finished_called_(false),
-      encoded_size_on_notify_finished_(0) {
-  resource_->AddClient(this);
-}
-
-MockResourceClient::~MockResourceClient() {}
-
-void MockResourceClient::NotifyFinished(Resource* resource) {
-  CHECK(!notify_finished_called_);
-  notify_finished_called_ = true;
-  encoded_size_on_notify_finished_ = resource->EncodedSize();
-}
-
-void MockResourceClient::RemoveAsClient() {
-  resource_->RemoveClient(this);
-  resource_ = nullptr;
-}
-
-void MockResourceClient::Dispose() {
-  if (resource_) {
-    resource_->RemoveClient(this);
-    resource_ = nullptr;
-  }
-}
-
-void MockResourceClient::Trace(blink::Visitor* visitor) {
-  visitor->Trace(resource_);
-  ResourceClient::Trace(visitor);
-}
-
-}  // namespace blink

third_party/WebKit/Source/platform/loader/testing/MockResourceClient.h

@@ -32,37 +32,28 @@
 #define MockResourceClient_h
 
 #include "platform/heap/Handle.h"
-#include "platform/loader/fetch/Resource.h"
 #include "platform/loader/fetch/ResourceClient.h"
 
 namespace blink {
 
 class MockResourceClient : public GarbageCollectedFinalized<MockResourceClient>,
                            public ResourceClient {
-  USING_PRE_FINALIZER(MockResourceClient, Dispose);
   USING_GARBAGE_COLLECTED_MIXIN(MockResourceClient);
 
  public:
-  explicit MockResourceClient(Resource*);
-  ~MockResourceClient() override;
+  MockResourceClient() {}
+  ~MockResourceClient() override {}
 
-  void NotifyFinished(Resource*) override;
-  String DebugName() const override { return "MockResourceClient"; }
-  virtual bool NotifyFinishedCalled() const { return notify_finished_called_; }
-
-  size_t EncodedSizeOnNotifyFinished() const {
-    return encoded_size_on_notify_finished_;
+  void NotifyFinished(Resource*) override {
+    CHECK(!notify_finished_called_);
+    notify_finished_called_ = true;
   }
-
-  virtual void RemoveAsClient();
-  virtual void Dispose();
-
-  void Trace(blink::Visitor*) override;
+  String DebugName() const override { return "MockResourceClient"; }
+  bool NotifyFinishedCalled() const { return notify_finished_called_; }
+  void RemoveAsClient() { ClearResource(); }
 
  protected:
-  Member<Resource> resource_;
-  bool notify_finished_called_;
-  size_t encoded_size_on_notify_finished_;
+  bool notify_finished_called_ = false;
 };
 
 }  // namespace blink