Remove preload support from the MemoryCache

sky/engine/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 40 matching lines @@
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/SharedBuffer.h"
 #include "platform/TraceEvent.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebURLRequest.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/WTFString.h"
 
-#define PRELOAD_DEBUG 0
-
 using blink::WebURLRequest;
 
 namespace blink {
 
 static Resource* createResource(Resource::Type type, const ResourceRequest& request, const String& charset)
 {
     switch (type) {
     case Resource::Image:
         return new ImageResource(request);
     case Resource::Font:
@@ skipping 73 matching lines @@
     , m_autoLoadImages(true)
     , m_imagesEnabled(true)
     , m_allowStaleResources(false)
 {
 }
 
 ResourceFetcher::~ResourceFetcher()
 {
     m_document = nullptr;
 
-    clearPreloads();
-
     // Make sure no requests still point to this ResourceFetcher
     ASSERT(!m_requestCount);
 }
 
 Resource* ResourceFetcher::cachedResource(const KURL& resourceURL) const
 {
     KURL url = MemoryCache::removeFragmentIdentifierIfNeeded(resourceURL);
     return m_documentResources.get(url).get();
 }
 
@@ skipping 23 matching lines @@
     return resource && resource->type() == Resource::Image ? toImageResource(resource) : 0;
 }
 
 ResourcePtr<FontResource> ResourceFetcher::fetchFont(FetchRequest& request)
 {
     ASSERT(request.resourceRequest().frameType() == WebURLRequest::FrameTypeNone);
     request.mutableResourceRequest().setRequestContext(WebURLRequest::RequestContextFont);
     return toFontResource(requestResource(Resource::Font, request));
 }
 
-bool ResourceFetcher::canRequest(Resource::Type type, const KURL& url, const ResourceLoaderOptions& options, bool forPreload, FetchRequest::OriginRestriction originRestriction) const
+bool ResourceFetcher::canRequest(Resource::Type type, const KURL& url, const ResourceLoaderOptions& options, FetchRequest::OriginRestriction originRestriction) const
 {
     // FIXME(sky): Remove
     return true;
 }
 
 bool ResourceFetcher::shouldLoadNewResource(Resource::Type type) const
 {
     if (!frame())
         return false;
     return true;
@@ skipping 20 matching lines @@
 }
 
 ResourcePtr<Resource> ResourceFetcher::requestResource(Resource::Type type, FetchRequest& request)
 {
     ASSERT(request.options().synchronousPolicy == RequestAsynchronously || type == Resource::Raw);
 
     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));
+    WTF_LOG(ResourceLoading, "ResourceFetcher::requestResource '%s', charset '%s', priority=%d, type=%s", url.elidedString().latin1().data(), request.charset().latin1().data(), request.priority(), ResourceTypeName(type));
 
     // If only the fragment identifiers differ, it is the same resource.
     url = MemoryCache::removeFragmentIdentifierIfNeeded(url);
 
     if (!url.isValid())
         return 0;
 
-    if (!canRequest(type, url, request.options(), request.forPreload(), request.originRestriction()))
+    if (!canRequest(type, url, request.options(), request.originRestriction()))
         return 0;
 
     if (LocalFrame* f = frame())
         f->loaderClient()->dispatchWillRequestResource(&request);
 
     // See if we can use an existing resource from the cache.
     ResourcePtr<Resource> resource = memoryCache()->resourceForURL(url);
 
     const RevalidationPolicy policy = determineRevalidationPolicy(type, request, resource.get());
     switch (policy) {
@@ skipping 13 matching lines @@
 
     if (!resource)
         return 0;
 
     if (!resource->hasClients())
         m_deadStatsRecorder.update(policy);
 
     if (policy != Use)
         resource->setIdentifier(createUniqueIdentifier());
 
-    if (!request.forPreload() || policy != Use) {
-        ResourceLoadPriority priority = loadPriority(type, request);
-        if (priority != resource->resourceRequest().priority()) {
-            resource->mutableResourceRequest().setPriority(priority);
-            resource->didChangePriority(priority, 0);
-        }
+    ResourceLoadPriority priority = loadPriority(type, request);
+    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;
         }
 
         resource->load(this, request.options());
@@ skipping 94 matching lines @@
     return resource;
 }
 
 ResourceFetcher::RevalidationPolicy ResourceFetcher::determineRevalidationPolicy(Resource::Type type, const FetchRequest& fetchRequest, Resource* existingResource) const
 {
     const ResourceRequest& request = fetchRequest.resourceRequest();
 
     if (!existingResource)
         return Load;
 
-    // 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->type() != 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.");
         return Reload;
     }
 
     // Do not load from cache if images are not enabled. The load for this image will be blocked
     // in ImageResource::load.
     if (FetchRequest::DeferredByClient == fetchRequest.defer())
         return Reload;
 
     // Always use data uris.
@@ skipping 14 matching lines @@
     if (request.isConditional())
         return Reload;
 
     // Don't reload resources while pasting.
     if (m_allowStaleResources)
         return Use;
 
     if (!fetchRequest.options().canReuseRequest(existingResource->options()))
         return Reload;
 
-    // Always use preloads.
-    if (existingResource->isPreloaded())
-        return Use;
-
     // CachePolicyHistoryBuffer uses the cache no matter what.
     CachePolicy cachePolicy = context().cachePolicy(document());
     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.");
         return Reload;
     }
@@ skipping 179 matching lines @@
 
 void ResourceFetcher::decrementRequestCount(const Resource* res)
 {
     if (res->ignoreForRequestCount())
         return;
 
     --m_requestCount;
     ASSERT(m_requestCount > -1);
 }
 
