Separate preload matching from MemoryCache

third_party/WebKit/Source/platform/loader/fetch/ResourceFetcher.h

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller <mueller@kde.org>
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
     rights reserved.
     Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
@@ skipping 15 matching lines @@
 
 #ifndef ResourceFetcher_h
 #define ResourceFetcher_h
 
 #include <memory>
 #include "platform/PlatformExport.h"
 #include "platform/Timer.h"
 #include "platform/loader/fetch/FetchContext.h"
 #include "platform/loader/fetch/FetchInitiatorInfo.h"
 #include "platform/loader/fetch/FetchParameters.h"
+#include "platform/loader/fetch/PreloadKey.h"
 #include "platform/loader/fetch/Resource.h"
 #include "platform/loader/fetch/ResourceError.h"
 #include "platform/loader/fetch/ResourceLoadPriority.h"
 #include "platform/loader/fetch/ResourceLoaderOptions.h"
 #include "platform/loader/fetch/SubstituteData.h"
 #include "platform/wtf/HashMap.h"
 #include "platform/wtf/HashSet.h"
 #include "platform/wtf/ListHashSet.h"
 #include "platform/wtf/text/StringHash.h"
 
@@ skipping 53 matching lines @@
   enum ClearPreloadsPolicy {
     kClearAllPreloads,
     kClearSpeculativeMarkupPreloads
   };
 
   void EnableIsPreloadedForTest();
   bool IsPreloadedForTest(const KURL&) const;
 
   int CountPreloads() const { return preloads_.size(); }
   void ClearPreloads(ClearPreloadsPolicy = kClearAllPreloads);
-  void PreloadStarted(Resource*);
   void LogPreloadStats(ClearPreloadsPolicy);
   void WarnUnusedPreloads();
 
   MHTMLArchive* Archive() const { return archive_.Get(); }
   ArchiveResource* CreateArchive(Resource*);
 
   void SetDefersLoading(bool);
   void StopFetching();
   bool IsFetching() const;
 
@@ skipping 18 matching lines @@
       Resource::Type,
       IsImageSet) const;
 
   void UpdateAllImageResourcePriorities();
 
   void ReloadLoFiImages();
 
   // Calling this method before main document resource is fetched is invalid.
   ResourceTimingInfo* GetNavigationTimingInfo();
 
-  bool ContainsAsPreloadForTesting(Resource* resource) const {
-    return preloads_.Contains(resource);
-  }
+  // Returns whether the given resource is contained as a preloaded resource.
+  bool ContainsAsPreload(Resource*) const;
+
+  void RemovePreload(Resource*);
 
   // Workaround for https://crbug.com/666214.
   // TODO(hiroshige): Remove this hack.
   void EmulateLoadStartedForInspector(Resource*,
                                       const KURL&,
                                       WebURLRequest::RequestContext,
                                       const AtomicString& initiator_name);
 
  private:
   friend class ResourceCacheValidationSuppressor;
@@ skipping 22 matching lines @@
                                       unsigned long identifier,
                                       ResourceRequestBlockedReason&);
 
   Resource* ResourceForStaticData(const FetchParameters&,
                                   const ResourceFactory&,
                                   const SubstituteData&);
   Resource* ResourceForBlockedRequest(const FetchParameters&,
                                       const ResourceFactory&,
                                       ResourceRequestBlockedReason);
 
+  Resource* MatchPreload(const FetchParameters& params, Resource::Type);
+  void InsertAsPreloadIfNecessary(Resource*,
+                                  const FetchParameters& params,
+                                  Resource::Type);
+
+  bool IsReusableAlsoForPreloading(const FetchParameters&,
+                                   Resource*,
+                                   bool is_static_data) const;
   // RevalidationPolicy enum values are used in UMAs https://crbug.com/579496.
   enum RevalidationPolicy { kUse, kRevalidate, kReload, kLoad };
   RevalidationPolicy DetermineRevalidationPolicy(Resource::Type,
                                                  const FetchParameters&,
                                                  Resource* existing_resource,
                                                  bool is_static_data) const;
 
   void MakePreloadedResourceBlockOnloadIfNeeded(Resource*,
                                                 const FetchParameters&);
   void MoveResourceLoaderToNonBlocking(ResourceLoader*);
@@ skipping 23 matching lines @@
                               RevalidationPolicy,
                               const FetchParameters&,
                               const ResourceFactory&,
                               bool is_static_data) const;
 
   Member<FetchContext> context_;
 
   HashSet<String> validated_urls_;
   mutable DocumentResourceMap document_resources_;
 
-  HeapListHashSet<Member<Resource>> preloads_;
+  HeapHashMap<PreloadKey, Member<Resource>> preloads_;
+  HeapVector<Member<Resource>> matched_preloads_;
   Member<MHTMLArchive> archive_;
 
   TaskRunnerTimer<ResourceFetcher> resource_timing_report_timer_;
 
   using ResourceTimingInfoMap =
       HeapHashMap<Member<Resource>, RefPtr<ResourceTimingInfo>>;
   ResourceTimingInfoMap resource_timing_info_map_;
 
   RefPtr<ResourceTimingInfo> navigation_timing_info_;
 
@@ skipping 29 matching lines @@
   }
 
  private:
   Member<ResourceFetcher> loader_;
   bool previous_state_;
 };
 
 }  // namespace blink
 
 #endif  // ResourceFetcher_h