ResourceFetcherTest: introduce FetchTestingPlatformSupport

third_party/WebKit/Source/core/fetch/MockFetchContext.h

 // Copyright 2016 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.
 
 #ifndef MockFetchContext_h
 #define MockFetchContext_h
 
 #include "core/fetch/FetchContext.h"
 #include "core/fetch/FetchRequest.h"
 #include "platform/network/ResourceTimingInfo.h"
@@ skipping 11 matching lines @@
 
 // Mocked FetchContext for testing.
 // TODO(toyoshim): Use this class by other unit tests that currently have own
 // mocked FetchContext respectively.
 class MockFetchContext : public FetchContext {
  public:
   enum LoadPolicy {
     kShouldLoadNewResource,
     kShouldNotLoadNewResource,
   };
-  static MockFetchContext* create(LoadPolicy loadPolicy) {
-    return new MockFetchContext(loadPolicy);
+  // TODO(toyoshim): Disallow to pass nullptr for |taskRunner|, and force to use

[Takashi Toyoshima, 2017/01/20 07:11:44]

Let me leave this TODO now because it's a little stressful to check my changes
work for both core and platform.

I'd adopt another CL to use FetchTestingPlatformSupport for other
MockFetchContext users, and remove old interfaces that use the
FakeWebTaskRunner.

+  // FetchTestingPlatformSupport's WebTaskRunner. Probably, MockFetchContext
+  // would be available only through the FetchTestingPlatformSupport in the
+  // future.
+  static MockFetchContext* create(LoadPolicy loadPolicy,
+                                  RefPtr<WebTaskRunner> taskRunner = nullptr) {
+    return new MockFetchContext(loadPolicy, std::move(taskRunner));
   }
 
   ~MockFetchContext() override {}
 
+  void setCachePolicy(CachePolicy policy) { m_policy = policy; }
+  void setLoadComplete(bool complete) { m_complete = complete; }
+  long long getTransferSize() const { return m_transferSize; }
+
+  // FetchContext:
   bool allowImage(bool imagesEnabled, const KURL&) const override {
     return true;
   }
   ResourceRequestBlockedReason canRequest(
       Resource::Type,
       const ResourceRequest&,
       const KURL&,
       const ResourceLoaderOptions&,
       bool forPreload,
       FetchRequest::OriginRestriction) const override {
     return ResourceRequestBlockedReason::None;
   }
   bool shouldLoadNewResource(Resource::Type) const override {
     return m_loadPolicy == kShouldLoadNewResource;
   }
   RefPtr<WebTaskRunner> loadingTaskRunner() const override { return m_runner; }
-
-  void setCachePolicy(CachePolicy policy) { m_policy = policy; }
   CachePolicy getCachePolicy() const override { return m_policy; }
-  void setLoadComplete(bool complete) { m_complete = complete; }
   bool isLoadComplete() const override { return m_complete; }
-
   void addResourceTiming(
       const ResourceTimingInfo& resourceTimingInfo) override {
     m_transferSize = resourceTimingInfo.transferSize();
   }
-  long long getTransferSize() const { return m_transferSize; }
 
  private:
-  MockFetchContext(LoadPolicy loadPolicy)
+  MockFetchContext(LoadPolicy loadPolicy, RefPtr<WebTaskRunner> taskRunner)
       : m_loadPolicy(loadPolicy),
         m_policy(CachePolicyVerify),
-        m_runner(adoptRef(new scheduler::FakeWebTaskRunner)),
+        m_runner(taskRunner ? std::move(taskRunner)
+                            : adoptRef(new scheduler::FakeWebTaskRunner)),
         m_complete(false),
         m_transferSize(-1) {}
 
   enum LoadPolicy m_loadPolicy;
   CachePolicy m_policy;
-  RefPtr<scheduler::FakeWebTaskRunner> m_runner;
+  RefPtr<WebTaskRunner> m_runner;
   bool m_complete;
   long long m_transferSize;
 };
 
 }  // namespace blink
 
 #endif