-void ResourceFetcher::preload(Resource::Type type, FetchRequest& request, const String& charset)
-{
-    requestPreload(type, request, charset);
-}
-
-void ResourceFetcher::requestPreload(Resource::Type type, FetchRequest& request, const String& charset)
-{
-    // Ensure main resources aren't preloaded, since the cache can't actually reuse the preload.
-    if (type == Resource::MainResource)
-        return;
-
-    String encoding;
-    request.setCharset(encoding);
-    request.setForPreload(true);
-
-    ResourcePtr<Resource> resource;
-    // Loading images involves several special cases, so use dedicated fetch method instead.
-    if (type == Resource::Image)
-        resource = fetchImage(request);
-    if (!resource)
-        resource = requestResource(type, request);
-    if (!resource || (m_preloads && m_preloads->contains(resource.get())))
-        return;
-    TRACE_EVENT_ASYNC_STEP_INTO0("net", "Resource", resource.get(), "Preload");
-    resource->increasePreloadCount();
-
-    if (!m_preloads)
-        m_preloads = adoptPtr(new ListHashSet<Resource*>);
-    m_preloads->add(resource.get());
-
-#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) {
-        ListHashSet<Resource*>::iterator end = m_preloads->end();
-        for (ListHashSet<Resource*>::iterator it = m_preloads->begin(); it != end; ++it) {
-            Resource* resource = *it;
-            if (resource->url() == url)
-                return true;
-        }
-    }
-
-    return false;
-}
-
-void ResourceFetcher::clearPreloads()
-{
-#if PRELOAD_DEBUG
-    printPreloadStats();
-#endif
-    if (!m_preloads)
-        return;
-
-    ListHashSet<Resource*>::iterator end = m_preloads->end();
-    for (ListHashSet<Resource*>::iterator it = m_preloads->begin(); it != end; ++it) {
-        Resource* res = *it;
-        res->decreasePreloadCount();
-        bool deleted = res->deleteIfPossible();
-        if (!deleted && res->preloadResult() == Resource::PreloadNotReferenced)
-            memoryCache()->remove(res);
-    }
-    m_preloads.clear();
-}
-
 void ResourceFetcher::didFinishLoading(const Resource* resource, double finishTime, int64_t encodedDataLength)
 {
     TRACE_EVENT_ASYNC_END0("net", "Resource", resource);
     context().dispatchDidFinishLoading(m_document, resource->identifier(), finishTime, encodedDataLength);
 }
 
 void ResourceFetcher::didChangeLoadingPriority(const Resource* resource, ResourceLoadPriority loadPriority, int intraPriorityValue)
 {
     TRACE_EVENT_ASYNC_STEP_INTO1("net", "Resource", resource, "ChangePriority", "priority", loadPriority);
     context().dispatchDidChangeResourcePriority(resource->identifier(), loadPriority, intraPriorityValue);
@@ skipping 79 matching lines @@
 {
     ref();
 }
 
 void ResourceFetcher::derefResourceLoaderHost()
 {
     deref();
 }
 #endif
 
-#if PRELOAD_DEBUG
-void ResourceFetcher::printPreloadStats()
-{
-    if (!m_preloads)
-        return;
-
-    unsigned scripts = 0;
-    unsigned scriptMisses = 0;
-    unsigned stylesheets = 0;
-    unsigned stylesheetMisses = 0;
-    unsigned images = 0;
-    unsigned imageMisses = 0;
-    ListHashSet<Resource*>::iterator end = m_preloads->end();
-    for (ListHashSet<Resource*>::iterator it = m_preloads->begin(); it != end; ++it) {
-        Resource* res = *it;
-        if (res->preloadResult() == Resource::PreloadNotReferenced)
-            printf("!! UNREFERENCED PRELOAD %s\n", res->url().string().latin1().data());
-        else if (res->preloadResult() == Resource::PreloadReferencedWhileComplete)
-            printf("HIT COMPLETE PRELOAD %s\n", res->url().string().latin1().data());
-        else if (res->preloadResult() == Resource::PreloadReferencedWhileLoading)
-            printf("HIT LOADING PRELOAD %s\n", res->url().string().latin1().data());
-
-        images++;
-        if (res->preloadResult() < Resource::PreloadReferencedWhileLoading)
-            imageMisses++;
-
-        if (res->errorOccurred())
-            memoryCache()->remove(res);
-
-        res->decreasePreloadCount();
-    }
-    m_preloads.clear();
-
-    if (scripts)
-        printf("SCRIPTS: %d (%d hits, hit rate %d%%)\n", scripts, scripts - scriptMisses, (scripts - scriptMisses) * 100 / scripts);
-    if (stylesheets)
-        printf("STYLESHEETS: %d (%d hits, hit rate %d%%)\n", stylesheets, stylesheets - stylesheetMisses, (stylesheets - stylesheetMisses) * 100 / stylesheets);
-    if (images)
-        printf("IMAGES:  %d (%d hits, hit rate %d%%)\n", images, images - imageMisses, (images - imageMisses) * 100 / images);
-}
-#endif
-
 const ResourceLoaderOptions& ResourceFetcher::defaultResourceOptions()
 {
     DEFINE_STATIC_LOCAL(ResourceLoaderOptions, options, (BufferData, AllowStoredCredentials, ClientRequestedCredentials, DocumentContext));
     return options;
 }
 
 ResourceFetcher::DeadResourceStatsRecorder::DeadResourceStatsRecorder()
     : m_useCount(0)
     , m_revalidateCount(0)
     , m_loadCount(0)
@@ skipping 20 matching lines @@
     case Revalidate:
         ++m_revalidateCount;
         return;
     case Use:
         ++m_useCount;
         return;
     }
 }
 
 }