[WIP] WebFonts cache-aware timeout adaption

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

 /*
  * Copyright (c) 2013, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 31 matching lines @@
 #include "platform/heap/HeapAllocator.h"
 #include "platform/heap/Member.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceTimingInfo.h"
 #include "platform/scheduler/test/fake_web_task_runner.h"
 #include "platform/testing/URLTestHelpers.h"
 #include "platform/testing/weburl_loader_mock.h"
 #include "platform/weborigin/KURL.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTaskRunner.h"
+#include "public/platform/WebURLError.h"
 #include "public/platform/WebURLLoaderMockFactory.h"
 #include "public/platform/WebURLResponse.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "wtf/Allocator.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/Vector.h"
 #include <memory>
 
 namespace blink {
 
@@ skipping 680 matching lines @@
   Platform::current()->getURLLoaderMockFactory()->registerURL(
       url, WebURLResponse(), "");
   Resource* newResource = fetcher->requestResource(
       fetchRequest, TestResourceFactory(Resource::Raw));
   fetcher->stopFetching();
   Platform::current()->getURLLoaderMockFactory()->unregisterURL(url);
 
   EXPECT_NE(resource, newResource);
 }
 
+class CacheAwareResourceClient
+    : public GarbageCollectedFinalized<CacheAwareResourceClient>,
+      public RawResourceClient {
+  USING_GARBAGE_COLLECTED_MIXIN(CacheAwareResourceClient);
+
+ public:
+  CacheAwareResourceClient() : m_willReloadAfterDiskCacheMissCalled(false) {}
+
+  void setResource(Resource* resource) {
+    ASSERT_FALSE(m_resource);
+    m_resource = resource;
+  }
+
+  void willReloadAfterDiskCacheMiss(Resource* resource) override {
+    EXPECT_EQ(m_resource, resource);
+    m_willReloadAfterDiskCacheMissCalled = true;
+  }
+
+  bool willReloadAfterDiskCacheMissCalled() const {
+    return m_willReloadAfterDiskCacheMissCalled;
+  }
+
+  DEFINE_INLINE_TRACE() {
+    visitor->trace(m_resource);
+    RawResourceClient::trace(visitor);
+  }
+
+  String debugName() const override { return "CacheAwareResourceClient"; }
+
+ private:
+  Member<Resource> m_resource;
+  bool m_willReloadAfterDiskCacheMissCalled;
+};
+
+void runCacheAwareLoadingTest(CacheAwareResourceClient* client,
+                              const WebURLError& error) {
+  ResourceFetcher* fetcher =
+      ResourceFetcher::create(ResourceFetcherTestMockFetchContext::create());
+  KURL url(ParsedURLString, "http://127.0.0.1:8000/foo.html");
+  FetchRequest fetchRequest = FetchRequest(url, FetchInitiatorInfo());
+  fetchRequest.mutableResourceRequest().setIsCacheAwareLoadingEnabled(true);
+
+  ResourceResponse response;
+  response.setURL(url);
+  Platform::current()->getURLLoaderMockFactory()->registerErrorURL(
+      url, WrappedResourceResponse(response), error);
+
+  Resource* resource =
+      fetcher->requestResource(fetchRequest, TestResourceFactory());
+  ASSERT_TRUE(resource);
+  ASSERT_TRUE(resource->resourceRequest().isCacheAwareLoadingActivated());
+
+  client->setResource(resource);
+  resource->addClient(client);
+  Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests();
+  Platform::current()->getURLLoaderMockFactory()->unregisterURL(url);
+
+  resource->removeClient(client);
+  memoryCache()->remove(resource);
+}
+
+TEST_F(ResourceFetcherTest, CacheAwareLoading) {
+  Persistent<CacheAwareResourceClient> client = new CacheAwareResourceClient;
+  WebURLError error;
+  error.reason = -400;  // ERR_CACHE_MISS
+  runCacheAwareLoadingTest(client, error);
+  EXPECT_TRUE(client->willReloadAfterDiskCacheMissCalled());
+}
+
+TEST_F(ResourceFetcherTest, CacheAwareLoadingFailByAccessCheck) {
+  Persistent<CacheAwareResourceClient> client = new CacheAwareResourceClient;
+  runCacheAwareLoadingTest(client,
+                           ResourceError::cancelledDueToAccessCheckError(""));
+  EXPECT_FALSE(client->willReloadAfterDiskCacheMissCalled());
+}
+
+TEST_F(ResourceFetcherTest, CacheAwareLoadingFailByCancellation) {
+  Persistent<CacheAwareResourceClient> client = new CacheAwareResourceClient;
+  runCacheAwareLoadingTest(client, ResourceError::cancelledError(""));
+  EXPECT_FALSE(client->willReloadAfterDiskCacheMissCalled());
+}
+
 }  // namespace blink