Remove unnecessary indirection of ResourceFetcher::preloads_

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

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@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
@@ skipping 464 matching lines @@
   if (params.IsSpeculativePreload() || params.IsLinkPreload()) {
     DEFINE_RESOURCE_HISTOGRAM("Preload.");
   } else {
     DEFINE_RESOURCE_HISTOGRAM("");
   }
 
   // Aims to count Resource only referenced from MemoryCache (i.e. what would be
   // dead if MemoryCache holds weak references to Resource). Currently we check
   // references to Resource from ResourceClient and |m_preloads| only, because
   // they are major sources of references.
-  if (resource && !resource->IsAlive() &&
-      (!preloads_ || !preloads_->Contains(resource))) {
+  if (resource && !resource->IsAlive() && !preloads_.Contains(resource)) {
     DEFINE_RESOURCE_HISTOGRAM("Dead.");
   }
 }
 
 ResourceFetcher::PrepareRequestResult ResourceFetcher::PrepareRequest(
     FetchParameters& params,
     const ResourceFactory& factory,
     const SubstituteData& substitute_data,
     unsigned long identifier,
     ResourceRequestBlockedReason& blocked_reason) {
@@ skipping 584 matching lines @@
 
 int ResourceFetcher::BlockingRequestCount() const {
   return loaders_.size();
 }
 
 int ResourceFetcher::NonblockingRequestCount() const {
   return non_blocking_loaders_.size();
 }
 
 void ResourceFetcher::PreloadStarted(Resource* resource) {
-  if (preloads_ && preloads_->Contains(resource))
+  if (preloads_.Contains(resource))
     return;
   resource->IncreasePreloadCount();
 
-  if (!preloads_)
-    preloads_ = new HeapListHashSet<Member<Resource>>;
-  preloads_->insert(resource);
+  preloads_.insert(resource);
 
   if (preloaded_urls_for_test_)
     preloaded_urls_for_test_->insert(resource->Url().GetString());
 }
 
 void ResourceFetcher::EnableIsPreloadedForTest() {
   if (preloaded_urls_for_test_)
     return;
   preloaded_urls_for_test_ = WTF::WrapUnique(new HashSet<String>);
 
-  if (preloads_) {
-    for (const auto& resource : *preloads_)
-      preloaded_urls_for_test_->insert(resource->Url().GetString());
-  }
+  for (const auto& resource : preloads_)
+    preloaded_urls_for_test_->insert(resource->Url().GetString());
 }
 
 bool ResourceFetcher::IsPreloadedForTest(const KURL& url) const {
   DCHECK(preloaded_urls_for_test_);
   return preloaded_urls_for_test_->Contains(url.GetString());
 }
 
 void ResourceFetcher::ClearPreloads(ClearPreloadsPolicy policy) {
-  if (!preloads_)
-    return;
-
   LogPreloadStats(policy);
 
-  for (const auto& resource : *preloads_) {
+  for (const auto& resource : preloads_) {
     if (policy == kClearAllPreloads || !resource->IsLinkPreload()) {
       resource->DecreasePreloadCount();
       if (resource->GetPreloadResult() == Resource::kPreloadNotReferenced)
         GetMemoryCache()->Remove(resource.Get());
-      preloads_->erase(resource);
+      preloads_.erase(resource);
     }
   }
-  if (!preloads_->size())
-    preloads_.Clear();
 }
 
 void ResourceFetcher::WarnUnusedPreloads() {
-  if (!preloads_)
-    return;
-  for (const auto& resource : *preloads_) {
+  for (const auto& resource : preloads_) {
     if (resource && resource->IsLinkPreload() &&
         resource->GetPreloadResult() == Resource::kPreloadNotReferenced) {
       Context().AddConsoleMessage(
           "The resource " + resource->Url().GetString() +
               " was preloaded using link preload but not used within a few "
               "seconds from the window's load event. Please make sure it "
               "wasn't preloaded for nothing.",
           FetchContext::kLogWarningMessage);
     }
   }
@@ skipping 213 matching lines @@
 
 void ResourceFetcher::ReloadLoFiImages() {
   for (const auto& document_resource : document_resources_) {
     Resource* resource = document_resource.value.Get();
     if (resource)
       resource->ReloadIfLoFiOrPlaceholderImage(this, Resource::kReloadAlways);
   }
 }
 
 void ResourceFetcher::LogPreloadStats(ClearPreloadsPolicy policy) {
-  if (!preloads_)
-    return;
   unsigned scripts = 0;
   unsigned script_misses = 0;
   unsigned stylesheets = 0;
   unsigned stylesheet_misses = 0;
   unsigned images = 0;
   unsigned image_misses = 0;
   unsigned fonts = 0;
   unsigned font_misses = 0;
   unsigned medias = 0;
   unsigned media_misses = 0;
   unsigned text_tracks = 0;
   unsigned text_track_misses = 0;
   unsigned imports = 0;
   unsigned import_misses = 0;
   unsigned raws = 0;
   unsigned raw_misses = 0;
-  for (const auto& resource : *preloads_) {
+  for (const auto& resource : preloads_) {
     // Do not double count link rel preloads. These do not get cleared if the
     // ClearPreloadsPolicy is only clearing speculative markup preloads.
     if (resource->IsLinkPreload() &&
         policy == kClearSpeculativeMarkupPreloads) {
       continue;
     }
     int miss_count =
         resource->GetPreloadResult() == Resource::kPreloadNotReferenced ? 1 : 0;
     switch (resource->GetType()) {
       case Resource::kImage:
@@ skipping 174 matching lines @@
   visitor->Trace(context_);
   visitor->Trace(archive_);
   visitor->Trace(loaders_);
   visitor->Trace(non_blocking_loaders_);
   visitor->Trace(document_resources_);
   visitor->Trace(preloads_);
   visitor->Trace(resource_timing_info_map_);
 }
 
 }  // namespace blink