Move the code in ResourceFetcher handling calls from WebURLLoaderImpl to ResourceLoader

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

 /*
  * Copyright (C) 2005, 2006, 2011 Apple 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:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 21 matching lines @@
 #include "core/CoreExport.h"
 #include "core/fetch/ResourceLoaderOptions.h"
 #include "platform/network/ResourceRequest.h"
 #include "public/platform/WebURLLoader.h"
 #include "public/platform/WebURLLoaderClient.h"
 #include "wtf/Forward.h"
 #include <memory>
 
 namespace blink {
 
+class FetchContext;
 class Resource;
 class ResourceError;
 class ResourceFetcher;
 
+// A ResourceLoader is created for each Resource by the ResourceFetcher when it
+// needs to load the specified resource. A ResourceLoader creates a
+// WebURLLoader and loads the resource using it. Any per-load logic should be
+// implemented in this class basically.
 class CORE_EXPORT ResourceLoader final
     : public GarbageCollectedFinalized<ResourceLoader>,
       protected WebURLLoaderClient {
  public:
   static ResourceLoader* create(ResourceFetcher*, Resource*);
   ~ResourceLoader() override;
   DECLARE_TRACE();
 
-  void start(const ResourceRequest&,
-             WebTaskRunner* loadingTaskRunner,
-             bool defersLoading);
-
-  // This method is currently only used for service worker fallback request and
-  // cache-aware loading, other users should be careful not to break
-  // ResourceLoader state.
-  void restart(const ResourceRequest&,
-               WebTaskRunner* loadingTaskRunner,
-               bool defersLoading);
+  void start(const ResourceRequest&);
 
   void cancel();
 
   void setDefersLoading(bool);
 
   void didChangePriority(ResourceLoadPriority, int intraPriorityValue);
 
   // Called before start() to activate cache-aware loading if enabled in
   // |m_resource->options()| and applicable.
   void activateCacheAwareLoadingIfNeeded(const ResourceRequest&);
@@ skipping 24 matching lines @@
   void didReceiveCachedMetadata(const char* data, int length) override;
   void didReceiveData(const char*, int) override;
   void didReceiveTransferSizeUpdate(int transferSizeDiff) override;
   void didDownloadData(int, int) override;
   void didFinishLoading(double finishTime,
                         int64_t encodedDataLength,
                         int64_t encodedBodyLength) override;
   void didFail(const WebURLError&,
                int64_t encodedDataLength,
                int64_t encodedBodyLength) override;
+  void handleError(const ResourceError&);
 
   void didFinishLoadingFirstPartInMultipart();
-  void didFail(const ResourceError&);
 
  private:
   // Assumes ResourceFetcher and Resource are non-null.
   ResourceLoader(ResourceFetcher*, Resource*);
 
+  // This method is currently only used for service worker fallback request and
+  // cache-aware loading, other users should be careful not to break
+  // ResourceLoader state.
+  void restart(const ResourceRequest&);
+
+  FetchContext& context() const;
+  ResourceRequestBlockedReason canAccessResponse(Resource*,
+                                                 const ResourceResponse&) const;
+
   void cancelForRedirectAccessCheckError(const KURL&,
                                          ResourceRequestBlockedReason);
   void requestSynchronously(const ResourceRequest&);
 
   std::unique_ptr<WebURLLoader> m_loader;
   Member<ResourceFetcher> m_fetcher;
   Member<Resource> m_resource;
   bool m_isCacheAwareLoadingActivated;
 };
 
 }  // namespace blink
 
 #endif