Remove ResourceFetcher::preloads

third_party/WebKit/Source/core/loader/resource/LinkPreloadResourceClients.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 LinkPreloadResourceClients_h
 #define LinkPreloadResourceClients_h
 
 #include "core/loader/resource/CSSStyleSheetResource.h"
 #include "core/loader/resource/FontResource.h"
 #include "core/loader/resource/ImageResource.h"
 #include "core/loader/resource/ScriptResource.h"
 #include "core/loader/resource/StyleSheetResourceClient.h"
 #include "platform/loader/fetch/RawResource.h"
 #include "platform/loader/fetch/ResourceOwner.h"
 
 namespace blink {
 
 class LinkLoader;
 
 class LinkPreloadResourceClient
     : public GarbageCollectedFinalized<LinkPreloadResourceClient> {
  public:
   virtual ~LinkPreloadResourceClient() {}
 
   void triggerEvents(const Resource*);
+  virtual Resource* resource() = 0;
   virtual void clear() = 0;
 
   DEFINE_INLINE_VIRTUAL_TRACE() { visitor->trace(m_loader); }
 
  protected:
   explicit LinkPreloadResourceClient(LinkLoader* loader) : m_loader(loader) {
     DCHECK(loader);
   }
 
  private:
   Member<LinkLoader> m_loader;
 };
 
 class LinkPreloadScriptResourceClient
     : public LinkPreloadResourceClient,
       public ResourceOwner<ScriptResource, ScriptResourceClient> {
   USING_GARBAGE_COLLECTED_MIXIN(LinkPreloadScriptResourceClient);
 
  public:
   static LinkPreloadScriptResourceClient* create(LinkLoader* loader,
                                                  ScriptResource* resource) {
     return new LinkPreloadScriptResourceClient(loader, resource);
   }
 
   virtual String debugName() const { return "LinkPreloadScript"; }
   virtual ~LinkPreloadScriptResourceClient() {}
 
+  Resource* resource() override {
+    return ResourceOwner<ScriptResource>::resource();
+  }
   void clear() override { clearResource(); }
 
   void notifyFinished(Resource* resource) override {
     DCHECK_EQ(this->resource(), resource);
     triggerEvents(resource);
   }
 
   DEFINE_INLINE_VIRTUAL_TRACE() {
     LinkPreloadResourceClient::trace(visitor);
     ResourceOwner<ScriptResource, ScriptResourceClient>::trace(visitor);
@@ skipping 14 matching lines @@
  public:
   static LinkPreloadStyleResourceClient* create(
       LinkLoader* loader,
       CSSStyleSheetResource* resource) {
     return new LinkPreloadStyleResourceClient(loader, resource);
   }
 
   virtual String debugName() const { return "LinkPreloadStyle"; }
   virtual ~LinkPreloadStyleResourceClient() {}
 
+  Resource* resource() override {
+    return ResourceOwner<CSSStyleSheetResource>::resource();
+  }
   void clear() override { clearResource(); }
 
   void setCSSStyleSheet(const String&,
                         const KURL&,
                         ReferrerPolicy,
                         const String&,
                         const CSSStyleSheetResource* resource) override {
     DCHECK_EQ(this->resource(), resource);
     triggerEvents(static_cast<const Resource*>(resource));
   }
@@ skipping 18 matching lines @@
 
  public:
   static LinkPreloadImageResourceClient* create(LinkLoader* loader,
                                                 ImageResource* resource) {
     return new LinkPreloadImageResourceClient(loader, resource);
   }
 
   virtual String debugName() const { return "LinkPreloadImage"; }
   virtual ~LinkPreloadImageResourceClient() {}
 
+  Resource* resource() override {
+    return ResourceOwner<ImageResource>::resource();
+  }
   void clear() override { clearResource(); }
 
   void notifyFinished(Resource* resource) override {
     DCHECK_EQ(this->resource(), toImageResource(resource));
     triggerEvents(resource);
   }
 
   DEFINE_INLINE_VIRTUAL_TRACE() {
     LinkPreloadResourceClient::trace(visitor);
     ResourceOwner<ImageResource>::trace(visitor);
@@ skipping 13 matching lines @@
 
  public:
   static LinkPreloadFontResourceClient* create(LinkLoader* loader,
                                                FontResource* resource) {
     return new LinkPreloadFontResourceClient(loader, resource);
   }
 
   virtual String debugName() const { return "LinkPreloadFont"; }
   virtual ~LinkPreloadFontResourceClient() {}
 
+  Resource* resource() override {
+    return ResourceOwner<FontResource>::resource();
+  }
   void clear() override { clearResource(); }
 
   void notifyFinished(Resource* resource) override {
     DCHECK_EQ(this->resource(), toFontResource(resource));
     triggerEvents(resource);
   }
 
   DEFINE_INLINE_VIRTUAL_TRACE() {
     LinkPreloadResourceClient::trace(visitor);
     ResourceOwner<FontResource, FontResourceClient>::trace(visitor);
@@ skipping 13 matching lines @@
 
  public:
   static LinkPreloadRawResourceClient* create(LinkLoader* loader,
                                               RawResource* resource) {
     return new LinkPreloadRawResourceClient(loader, resource);
   }
 
   virtual String debugName() const { return "LinkPreloadRaw"; }
   virtual ~LinkPreloadRawResourceClient() {}
 
+  Resource* resource() override {
+    return ResourceOwner<RawResource>::resource();
+  }
   void clear() override { clearResource(); }
 
   void notifyFinished(Resource* resource) override {
     DCHECK_EQ(this->resource(), toRawResource(resource));
     triggerEvents(resource);
   }
 
   DEFINE_INLINE_VIRTUAL_TRACE() {
     LinkPreloadResourceClient::trace(visitor);
     ResourceOwner<RawResource, RawResourceClient>::trace(visitor);
   }
 
  private:
   LinkPreloadRawResourceClient(LinkLoader* loader, RawResource* resource)
       : LinkPreloadResourceClient(loader) {
     setResource(resource, Resource::DontMarkAsReferenced);
   }
 };
 
 }  // namespace blink
 
 #endif  // LinkPreloadResourceClients_h