Move /fetch to use C++11

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 147 matching lines @@
 
 static Resource* resourceFromDataURIRequest(const ResourceRequest& request, const ResourceLoaderOptions& resourceOptions)
 {
     const KURL& url = request.url();
     ASSERT(url.protocolIsData());
 
     blink::WebString mimetype;
     blink::WebString charset;
     RefPtr<SharedBuffer> data = PassRefPtr<SharedBuffer>(blink::Platform::current()->parseDataURL(url, mimetype, charset));
     if (!data)
-        return 0;
+        return nullptr;
     ResourceResponse response(url, mimetype, data->size(), charset, String());
 
     Resource* resource = createResource(Resource::Image, request, charset);
     resource->setOptions(resourceOptions);
     resource->responseReceived(response);
     if (data->size())
         resource->setResourceBuffer(data);
     resource->finish();
     return resource;
 }
@@ skipping 77 matching lines @@
     , m_garbageCollectDocumentResourcesTimer(this, &ResourceFetcher::garbageCollectDocumentResourcesTimerFired)
     , m_resourceTimingReportTimer(this, &ResourceFetcher::resourceTimingReportTimerFired)
     , m_autoLoadImages(true)
     , m_imagesEnabled(true)
     , m_allowStaleResources(false)
 {
 }
 
 ResourceFetcher::~ResourceFetcher()
 {
-    m_documentLoader = 0;
+    m_documentLoader = nullptr;
     m_document = nullptr;
 
     clearPreloads();
 
     // Make sure no requests still point to this ResourceFetcher
     ASSERT(!m_requestCount);
 }
 
 Resource* ResourceFetcher::cachedResource(const KURL& resourceURL) const
 {
@@ skipping 404 matching lines @@
     TRACE_EVENT0("blink", "ResourceFetcher::requestResource");
 
     KURL url = request.resourceRequest().url();
 
     WTF_LOG(ResourceLoading, "ResourceFetcher::requestResource '%s', charset '%s', priority=%d, forPreload=%u, type=%s", url.elidedString().latin1().data(), request.charset().latin1().data(), request.priority(), request.forPreload(), ResourceTypeName(type));
 
     // If only the fragment identifiers differ, it is the same resource.
     url = MemoryCache::removeFragmentIdentifierIfNeeded(url);
 
     if (!url.isValid())
-        return 0;
+        return nullptr;
 
     if (!canRequest(type, request.resourceRequest(), url, request.options(), request.forPreload(), request.originRestriction()))
-        return 0;
+        return nullptr;
 
     if (LocalFrame* f = frame())
         f->loader().client()->dispatchWillRequestResource(&request);
 
     if (!request.forPreload()) {
-        V8DOMActivityLogger* activityLogger = 0;
+        V8DOMActivityLogger* activityLogger = nullptr;
         if (request.options().initiatorInfo.name == FetchInitiatorTypeNames::xmlhttprequest)
             activityLogger = V8DOMActivityLogger::currentActivityLogger();
         else
             activityLogger = V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
 
         if (activityLogger) {
             Vector<String> argv;
             argv.append(Resource::resourceTypeToString(type, request.options().initiatorInfo));
             argv.append(url);
             activityLogger->logEvent("blinkRequestResource", argv.size(), argv.data());
@@ skipping 13 matching lines @@
         break;
     case Revalidate:
         resource = createResourceForRevalidation(request, resource.get());
         break;
     case Use:
         memoryCache()->updateForAccess(resource.get());
         break;
     }
 
     if (!resource)
-        return 0;
+        return nullptr;
 
     if (!resource->hasClients())
         m_deadStatsRecorder.update(policy);
 
     if (policy != Use)
         resource->setIdentifier(createUniqueIdentifier());
 
     if (!request.forPreload() || policy != Use) {
         ResourceLoadPriority priority = loadPriority(type, request);
         // When issuing another request for a resource that is already in-flight make
         // sure to not demote the priority of the in-flight request. If the new request
         // isn't at the same priority as the in-flight request, only allow promotions.
         // This can happen when a visible image's priority is increased and then another
         // reference to the image is parsed (which would be at a lower priority).
         if (priority > resource->resourceRequest().priority()) {
             resource->mutableResourceRequest().setPriority(priority);
             resource->didChangePriority(priority, 0);
         }
     }
 
     if (resourceNeedsLoad(resource.get(), request, policy)) {
         if (!shouldLoadNewResource(type)) {
             if (memoryCache()->contains(resource.get()))
                 memoryCache()->remove(resource.get());
-            return 0;
+            return nullptr;
         }
 
         if (!m_documentLoader || !m_documentLoader->scheduleArchiveLoad(resource.get(), request.resourceRequest()))
             resource->load(this, request.options());
 
         // For asynchronous loads that immediately fail, it's sufficient to return a
         // null Resource, as it indicates that something prevented the load from starting.
         // If there's a network error, that failure will happen asynchronously. However, if
         // a sync load receives a network error, it will have already happened by this point.
         // In that case, the requester should have access to the relevant ResourceError, so
         // we need to return a non-null Resource.
         if (resource->errorOccurred()) {
             if (memoryCache()->contains(resource.get()))
                 memoryCache()->remove(resource.get());
-            return request.options().synchronousPolicy == RequestSynchronously ? resource : 0;
+            return request.options().synchronousPolicy == RequestSynchronously ? resource : nullptr;
         }
     }
 
     // FIXME: Temporarily leave main resource caching disabled for chromium,
     // see https://bugs.webkit.org/show_bug.cgi?id=107962. Before caching main
     // resources, we should be sure to understand the implications for memory
     // use.
     // Remove main resource from cache to prevent reuse.
     if (type == Resource::MainResource) {
         ASSERT(policy != Use || m_documentLoader->substituteData().isValid());
@@ skipping 480 matching lines @@
 #if PRELOAD_DEBUG
     printf("PRELOADING %s\n",  resource->url().string().latin1().data());
 #endif
 }
 
 bool ResourceFetcher::isPreloaded(const String& urlString) const
 {
     const KURL& url = m_document->completeURL(urlString);
 
     if (m_preloads) {
-        for (const auto& resource : *m_preloads) {
+        for (Resource* resource : *m_preloads) {
             if (resource->url() == url)
                 return true;
         }
     }
 
     return false;
 }
 
 void ResourceFetcher::clearPreloads()
 {
 #if PRELOAD_DEBUG
     printPreloadStats();
 #endif
     if (!m_preloads)
         return;
 
-    for (const auto& resource : *m_preloads) {
+    for (Resource* resource : *m_preloads) {
         resource->decreasePreloadCount();
         bool deleted = resource->deleteIfPossible();
         if (!deleted && resource->preloadResult() == Resource::PreloadNotReferenced)
             memoryCache()->remove(resource);
     }
     m_preloads.clear();
 }
 
 void ResourceFetcher::didFinishLoading(const Resource* resource, double finishTime, int64_t encodedDataLength)
 {
@@ skipping 153 matching lines @@
 {
     if (!m_preloads)
         return;
 
     unsigned scripts = 0;
     unsigned scriptMisses = 0;
     unsigned stylesheets = 0;
     unsigned stylesheetMisses = 0;
     unsigned images = 0;
     unsigned imageMisses = 0;
-    for (const auto& resource : *m_preloads) {
+    for (Resource* resource : *m_preloads) {
         if (resource->preloadResult() == Resource::PreloadNotReferenced)
             printf("!! UNREFERENCED PRELOAD %s\n", resource->url().string().latin1().data());
         else if (resource->preloadResult() == Resource::PreloadReferencedWhileComplete)
             printf("HIT COMPLETE PRELOAD %s\n", resource->url().string().latin1().data());
         else if (resource->preloadResult() == Resource::PreloadReferencedWhileLoading)
             printf("HIT LOADING PRELOAD %s\n", resource->url().string().latin1().data());
 
         if (resource->type() == Resource::Script) {
             scripts++;
             if (resource->preloadResult() < Resource::PreloadReferencedWhileLoading)
@@ skipping 65 matching lines @@
 
 void ResourceFetcher::trace(Visitor* visitor)
 {
     visitor->trace(m_document);
     visitor->trace(m_loaders);
     visitor->trace(m_multipartLoaders);
     ResourceLoaderHost::trace(visitor);
 }
 
 }