Merge WebKit at r75993: Initial merge by git.

Change-Id: I602bbdc3974787a3b0450456a30a7868286921c3

8 files changed, 61 insertions, 75 deletions

diff --git a/Source/WebCore/loader/cache/CachedFont.cpp b/Source/WebCore/loader/cache/CachedFont.cpp
index d6967bf..fe3281e 100644
--- a/Source/WebCore/loader/cache/CachedFont.cpp
+++ b/Source/WebCore/loader/cache/CachedFont.cpp
@@ -137,18 +137,13 @@ bool CachedFont::ensureSVGFontData()
     ASSERT(m_isSVGFont);
     if (!m_externalSVGDocument && !errorOccurred() && !isLoading() && m_data) {
         m_externalSVGDocument = SVGDocument::create(0, KURL());
-        m_externalSVGDocument->open();
 
         RefPtr<TextResourceDecoder> decoder = TextResourceDecoder::create("application/xml");
-        m_externalSVGDocument->write(decoder->decode(m_data->data(), m_data->size()));
-        m_externalSVGDocument->write(decoder->flush());
-        if (decoder->sawError()) {
-            m_externalSVGDocument.clear();
-            return 0;
-        }
-
-        m_externalSVGDocument->finishParsing();
-        m_externalSVGDocument->close();
+
+        m_externalSVGDocument->setContent(decoder->decode(m_data->data(), m_data->size()) + decoder->flush());
+        
+        if (decoder->sawError())
+            m_externalSVGDocument = 0;
     }
 
     return m_externalSVGDocument;
diff --git a/Source/WebCore/loader/cache/CachedImage.cpp b/Source/WebCore/loader/cache/CachedImage.cpp
index c550eec..7d9ce3d 100644
--- a/Source/WebCore/loader/cache/CachedImage.cpp
+++ b/Source/WebCore/loader/cache/CachedImage.cpp
@@ -111,7 +111,7 @@ void CachedImage::allClientsRemoved()
 {
     if (m_image && !errorOccurred())
         m_image->resetAnimation();
-    if (double interval = cache()->deadDecodedDataDeletionInterval())
+    if (double interval = memoryCache()->deadDecodedDataDeletionInterval())
         m_decodedDataDeletionTimer.startOneShot(interval);
 }
 
@@ -284,7 +284,7 @@ void CachedImage::data(PassRefPtr<SharedBuffer> data, bool allDataReceived)
         if (m_image->isNull() || (maxDecodedImageSize > 0 && estimatedDecodedImageSize > maxDecodedImageSize)) {
             error(errorOccurred() ? status() : DecodeError);
             if (inCache())
-                cache()->remove(this);
+                memoryCache()->remove(this);
             return;
         }
         
diff --git a/Source/WebCore/loader/cache/CachedResource.cpp b/Source/WebCore/loader/cache/CachedResource.cpp
index a9d9b0a..06b3131 100644
--- a/Source/WebCore/loader/cache/CachedResource.cpp
+++ b/Source/WebCore/loader/cache/CachedResource.cpp
@@ -116,7 +116,7 @@ CachedResource::~CachedResource()
     ASSERT(canDelete());
     ASSERT(!inCache());
     ASSERT(!m_deleted);
-    ASSERT(url().isNull() || cache()->resourceForURL(KURL(ParsedURLString, url())) != this);
+    ASSERT(url().isNull() || memoryCache()->resourceForURL(KURL(ParsedURLString, url())) != this);
 #ifndef NDEBUG
     m_deleted = true;
     cachedResourceLeakCounter.decrement();
@@ -259,7 +259,7 @@ void CachedResource::addClientToSet(CachedResourceClient* client)
             m_preloadResult = PreloadReferenced;
     }
     if (!hasClients() && inCache())
-        cache()->addToLiveResourcesSize(this);
+        memoryCache()->addToLiveResourcesSize(this);
     m_clients.add(client);
 }
 
@@ -271,8 +271,8 @@ void CachedResource::removeClient(CachedResourceClient* client)
     if (canDelete() && !inCache())
         delete this;
     else if (!hasClients() && inCache()) {
-        cache()->removeFromLiveResourcesSize(this);
-        cache()->removeFromLiveDecodedResourcesList(this);
+        memoryCache()->removeFromLiveResourcesSize(this);
+        memoryCache()->removeFromLiveDecodedResourcesList(this);
         allClientsRemoved();
         if (response().cacheControlContainsNoStore()) {
             // RFC2616 14.9.2:
@@ -280,9 +280,9 @@ void CachedResource::removeClient(CachedResourceClient* client)
             // "... History buffers MAY store such responses as part of their normal operation."
             // We allow non-secure content to be reused in history, but we do not allow secure content to be reused.
             if (protocolIs(url(), "https"))
-                cache()->remove(this);
+                memoryCache()->remove(this);
         } else
-            cache()->prune();
+            memoryCache()->prune();
     }
     // This object may be dead here.
 }
