ur_ls -> urls in ResourceFetcher

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 287 matching lines @@
 // Limit the number of URLs in m_validatedURLs to avoid memory bloat.
 // http://crbug.com/52411
 static const int kMaxValidatedURLsSize = 10000;
 
 void ResourceFetcher::RequestLoadStarted(unsigned long identifier,
                                          Resource* resource,
                                          const FetchRequest& request,
                                          RevalidationPolicy policy,
                                          bool is_static_data) {
   if (policy == kUse && resource->GetStatus() == ResourceStatus::kCached &&
-      !validated_ur_ls_.Contains(resource->Url())) {
+      !validated_urls_.Contains(resource->Url())) {
     // Loaded from MemoryCache.
     DidLoadResourceFromMemoryCache(identifier, resource,
                                    request.GetResourceRequest());
   }
 
   if (is_static_data)
     return;
 
   if (policy == kUse && !resource->StillNeedsLoad() &&
-      !validated_ur_ls_.Contains(request.GetResourceRequest().Url())) {
+      !validated_urls_.Contains(request.GetResourceRequest().Url())) {
     // Resources loaded from memory cache should be reported the first time
     // they're used.
     RefPtr<ResourceTimingInfo> info = ResourceTimingInfo::Create(
         request.Options().initiator_info.name, MonotonicallyIncreasingTime(),
         resource->GetType() == Resource::kMainResource);
     PopulateTimingInfo(info.Get(), resource);
     info->ClearLoadTimings();
     info->SetLoadFinishTime(info->InitialTime());
     scheduled_resource_timing_reports_.push_back(info.Release());
     if (!resource_timing_report_timer_.IsActive())
       resource_timing_report_timer_.StartOneShot(0, BLINK_FROM_HERE);
   }
 
-  if (validated_ur_ls_.size() >= kMaxValidatedURLsSize) {
-    validated_ur_ls_.Clear();
+  if (validated_urls_.size() >= kMaxValidatedURLsSize) {
+    validated_urls_.Clear();
   }
-  validated_ur_ls_.insert(request.GetResourceRequest().Url());
+  validated_urls_.insert(request.GetResourceRequest().Url());
 }
 
 void ResourceFetcher::DidLoadResourceFromMemoryCache(
     unsigned long identifier,
     Resource* resource,
     const ResourceRequest& original_resource_request) {
   ResourceRequest resource_request(resource->Url());
   resource_request.SetFrameType(original_resource_request.GetFrameType());
   resource_request.SetRequestContext(
       original_resource_request.GetRequestContext());
@@ skipping 615 matching lines @@
     return kReload;
   }
 
   // During the initial load, avoid loading the same resource multiple times for
   // a single document, even if the cache policies would tell us to. We also
   // group loads of the same resource together. Raw resources are exempted, as
   // XHRs fall into this category and may have user-set Cache-Control: headers
   // or other factors that require separate requests.
   if (type != Resource::kRaw) {
     if (!Context().IsLoadComplete() &&
-        validated_ur_ls_.Contains(existing_resource->Url()))
+        validated_urls_.Contains(existing_resource->Url()))
       return kUse;
     if (existing_resource->IsLoading())
       return kUse;
   }
 
   // WebCachePolicy::BypassingCache always reloads
   if (request.GetCachePolicy() == WebCachePolicy::kBypassingCache) {
     RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::determineRevalidationPolicy "
                                  "reloading due to "
                                  "WebCachePolicy::BypassingCache.";
@@ skipping 107 matching lines @@
 
 void ResourceFetcher::PreloadStarted(Resource* resource) {
   if (preloads_ && preloads_->Contains(resource))
     return;
   resource->IncreasePreloadCount();
 
   if (!preloads_)
     preloads_ = new HeapListHashSet<Member<Resource>>;
   preloads_->insert(resource);
 
-  if (preloaded_ur_ls_for_test_)
-    preloaded_ur_ls_for_test_->insert(resource->Url().GetString());
+  if (preloaded_urls_for_test_)
+    preloaded_urls_for_test_->insert(resource->Url().GetString());
 }
 
 void ResourceFetcher::EnableIsPreloadedForTest() {
-  if (preloaded_ur_ls_for_test_)
+  if (preloaded_urls_for_test_)
     return;
-  preloaded_ur_ls_for_test_ = WTF::WrapUnique(new HashSet<String>);
+  preloaded_urls_for_test_ = WTF::WrapUnique(new HashSet<String>);
 
   if (preloads_) {
     for (const auto& resource : *preloads_)
-      preloaded_ur_ls_for_test_->insert(resource->Url().GetString());
+      preloaded_urls_for_test_->insert(resource->Url().GetString());
   }
 }
 
 bool ResourceFetcher::IsPreloadedForTest(const KURL& url) const {
-  DCHECK(preloaded_ur_ls_for_test_);
-  return preloaded_ur_ls_for_test_->Contains(url.GetString());
+  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_) {
     if (policy == kClearAllPreloads || !resource->IsLinkPreload()) {
@@ skipping 450 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