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)
 {
     switch (type) {
     case CachedResource::ImageResource:
         return new CachedImage(request);
     case CachedResource::CSSStyleSheet:
@@ skipping 15 matching lines @@
         return new CachedResource(request, CachedResource::LinkSubresource);
     case CachedResource::TextTrackResource:
         return new CachedTextTrack(request);
     case CachedResource::ShaderResource:
         return new CachedShader(request);
     }
     ASSERT_NOT_REACHED();
     return 0;
 }
 
+static CachedResource* resourceFromDataURIRequest(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);

[abarth-chromium, 2013/06/07 20:36:11]

We'll eventually want to expand this beyond just images, but this is a good
start.

+    resource->responseReceived(response);
+    // FIXME: AppendData caises an unnecessary memcpy.

[abarth-chromium, 2013/06/07 20:36:11]

caises -> causes

[pdr., 2013/06/07 22:00:23]

Done.

+    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)
+{
+    const KURL& url = request.resourceRequest().url();
+    ASSERT(url.protocolIsData());
+
+    if (CachedResource* existing = memoryCache()->resourceForURL(url)) {
+        if (existing->type() == CachedResource::ImageResource)
+            return;
+        memoryCache()->remove(existing); // Cache entry is incorrect.

[abarth-chromium, 2013/06/07 20:36:11]

Is there a test for this case?

[pdr., 2013/06/07 22:00:23]

I don't think a test can hit this codepath. I tried a few ways such as loading
an SVG image as a font or in an iframe and we end up not caching it, or properly
caching it.

I've replaced the "memoryCache()->remove(existing);" line with an ASSERT.

+    }
+
+    if (CachedResource* resource = resourceFromDataURIRequest(request.mutableResourceRequest()))

[abarth-chromium, 2013/06/07 20:36:11]

Why does this need to be mutable?  It doesn't seem like you're going to alter
the resource request.

[pdr., 2013/06/07 22:00:23]

Nope! Required some minor fixups to make this true though (CachedRawResource,
etc.)

+        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 862 matching lines @@
     info.addMember(m_garbageCollectDocumentResourcesTimer, "garbageCollectDocumentResourcesTimer");
 }
 
 const ResourceLoaderOptions& CachedResourceLoader::defaultCachedResourceOptions()
 {
     static ResourceLoaderOptions options(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, ClientRequestedCredentials, AskClientForCrossOriginCredentials, DoSecurityCheck, CheckContentSecurityPolicy);
     return options;
 }
 
 }