@@ -304,13 +304,13 @@ void CachedResource::setDecodedSize(unsigned size)
     // We have to remove explicitly before updating m_decodedSize, so that we find the correct previous
     // queue.
     if (inCache())
-        cache()->removeFromLRUList(this);
+        memoryCache()->removeFromLRUList(this);
     
     m_decodedSize = size;
    
     if (inCache()) { 
         // Now insert into the new LRU list.
-        cache()->insertInLRUList(this);
+        memoryCache()->insertInLRUList(this);
         
         // Insert into or remove from the live decoded list if necessary.
         // When inserting into the LiveDecodedResourcesList it is possible
@@ -320,12 +320,12 @@ void CachedResource::setDecodedSize(unsigned size)
         // by access time. The weakening of the invariant does not pose
         // a problem. For more details please see: https://bugs.webkit.org/show_bug.cgi?id=30209
         if (m_decodedSize && !m_inLiveDecodedResourcesList && hasClients())
-            cache()->insertInLiveDecodedResourcesList(this);
+            memoryCache()->insertInLiveDecodedResourcesList(this);
         else if (!m_decodedSize && m_inLiveDecodedResourcesList)
-            cache()->removeFromLiveDecodedResourcesList(this);
+            memoryCache()->removeFromLiveDecodedResourcesList(this);
 
         // Update the cache's size totals.
-        cache()->adjustSize(hasClients(), delta);
+        memoryCache()->adjustSize(hasClients(), delta);
     }
 }
 
@@ -343,16 +343,16 @@ void CachedResource::setEncodedSize(unsigned size)
     // We have to remove explicitly before updating m_encodedSize, so that we find the correct previous
     // queue.
     if (inCache())
-        cache()->removeFromLRUList(this);
+        memoryCache()->removeFromLRUList(this);
     
     m_encodedSize = size;
    
     if (inCache()) { 
         // Now insert into the new LRU list.
-        cache()->insertInLRUList(this);
+        memoryCache()->insertInLRUList(this);
         
         // Update the cache's size totals.
-        cache()->adjustSize(hasClients(), delta);
+        memoryCache()->adjustSize(hasClients(), delta);
     }
 }
 
@@ -362,10 +362,10 @@ void CachedResource::didAccessDecodedData(double timeStamp)
     
     if (inCache()) {
         if (m_inLiveDecodedResourcesList) {
-            cache()->removeFromLiveDecodedResourcesList(this);
-            cache()->insertInLiveDecodedResourcesList(this);
+            memoryCache()->removeFromLiveDecodedResourcesList(this);
+            memoryCache()->insertInLiveDecodedResourcesList(this);
         }
-        cache()->prune();
+        memoryCache()->prune();
     }
 }
     
diff --git a/Source/WebCore/loader/cache/CachedResourceLoader.cpp b/Source/WebCore/loader/cache/CachedResourceLoader.cpp
index 3fcace6..de02758 100644
--- a/Source/WebCore/loader/cache/CachedResourceLoader.cpp
+++ b/Source/WebCore/loader/cache/CachedResourceLoader.cpp
@@ -43,8 +43,10 @@
 #include "Logging.h"
 #include "MemoryCache.h"
 #include "PingLoader.h"
+#include "ResourceLoadScheduler.h"
 #include "SecurityOrigin.h"
 #include "Settings.h"
+#include <wtf/text/CString.h>
 #include <wtf/text/StringConcatenate.h>
 
 #define PRELOAD_DEBUG 0
@@ -76,8 +78,7 @@ static CachedResource* createResource(CachedResource::Type type, const KURL& url
 }
 
 CachedResourceLoader::CachedResourceLoader(Document* document)
-    : m_cache(cache())
-    , m_document(document)
+    : m_document(document)
     , m_requestCount(0)
 #ifdef ANDROID_BLOCK_NETWORK_IMAGE
     , m_blockNetworkImage(false)
