Replace ASSERT*() with DCHECK*() in core/fetch/ and core/loader/

third_party/WebKit/Source/core/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
     License as published by the Free Software Foundation; either
@@ skipping 90 matching lines @@
 
 static ResourceLoadPriority typeToPriority(Resource::Type type)
 {
     switch (type) {
     case Resource::MainResource:
     case Resource::CSSStyleSheet:
     case Resource::Font:
         // Also parser-blocking scripts (set explicitly in loadPriority)
         return ResourceLoadPriorityVeryHigh;
     case Resource::XSLStyleSheet:
-        ASSERT(RuntimeEnabledFeatures::xsltEnabled());
+        DCHECK(RuntimeEnabledFeatures::xsltEnabled());
     case Resource::Raw:
     case Resource::ImportResource:
     case Resource::Script:
         // Also visible resources/images (set explicitly in loadPriority)
         return ResourceLoadPriorityHigh;
     case Resource::Manifest:
         // Also late-body scripts discovered by the preload scanner (set explicitly in loadPriority)
         return ResourceLoadPriorityMedium;
     case Resource::Image:
     case Resource::TextTrack:
     case Resource::Media:
     case Resource::SVGDocument:
         // Also async scripts (set explicitly in loadPriority)
         return ResourceLoadPriorityLow;
     case Resource::LinkPrefetch:
         return ResourceLoadPriorityVeryLow;
     }
 
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return ResourceLoadPriorityUnresolved;
 }
 
 ResourceLoadPriority ResourceFetcher::computeLoadPriority(Resource::Type type, const FetchRequest& request, ResourcePriority::VisibilityStatus visibility)
 {
     ResourceLoadPriority priority = typeToPriority(type);
 
     // Visible resources (images in practice) get a boost to High priority.
     if (visibility == ResourcePriority::Visible)
         priority = ResourceLoadPriorityHigh;
@@ skipping 33 matching lines @@
 
 static WebURLRequest::RequestContext requestContextFromType(bool isMainFrame, Resource::Type type)
 {
     switch (type) {
     case Resource::MainResource:
         if (!isMainFrame)
             return WebURLRequest::RequestContextIframe;
         // FIXME: Change this to a context frame type (once we introduce them): http://fetch.spec.whatwg.org/#concept-request-context-frame-type
         return WebURLRequest::RequestContextHyperlink;
     case Resource::XSLStyleSheet:
-        ASSERT(RuntimeEnabledFeatures::xsltEnabled());
+        DCHECK(RuntimeEnabledFeatures::xsltEnabled());
     case Resource::CSSStyleSheet:
         return WebURLRequest::RequestContextStyle;
     case Resource::Script:
         return WebURLRequest::RequestContextScript;
     case Resource::Font:
         return WebURLRequest::RequestContextFont;
     case Resource::Image:
         return WebURLRequest::RequestContextImage;
     case Resource::Raw:
         return WebURLRequest::RequestContextSubresource;
     case Resource::ImportResource:
         return WebURLRequest::RequestContextImport;
     case Resource::LinkPrefetch:
         return WebURLRequest::RequestContextPrefetch;
     case Resource::TextTrack:
         return WebURLRequest::RequestContextTrack;
     case Resource::SVGDocument:
         return WebURLRequest::RequestContextImage;
     case Resource::Media: // TODO: Split this.
         return WebURLRequest::RequestContextVideo;
     case Resource::Manifest:
         return WebURLRequest::RequestContextManifest;
     }
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return WebURLRequest::RequestContextSubresource;
 }
 
 ResourceFetcher::ResourceFetcher(FetchContext* newContext)
     : m_context(newContext)
     , m_archive(context().isMainFrame() ? nullptr : context().archive())
     , m_resourceTimingReportTimer(this, &ResourceFetcher::resourceTimingReportTimerFired)
     , m_autoLoadImages(true)
     , m_imagesEnabled(true)
     , m_allowStaleResources(false)
@@ skipping 88 matching lines @@
 static std::unique_ptr<TracedValue> urlForTraceEvent(const KURL& url)
 {
     std::unique_ptr<TracedValue> value = TracedValue::create();
     value->setString("url", url.getString());
     return value;
 }
 
 Resource* ResourceFetcher::resourceForStaticData(const FetchRequest& request, const ResourceFactory& factory, const SubstituteData& substituteData)
 {
     const KURL& url = request.resourceRequest().url();
-    ASSERT(url.protocolIsData() || substituteData.isValid() || m_archive);
+    DCHECK(url.protocolIsData() || substituteData.isValid() || m_archive);
 
     // TODO(japhet): We only send main resource data: urls through WebURLLoader for the benefit of
     // a service worker test (RenderViewImplTest.ServiceWorkerNetworkProviderSetup), which is at a
     // layer where it isn't easy to mock out a network load. It uses data: urls to emulate the
     // behavior it wants to test, which would otherwise be reserved for network loads.
     if (!m_archive && !substituteData.isValid() && (factory.type() == Resource::MainResource || factory.type() == Resource::Raw))
         return nullptr;
 
     const String cacheIdentifier = getCacheIdentifier();
     if (Resource* oldResource = memoryCache()->resourceForURL(url, cacheIdentifier)) {
@@ skipping 69 matching lines @@
     // 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() && (!m_preloads || !m_preloads->contains(resource))) {
         DEFINE_RESOURCE_HISTOGRAM("Dead.");
     }
 }
 
 Resource* ResourceFetcher::requestResource(FetchRequest& request, const ResourceFactory& factory, const SubstituteData& substituteData)
 {
-    ASSERT(request.options().synchronousPolicy == RequestAsynchronously || factory.type() == Resource::Raw || factory.type() == Resource::XSLStyleSheet);
+    DCHECK(request.options().synchronousPolicy == RequestAsynchronously || factory.type() == Resource::Raw || factory.type() == Resource::XSLStyleSheet);
 
     context().populateRequestData(request.mutableResourceRequest());
     if (request.resourceRequest().httpHeaderField("Upgrade-Insecure-Requests") != AtomicString("1"))
         context().upgradeInsecureRequest(request.mutableResourceRequest());
     context().addClientHintsIfNecessary(request);
     context().addCSPHeaderIfNecessary(factory.type(), request);
 
     TRACE_EVENT1("blink", "ResourceFetcher::requestResource", "url", urlForTraceEvent(request.url()));
 
     if (!request.url().isValid())
@@ skipping 56 matching lines @@
         initializeRevalidation(request.mutableResourceRequest(), resource);
         break;
     case Use:
         memoryCache()->updateForAccess(resource);
         break;
     }
 
     if (!resource)
         return nullptr;
     if (resource->getType() != factory.type()) {
-        ASSERT(request.forPreload());
+        DCHECK(request.forPreload());
         return nullptr;
     }
 
     if (!resource->isAlive())
         m_deadStatsRecorder.update(policy);
 
     if (policy != Use)
         resource->setIdentifier(identifier);
 
     if (!request.forPreload() || policy != Use) {
@@ skipping 13 matching lines @@
 
     // Returns with an existing resource if the resource does not need to start
     // loading immediately.
     // If revalidation policy was determined as |Revalidate|, the resource was
     // already initialized for the revalidation here, but won't start loading.
     if (!resourceNeedsLoad(resource, request, policy))
         return resource;
 
     if (!startLoad(resource))
         return nullptr;
-    ASSERT(!resource->errorOccurred() || request.options().synchronousPolicy == RequestSynchronously);
+    DCHECK(!resource->errorOccurred() || request.options().synchronousPolicy == RequestSynchronously);
     return resource;
 }
 
 void ResourceFetcher::resourceTimingReportTimerFired(TimerBase* timer)
 {
-    ASSERT_UNUSED(timer, timer == &m_resourceTimingReportTimer);
+    DCHECK_EQ(timer, &m_resourceTimingReportTimer);
     Vector<std::unique_ptr<ResourceTimingInfo>> timingReports;
     timingReports.swap(m_scheduledResourceTimingReports);
     for (const auto& timingInfo : timingReports)
         context().addResourceTiming(*timingInfo);
 }
 
 void ResourceFetcher::determineRequestContext(ResourceRequest& request, Resource::Type type, bool isMainFrame)
 {
     WebURLRequest::RequestContext requestContext = requestContextFromType(isMainFrame, type);
     request.setRequestContext(requestContext);
@@ skipping 11 matching lines @@
     if (request.requestContext() == WebURLRequest::RequestContextUnspecified)
         determineRequestContext(request, type);
     if (type == Resource::LinkPrefetch)
         request.setHTTPHeaderField(HTTPNames::Purpose, "prefetch");
 
     context().addAdditionalRequestHeaders(request, (type == Resource::MainResource) ? FetchMainResource : FetchSubresource);
 }
 
 void ResourceFetcher::initializeRevalidation(ResourceRequest& revalidatingRequest, Resource* resource)
 {
-    ASSERT(resource);
-    ASSERT(memoryCache()->contains(resource));
-    ASSERT(resource->isLoaded());
-    ASSERT(resource->canUseCacheValidator());
-    ASSERT(!resource->isCacheValidator());
-    ASSERT(!context().isControlledByServiceWorker());
+    DCHECK(resource);
+    DCHECK(memoryCache()->contains(resource));
+    DCHECK(resource->isLoaded());
+    DCHECK(resource->canUseCacheValidator());
+    DCHECK(!resource->isCacheValidator());
+    DCHECK(!context().isControlledByServiceWorker());
 
     const AtomicString& lastModified = resource->response().httpHeaderField(HTTPNames::Last_Modified);
     const AtomicString& eTag = resource->response().httpHeaderField(HTTPNames::ETag);
     if (!lastModified.isEmpty() || !eTag.isEmpty()) {
-        ASSERT(context().getCachePolicy() != CachePolicyReload);
+        DCHECK_NE(context().getCachePolicy(), CachePolicyReload);
         if (context().getCachePolicy() == CachePolicyRevalidate)
             revalidatingRequest.setHTTPHeaderField(HTTPNames::Cache_Control, "max-age=0");
     }
     if (!lastModified.isEmpty())
         revalidatingRequest.setHTTPHeaderField(HTTPNames::If_Modified_Since, lastModified);
     if (!eTag.isEmpty())
         revalidatingRequest.setHTTPHeaderField(HTTPNames::If_None_Match, eTag);
 
     double stalenessLifetime = resource->stalenessLifetime();
     if (std::isfinite(stalenessLifetime) && stalenessLifetime > 0) {
         revalidatingRequest.setHTTPHeaderField(HTTPNames::Resource_Freshness, AtomicString(String::format("max-age=%.0lf,stale-while-revalidate=%.0lf,age=%.0lf", resource->freshnessLifetime(), stalenessLifetime, resource->currentAge())));
     }
 
     resource->setRevalidatingRequest(revalidatingRequest);
 }
 
 Resource* ResourceFetcher::createResourceForLoading(FetchRequest& request, const String& charset, const ResourceFactory& factory)
 {
     const String cacheIdentifier = getCacheIdentifier();
-    ASSERT(!memoryCache()->resourceForURL(request.resourceRequest().url(), cacheIdentifier));
+    DCHECK(!memoryCache()->resourceForURL(request.resourceRequest().url(), cacheIdentifier));
 
     RESOURCE_LOADING_DVLOG(1) << "Loading Resource for " << request.resourceRequest().url().elidedString();
 
     Resource* resource = factory.create(request.resourceRequest(), request.options(), charset);
     resource->setLinkPreload(request.isLinkPreload());
     if (request.forPreload()) {
         resource->setPreloadDiscoveryTime(request.preloadDiscoveryTime());
     }
     resource->setCacheIdentifier(cacheIdentifier);
 
@@ skipping 419 matching lines @@
 }
 
 void ResourceFetcher::moveResourceLoaderToNonBlocking(ResourceLoader* loader)
 {
     m_nonBlockingLoaders.add(loader);
     m_loaders.remove(loader);
 }
 
 bool ResourceFetcher::startLoad(Resource* resource)
 {
-    DCHECK(resource && resource->stillNeedsLoad());
+    DCHECK(resource);
+    DCHECK(resource->stillNeedsLoad());
     if (!context().shouldLoadNewResource(resource->getType())) {
         memoryCache()->remove(resource);
         return false;
     }
 
     ResourceRequest request(resource->resourceRequest());
     willSendRequest(resource->identifier(), request, ResourceResponse(), resource->options());
 
     ResourceLoader* loader = ResourceLoader::create(this, resource);
     if (resource->shouldBlockLoadEvent())
         m_loaders.add(loader);
     else
         m_nonBlockingLoaders.add(loader);
 
     storeResourceTimingInitiatorInformation(resource);
     resource->setFetcherSecurityOrigin(context().getSecurityOrigin());
     loader->start(request, context().loadingTaskRunner(), context().defersLoading());
     return true;
 }
 
 void ResourceFetcher::removeResourceLoader(ResourceLoader* loader)
 {
     if (m_loaders.contains(loader))
         m_loaders.remove(loader);
     else if (m_nonBlockingLoaders.contains(loader))
         m_nonBlockingLoaders.remove(loader);
     else
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
 }
 
 void ResourceFetcher::stopFetching()
 {
     HeapVector<Member<ResourceLoader>> loadersToCancel;
     for (const auto& loader : m_nonBlockingLoaders)
         loadersToCancel.append(loader);
     for (const auto& loader : m_loaders)
         loadersToCancel.append(loader);
 
@@ skipping 144 matching lines @@
             break;
         case Resource::ImportResource:
             imports++;
             importMisses += missCount;
             break;
         case Resource::Raw:
             raws++;
             rawMisses += missCount;
             break;
         default:
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
         }
     }
     // TODO(csharrison): These can falsely attribute link rel="preload" requests
     // as misses if they are referenced after parsing completes. Migrate this
     // logic to the memory cache / individual resources to prevent this.
     DEFINE_STATIC_LOCAL(CustomCountHistogram, imagePreloads, ("PreloadScanner.Counts2.Image", 0, 100, 25));
     DEFINE_STATIC_LOCAL(CustomCountHistogram, imagePreloadMisses, ("PreloadScanner.Counts2.Miss.Image", 0, 100, 25));
     DEFINE_STATIC_LOCAL(CustomCountHistogram, scriptPreloads, ("PreloadScanner.Counts2.Script", 0, 100, 25));
     DEFINE_STATIC_LOCAL(CustomCountHistogram, scriptPreloadMisses, ("PreloadScanner.Counts2.Miss.Script", 0, 100, 25));
     DEFINE_STATIC_LOCAL(CustomCountHistogram, stylesheetPreloads, ("PreloadScanner.Counts2.CSSStyleSheet", 0, 100, 25));
@@ skipping 93 matching lines @@
     visitor->trace(m_context);
     visitor->trace(m_archive);
     visitor->trace(m_loaders);
     visitor->trace(m_nonBlockingLoaders);
     visitor->trace(m_documentResources);
     visitor->trace(m_preloads);
     visitor->trace(m_resourceTimingInfoMap);
 }
 
 } // namespace blink