Prepopulate the memoryCache with data:uri images.

Source/core/loader/cache/CachedResourceLoader.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 32 matching lines @@
 #include "core/loader/PingLoader.h"
 #include "core/loader/UniqueIdentifier.h"
 #include "core/loader/cache/CachedCSSStyleSheet.h"
 #include "core/loader/cache/CachedDocument.h"
 #include "core/loader/cache/CachedFont.h"
 #include "core/loader/cache/CachedImage.h"
 #include "core/loader/cache/CachedRawResource.h"
 #include "core/loader/cache/CachedResourceRequest.h"
 #include "core/loader/cache/CachedScript.h"
 #include "core/loader/cache/CachedShader.h"
+#include "core/loader/cache/CachedTextTrack.h"
 #include "core/loader/cache/CachedXSLStyleSheet.h"
 #include "core/loader/cache/MemoryCache.h"
 #include "core/page/Console.h"
 #include "core/page/ContentSecurityPolicy.h"
 #include "core/page/DOMWindow.h"
 #include "core/page/Frame.h"
 #include "core/page/Performance.h"
 #include "core/page/Settings.h"
 #include "core/platform/Logging.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebURL.h"
 #include "weborigin/SecurityOrigin.h"
 #include "weborigin/SecurityPolicy.h"
 
-#include "core/loader/cache/CachedTextTrack.h"
-
 #define PRELOAD_DEBUG 0
 
 namespace WebCore {
 
-static CachedResource* createResource(CachedResource::Type type, ResourceRequest& request, const String& charset)
+static CachedResource* createResource(CachedResource::Type type, const ResourceRequest& request, const String& charset)
 {
     switch (type) {
     case CachedResource::ImageResource:
         return new CachedImage(request);
     case CachedResource::CSSStyleSheet:
         return new CachedCSSStyleSheet(request, charset);
     case CachedResource::Script:
         return new CachedScript(request, charset);
     case CachedResource::SVGDocumentResource:
         return new CachedDocument(request, CachedResource::SVGDocumentResource);
@@ skipping 43 matching lines @@
         return ResourceLoadPriorityLow;
     case CachedResource::TextTrackResource:
         return ResourceLoadPriorityLow;
     case CachedResource::ShaderResource:
         return ResourceLoadPriorityMedium;
     }
     ASSERT_NOT_REACHED();
     return ResourceLoadPriorityUnresolved;
 }
 
+static CachedResource* resourceFromDataURIRequest(const ResourceRequest& request)
+{
+    const KURL& url = request.url();
+    ASSERT(url.protocolIsData());
+
+    WebKit::WebString mimetype;
+    WebKit::WebString charset;
+    RefPtr<SharedBuffer> data = PassRefPtr<SharedBuffer>(WebKit::Platform::current()->parseDataURL(url, mimetype, charset));
+    if (!data)
+        return 0;
+    ResourceResponse response(url, mimetype, data->size(), charset, String());
+
+    CachedResource* resource = createResource(CachedResource::ImageResource, request, charset);
+    resource->responseReceived(response);
+    // FIXME: AppendData causes an unnecessary memcpy.
+    if (data->size())
+        resource->appendData(data->data(), data->size());
+    resource->finish();
+    return resource;
+}
+
 CachedResourceLoader::CachedResourceLoader(DocumentLoader* documentLoader)
     : m_document(0)
     , m_documentLoader(documentLoader)
     , m_requestCount(0)
     , m_garbageCollectDocumentResourcesTimer(this, &CachedResourceLoader::garbageCollectDocumentResourcesTimerFired)
     , m_autoLoadImages(true)
     , m_imagesEnabled(true)
     , m_allowStaleResources(false)
 {
 }
@@ skipping 29 matching lines @@
 CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(CachedResourceRequest& request)
 {
     if (Frame* f = frame()) {
         if (f->loader()->pageDismissalEventBeingDispatched() != FrameLoader::NoDismissal) {
             KURL requestURL = request.resourceRequest().url();
             if (requestURL.isValid() && canRequest(CachedResource::ImageResource, requestURL, CheckContentSecurityPolicy))
                 PingLoader::loadImage(f, requestURL);
             return 0;
         }
     }
+
+    if (request.resourceRequest().url().protocolIsData())
+        preCacheDataURIImage(request);
+
     request.setDefer(clientDefersImage(request.resourceRequest().url()) ? CachedResourceRequest::DeferredByClient : CachedResourceRequest::NoDefer);
     return static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request).get());
 }
 
+void CachedResourceLoader::preCacheDataURIImage(CachedResourceRequest& request)

[abarth-chromium, 2013/06/07 22:16:07]

While we're in the "const" business, we might want to add one to "const
CachedResourceRequest&"  :)

+{
+    const KURL& url = request.resourceRequest().url();
+    ASSERT(url.protocolIsData());
+
+    if (CachedResource* existing = memoryCache()->resourceForURL(url)) {
+        ASSERT(existing->type() == CachedResource::ImageResource);
+        if (existing->type() == CachedResource::ImageResource)
+            return;

[abarth-chromium, 2013/06/07 22:16:07]

Wait, why don't you need to remove the existing resource?

There's no reason why the existing resource needs to be of type
CachedResource::ImageResource.  He code you had before was correct.

As a more general note, we try to avoid ASSERTing a condition and then handling
the negation.  Either the condition can fail, in which case the ASSERT is wrong,
or the condition cannot fail, in which case there's no point in handling the
negation.

+    }
+
+    if (CachedResource* resource = resourceFromDataURIRequest(request.resourceRequest()))
+        memoryCache()->add(resource);
+}
+
 CachedResourceHandle<CachedFont> CachedResourceLoader::requestFont(CachedResourceRequest& request)
 {
     return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, request).get());
 }
 
 CachedResourceHandle<CachedTextTrack> CachedResourceLoader::requestTextTrack(CachedResourceRequest& request)
 {
     return static_cast<CachedTextTrack*>(requestResource(CachedResource::TextTrackResource, request).get());
 }
 
@@ skipping 864 matching lines @@
     info.addMember(m_garbageCollectDocumentResourcesTimer, "garbageCollectDocumentResourcesTimer");
 }
 
 const ResourceLoaderOptions& CachedResourceLoader::defaultCachedResourceOptions()
 {
     DEFINE_STATIC_LOCAL(ResourceLoaderOptions, options, (SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, ClientRequestedCredentials, AskClientForCrossOriginCredentials, DoSecurityCheck, CheckContentSecurityPolicy));
     return options;
 }
 
 }