@@ -86,7 +87,6 @@ CachedResourceLoader::CachedResourceLoader(Document* document)
     , m_loadFinishing(false)
     , m_allowStaleResources(false)
 {
-    m_cache->addCachedResourceLoader(this);
 }
 
 CachedResourceLoader::~CachedResourceLoader()
@@ -96,7 +96,6 @@ CachedResourceLoader::~CachedResourceLoader()
     DocumentResourceMap::iterator end = m_documentResources.end();
     for (DocumentResourceMap::iterator it = m_documentResources.begin(); it != end; ++it)
         it->second->setOwningCachedResourceLoader(0);
-    m_cache->removeCachedResourceLoader(this);
 
     // Make sure no requests still point to this CachedResourceLoader
     ASSERT(m_requestCount == 0);
@@ -160,14 +159,14 @@ CachedCSSStyleSheet* CachedResourceLoader::requestUserCSSStyleSheet(const String
 {
     KURL url = MemoryCache::removeFragmentIdentifierIfNeeded(KURL(KURL(), requestURL));
 
-    if (CachedResource* existing = cache()->resourceForURL(url)) {
+    if (CachedResource* existing = memoryCache()->resourceForURL(url)) {
         if (existing->type() == CachedResource::CSSStyleSheet)
             return static_cast<CachedCSSStyleSheet*>(existing);
-        cache()->remove(existing);
+        memoryCache()->remove(existing);
     }
     CachedCSSStyleSheet* userSheet = new CachedCSSStyleSheet(url, charset);
     
-    bool inCache = cache()->add(userSheet);
+    bool inCache = memoryCache()->add(userSheet);
     if (!inCache)
         userSheet->setInCache(true);
     
@@ -290,7 +289,7 @@ CachedResource* CachedResourceLoader::requestResource(CachedResource::Type type,
         return 0;
     }
 
-    if (cache()->disabled()) {
+    if (memoryCache()->disabled()) {
         DocumentResourceMap::iterator it = m_documentResources.find(url.string());
         if (it != m_documentResources.end()) {
             it->second->setOwningCachedResourceLoader(0);
@@ -299,21 +298,21 @@ CachedResource* CachedResourceLoader::requestResource(CachedResource::Type type,
     }
 
     // See if we can use an existing resource from the cache.
-    CachedResource* resource = cache()->resourceForURL(url);
+    CachedResource* resource = memoryCache()->resourceForURL(url);
 
     switch (determineRevalidationPolicy(type, forPreload, resource)) {
     case Load:
         resource = loadResource(type, url, charset, priority);
         break;
     case Reload:
-        cache()->remove(resource);
+        memoryCache()->remove(resource);
         resource = loadResource(type, url, charset, priority);
         break;
     case Revalidate:
         resource = revalidateResource(resource, priority);
         break;
     case Use:
-        cache()->resourceAccessed(resource);
+        memoryCache()->resourceAccessed(resource);
         notifyLoadedFromMemoryCache(resource);
         break;
     }
@@ -331,7 +330,7 @@ CachedResource* CachedResourceLoader::revalidateResource(CachedResource* resourc
 {
     ASSERT(resource);
     ASSERT(resource->inCache());
-    ASSERT(!cache()->disabled());
+    ASSERT(!memoryCache()->disabled());
     ASSERT(resource->canUseCacheValidator());
     ASSERT(!resource->resourceToRevalidate());
     
@@ -341,8 +340,8 @@ CachedResource* CachedResourceLoader::revalidateResource(CachedResource* resourc
     LOG(ResourceLoading, "Resource %p created to revalidate %p", newResource, resource);
     newResource->setResourceToRevalidate(resource);
     
-    cache()->remove(resource);
-    cache()->add(newResource);
+    memoryCache()->remove(resource);
+    memoryCache()->add(newResource);
     
     newResource->setLoadPriority(priority);
     newResource->load(this);
@@ -353,13 +352,13 @@ CachedResource* CachedResourceLoader::revalidateResource(CachedResource* resourc
 
 CachedResource* CachedResourceLoader::loadResource(CachedResource::Type type, const KURL& url, const String& charset, ResourceLoadPriority priority)
 {
-    ASSERT(!cache()->resourceForURL(url));
+    ASSERT(!memoryCache()->resourceForURL(url));
     
     LOG(ResourceLoading, "Loading CachedResource for '%s'.", url.string().latin1().data());
     
     CachedResource* resource = createResource(type, url, charset);
     
-    bool inCache = cache()->add(resource);
+    bool inCache = memoryCache()->add(resource);
     
     // Pretend the resource is in the cache, to prevent it from being deleted during the load() call.
     // FIXME: CachedResource should just use normal refcounting instead.
@@ -377,7 +376,7 @@ CachedResource* CachedResourceLoader::loadResource(CachedResource::Type type, co
     // We don't support immediate loads, but we do support immediate failure.
     if (resource->errorOccurred()) {
         if (inCache)
-            cache()->remove(resource);
+            memoryCache()->remove(resource);
         else
             delete resource;
         return 0;
@@ -410,6 +409,16 @@ CachedResourceLoader::RevalidationPolicy CachedResourceLoader::determineRevalida
     if (existingResource->isPreloaded())
         return Use;
     
+    // CachePolicyHistoryBuffer uses the cache no matter what.
+    if (cachePolicy() == CachePolicyHistoryBuffer)
+        return Use;
+
+    // Don't reuse resources with Cache-control: no-store.
+    if (existingResource->response().cacheControlContainsNoStore()) {
+        LOG(ResourceLoading, "CachedResourceLoader::determineRevalidationPolicy reloading due to Cache-control: no-store.");
+        return Reload;
+    }
+
     // Avoid loading the same resource multiple times for a single document, even if the cache policies would tell us to.
     if (m_validatedURLs.contains(existingResource->url()))
         return Use;
@@ -420,10 +429,6 @@ CachedResourceLoader::RevalidationPolicy CachedResourceLoader::determineRevalida
         return Reload;
     }
     
-    // CachePolicyHistoryBuffer uses the cache no matter what.
-    if (cachePolicy() == CachePolicyHistoryBuffer)
-        return Use;
-    
     // We'll try to reload the resource if it failed last time.
     if (existingResource->errorOccurred()) {
         LOG(ResourceLoading, "CachedResourceLoader::determineRevalidationPolicye reloading due to resource being in the error state");
@@ -562,6 +567,7 @@ void CachedResourceLoader::loadDone(CachedResourceRequest* request)
     if (frame())
         frame()->loader()->loadDone();
     checkForPendingPreloads();
+    resourceLoadScheduler()->servePendingRequests();
 }
 
 void CachedResourceLoader::cancelRequests()
@@ -671,7 +677,7 @@ void CachedResourceLoader::clearPreloads()
         if (res->canDelete() && !res->inCache())
             delete res;
         else if (res->preloadResult() == CachedResource::PreloadNotReferenced)
-            cache()->remove(res);
+            memoryCache()->remove(res);
     }
     m_preloads.clear();
 }
@@ -715,7 +721,7 @@ void CachedResourceLoader::printPreloadStats()
         }
         
         if (res->errorOccurred())
-            cache()->remove(res);
+            memoryCache()->remove(res);
         
         res->decreasePreloadCount();
     }
diff --git a/Source/WebCore/loader/cache/CachedResourceLoader.h b/Source/WebCore/loader/cache/CachedResourceLoader.h
index 1d53976..bc351ce 100644
--- a/Source/WebCore/loader/cache/CachedResourceLoader.h
+++ b/Source/WebCore/loader/cache/CachedResourceLoader.h
@@ -50,7 +50,6 @@ class KURL;
 
 // The CachedResourceLoader manages the loading of scripts/images/stylesheets for a single document.
 class CachedResourceLoader : public Noncopyable {
-friend class MemoryCache;
 friend class ImageLoader;
 
 public:
@@ -124,7 +123,6 @@ private:
     void notifyLoadedFromMemoryCache(CachedResource*);
     bool canRequest(CachedResource::Type, const KURL&);
     
-    MemoryCache* m_cache;
     HashSet<String> m_validatedURLs;
     mutable DocumentResourceMap m_documentResources;
     Document* m_document;
diff --git a/Source/WebCore/loader/cache/CachedResourceRequest.cpp b/Source/WebCore/loader/cache/CachedResourceRequest.cpp
index 827bb8e..d5e1adf 100644
--- a/Source/WebCore/loader/cache/CachedResourceRequest.cpp
+++ b/Source/WebCore/loader/cache/CachedResourceRequest.cpp
@@ -122,7 +122,7 @@ PassRefPtr<CachedResourceRequest> CachedResourceRequest::load(CachedResourceLoad
         cachedResourceLoader->decrementRequestCount(resource);
         cachedResourceLoader->loadFinishing();
         if (resource->resourceToRevalidate()) 
-            cache()->revalidationFailed(resource); 
+            memoryCache()->revalidationFailed(resource); 
         resource->error(CachedResource::LoadError);
         cachedResourceLoader->loadDone(0);
         return 0;
@@ -186,7 +186,7 @@ void CachedResourceRequest::didFail(bool cancelled)
     m_loader->clearClient();
 
     if (m_resource->resourceToRevalidate())
-        cache()->revalidationFailed(m_resource);
+        memoryCache()->revalidationFailed(m_resource);
 
     if (!cancelled) {
         m_cachedResourceLoader->loadFinishing();
@@ -194,7 +194,7 @@ void CachedResourceRequest::didFail(bool cancelled)
     }
 
     if (cancelled || !m_resource->isPreloaded())
-        cache()->remove(m_resource);
+        memoryCache()->remove(m_resource);
     
     m_cachedResourceLoader->loadDone(this);
 }
@@ -211,7 +211,7 @@ void CachedResourceRequest::didReceiveResponse(SubresourceLoader* loader, const
             m_finishing = true;
 
             // Existing resource is ok, just use it updating the expiration time.
-            cache()->revalidationSucceeded(m_resource, response);
+            memoryCache()->revalidationSucceeded(m_resource, response);
             
             if (m_cachedResourceLoader->frame())
                 m_cachedResourceLoader->frame()->loader()->checkCompleted();
@@ -220,7 +220,7 @@ void CachedResourceRequest::didReceiveResponse(SubresourceLoader* loader, const
             return;
         } 
         // Did not get 304 response, continue as a regular resource load.
-        cache()->revalidationFailed(m_resource);
+        memoryCache()->revalidationFailed(m_resource);
     }
 
     m_resource->setResponse(response);
diff --git a/Source/WebCore/loader/cache/MemoryCache.cpp b/Source/WebCore/loader/cache/MemoryCache.cpp
index 930033a..c0927f8 100644
--- a/Source/WebCore/loader/cache/MemoryCache.cpp
+++ b/Source/WebCore/loader/cache/MemoryCache.cpp
@@ -50,7 +50,7 @@ static const double cMinDelayBeforeLiveDecodedPrune = 1; // Seconds.
 static const float cTargetPrunePercentage = .95f; // Percentage of capacity toward which we prune, to avoid immediately pruning again.
 static const double cDefaultDecodedDataDeletionInterval = 0;
 
-MemoryCache* cache()
+MemoryCache* memoryCache()
 {
     static MemoryCache* staticCache = new MemoryCache;
     return staticCache;
@@ -346,16 +346,6 @@ void MemoryCache::evict(CachedResource* resource)
         delete resource;
 }
 
-void MemoryCache::addCachedResourceLoader(CachedResourceLoader* cachedResourceLoader)
-{
-    m_cachedResourceLoaders.add(cachedResourceLoader);
-}
-
-void MemoryCache::removeCachedResourceLoader(CachedResourceLoader* cachedResourceLoader)
-{
-    m_cachedResourceLoaders.remove(cachedResourceLoader);
-}
-
 static inline unsigned fastLog2(unsigned i)
 {
     unsigned log2 = 0;
diff --git a/Source/WebCore/loader/cache/MemoryCache.h b/Source/WebCore/loader/cache/MemoryCache.h
index dc47733..7a567ea 100644
--- a/Source/WebCore/loader/cache/MemoryCache.h
+++ b/Source/WebCore/loader/cache/MemoryCache.h
@@ -72,7 +72,7 @@ class KURL;
 
 class MemoryCache : public Noncopyable {
 public:
-    friend MemoryCache* cache();
+    friend MemoryCache* memoryCache();
 
     typedef HashMap<String, CachedResource*> CachedResourceMap;
 
@@ -186,9 +186,6 @@ private:
     bool makeResourcePurgeable(CachedResource*);
     void evict(CachedResource*);
 
-    // Member variables.
-    HashSet<CachedResourceLoader*> m_cachedResourceLoaders;
-
     bool m_disabled;  // Whether or not the cache is enabled.
     bool m_pruneEnabled;
     bool m_inPruneDeadResources;
@@ -224,7 +221,7 @@ inline bool MemoryCache::shouldMakeResourcePurgeableOnEviction()
 }
 
 // Function to obtain the global cache.
-MemoryCache* cache();
+MemoryCache* memoryCache();
 
 }