Replace WTF_LOG() with NETWORK_DVLOG() or RESOURCE_LOADING_DVLOG().

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 16 matching lines @@
 #include "core/fetch/ResourceFetcher.h"
 
 #include "bindings/core/v8/V8DOMActivityLogger.h"
 #include "core/fetch/CrossOriginAccessControl.h"
 #include "core/fetch/FetchContext.h"
 #include "core/fetch/FetchInitiatorTypeNames.h"
 #include "core/fetch/ImageResource.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/fetch/ResourceLoader.h"
 #include "core/fetch/ResourceLoaderSet.h"
+#include "core/fetch/ResourceLoadingLog.h"
 #include "core/fetch/UniqueIdentifier.h"
 #include "platform/Histogram.h"
-#include "platform/Logging.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
 #include "platform/TracedValue.h"
 #include "platform/mhtml/ArchiveResource.h"
 #include "platform/mhtml/MHTMLArchive.h"
 #include "platform/network/ResourceTimingInfo.h"
 #include "platform/weborigin/KnownPorts.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "public/platform/Platform.h"
@@ skipping 534 matching lines @@
     }
 
     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));
 
-    WTF_LOG(ResourceLoading, "Loading Resource for '%s'.", request.resourceRequest().url().elidedString().latin1().data());
+    RESOURCE_LOADING_DVLOG(1) << "Loading Resource for " << request.resourceRequest().url().elidedString();

[tyoshino (SeeGerritForStatus), 2016/08/12 07:32:19]

oh, does this change make this line run .elidedString() even for release build?

if so, it's ok to commit this first but later ideally we should add some
if-clause to skip this?

[tkent, 2016/08/12 07:43:45]

Both of clang and MSVC are clever enough.  They don't produce any code for this
line in Release build.

 
     Resource* resource = factory.create(request.resourceRequest(), request.options(), charset);
     resource->setLinkPreload(request.isLinkPreload());
     if (request.forPreload()) {
         resource->setPreloadDiscoveryTime(request.preloadDiscoveryTime());
     }
     resource->setCacheIdentifier(cacheIdentifier);
 
     // Don't add main resource to cache to prevent reuse.
     if (factory.type() != Resource::MainResource)
@@ skipping 57 matching lines @@
     // We already have a preload going for this URL.
     if (fetchRequest.forPreload() && existingResource->isPreloaded())
         return Use;
 
     // If the same URL has been loaded as a different type, we need to reload.
     if (existingResource->getType() != type) {
         // FIXME: If existingResource is a Preload and the new type is LinkPrefetch
         // We really should discard the new prefetch since the preload has more
         // specific type information! crbug.com/379893
         // fast/dom/HTMLLinkElement/link-and-subresource-test hits this case.
-        WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicy reloading due to type mismatch.");
+        RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::determineRevalidationPolicy reloading due to type mismatch.";
         return Reload;
     }
 
     // Do not load from cache if images are not enabled.
     // There are two general cases:
     // 1. Images are disabled. Don't ever load images, even if the image is
     //    cached or it is a data: url. In this case, we "Reload" the image,
     //    then defer it with resourceNeedsLoad() so that it never actually
     //    goes to the network.
     // 2. Images are enabled, but not loaded automatically. In this case, we
@@ skipping 44 matching lines @@
     if (existingResource->isPreloaded())
         return Use;
 
     // CachePolicyHistoryBuffer uses the cache no matter what.
     CachePolicy cachePolicy = context().getCachePolicy();
     if (cachePolicy == CachePolicyHistoryBuffer)
         return Use;
 
     // Don't reuse resources with Cache-control: no-store.
     if (existingResource->hasCacheControlNoStoreHeader()) {
-        WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicy reloading due to Cache-control: no-store.");
+        RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::determineRevalidationPolicy reloading due to Cache-control: no-store.";
         return Reload;
     }
 
     // If credentials were sent with the previous request and won't be
     // with this one, or vice versa, re-fetch the resource.
     //
     // This helps with the case where the server sends back
     // "Access-Control-Allow-Origin: *" all the time, but some of the
     // client's requests are made without CORS and some with.
     if (existingResource->resourceRequest().allowStoredCredentials() != request.allowStoredCredentials()) {
-        WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicy reloading due to difference in credentials settings.");
+        RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::determineRevalidationPolicy reloading due to difference in credentials settings.";
         return Reload;
     }
 
     // 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::Raw) {
         if (!context().isLoadComplete() && m_validatedURLs.contains(existingResource->url()))
             return Use;
         if (existingResource->isLoading())
             return Use;
     }
 
     if (request.getCachePolicy() == WebCachePolicy::BypassingCache)
         return Reload;
 
     // CachePolicyReload always reloads
     if (cachePolicy == CachePolicyReload) {
-        WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicy reloading due to CachePolicyReload.");
+        RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::determineRevalidationPolicy reloading due to CachePolicyReload.";
         return Reload;
     }
 
     // We'll try to reload the resource if it failed last time.
     if (existingResource->errorOccurred()) {
-        WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicye reloading due to resource being in the error state");
+        RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::determineRevalidationPolicye reloading due to resource being in the error state";
         return Reload;
     }
 
     // List of available images logic allows images to be re-used without cache validation. We restrict this only to images
     // from memory cache which are the same as the version in the current document.
     if (type == Resource::Image && existingResource == cachedResource(request.url()))
         return Use;
 
     // Defer to the browser process cache for Vary header handling.
     if (existingResource->hasVaryHeader())
         return Reload;
 
     // If any of the redirects in the chain to loading the resource were not cacheable, we cannot reuse our cached resource.
     if (!existingResource->canReuseRedirectChain()) {
-        WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicy reloading due to an uncacheable redirect");
+        RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::determineRevalidationPolicy reloading due to an uncacheable redirect";
         return Reload;
     }
 
     // Check if the cache headers requires us to revalidate (cache expiration for example).
     if (cachePolicy == CachePolicyRevalidate || existingResource->mustRevalidateDueToCacheHeaders()
         || request.cacheControlContainsNoCache()) {
         // See if the resource has usable ETag or Last-modified headers.
         // If the page is controlled by the ServiceWorker, we choose the Reload policy because the revalidation headers should not be exposed to the ServiceWorker.(crbug.com/429570)
         if (existingResource->canUseCacheValidator() && !context().isControlledByServiceWorker()) {
             // If the resource is already a cache validator but not started yet,
             // the |Use| policy should be applied to subsequent requests.
             if (existingResource->isCacheValidator()) {
                 DCHECK(existingResource->stillNeedsLoad());
                 return Use;
             }
             return Revalidate;
         }
 
         // No, must reload.
-        WTF_LOG(ResourceLoading, "ResourceFetcher::determineRevalidationPolicy reloading due to missing cache validators.");
+        RESOURCE_LOADING_DVLOG(1) << "ResourceFetcher::determineRevalidationPolicy reloading due to missing cache validators.";
         return Reload;
     }
 
     return Use;
 }
 
 void ResourceFetcher::setAutoLoadImages(bool enable)
 {
     if (enable == m_autoLoadImages)
         return;
@@ skipping 493 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