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 17 matching lines @@
   enum LoadPolicy {
     kShouldLoadNewResource,
     kShouldNotLoadNewResource,
   };
   static MockFetchContext* create(LoadPolicy loadPolicy) {
     return new MockFetchContext(loadPolicy);
   }
 
   ~MockFetchContext() override {}
 
+  void setCachePolicy(CachePolicy policy) { m_policy = policy; }
+  void setLoadComplete(bool complete) { m_complete = complete; }
+  long long getTransferSize() const { return m_transferSize; }
+  void runLoadingTaskRunnerUntilIdle() { m_runner->runUntilIdle(); }
+
+  // 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; }

[kinuko, 2017/01/19 18:40:18]

Could you help me understand... so the task runner returned by this fetch
context and the task runner that is returned by
Platform::current()->currentThread()->scheduler()->loadingTaskRunner() are
different, is that right?  Wouldn't that become a problem at some point?

[Takashi Toyoshima, 2017/01/20 04:13:16]

The right approach to obtain the task runner in fetch is to access it via
FetchContext since it's per-frame runner. But unfortunately as you noticed, we
are using currentThread()->scheduler()->loadingTaskRunner() in some modules,
e.g. MemoryCache, Resource, and RawResource. Probably, we could change to use
per-frame task runner for *Resource, but I have no idea about the MemoryCache.
Probably, we will continue to use per-frame runner.

Once we move this test to platform, currentThread()->scheduler() is mocked by
TestingPlatformSupportWithMockScheduler. That does not have a MessageLoop, and
need to call another runUntilIdle method that the testing Platform instance has.
So anyway, current WebURLLoaderMockFactory's RunLoop does not work.

If all MockFetchContext users are moved to platform, we could change this to
return a task runner mocked by TestingPlatform..., but since this is used by
core/loader tests, using FakeWebTaskRunner here is a point of compromise.

[kinuko, 2017/01/20 05:00:33]

When you say MemoryCache do you mean the task observers for pruning?  And I see
it comes from the browser... I feel we might be able to deprecate the Web Cache
manager and this prune code path as we now have memory coordinator, but that's
probably another story.
Yep I noticed it.
 
Do you mean you're assuming we can't use TestingPlatform if the test's not in
platform?

-
-  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)
       : m_loadPolicy(loadPolicy),
         m_policy(CachePolicyVerify),
         m_runner(adoptRef(new scheduler::FakeWebTaskRunner)),
         m_complete(false),
         m_transferSize(-1) {}
 
   enum LoadPolicy m_loadPolicy;
   CachePolicy m_policy;
   RefPtr<scheduler::FakeWebTaskRunner> m_runner;
   bool m_complete;
   long long m_transferSize;
 };
 
 }  // namespace blink
 
 #endif