Changeset 116719 in webkit


Ignore:
Timestamp:
May 10, 2012 7:31:26 PM (12 years ago)
Author:
ap@apple.com
Message:

Crash in 3rd party WebKit apps that disable cache at a wrong time
​https://bugs.webkit.org/show_bug.cgi?id=86027
<rdar://problem/10615880>

Reviewed by Antti Koivisto.

Source/WebCore:

Added an API test.

The fix is to use CachedResourceHandle throughout MemoryCache, which will certainly
keep the resource alive. Also removed earlier fixes.

  • css/CSSImageSetValue.cpp: (WebCore::CSSImageSetValue::cachedImageSet):
  • css/CSSImageValue.cpp: (WebCore::CSSImageValue::cachedImage):
  • css/WebKitCSSShaderValue.cpp: (WebCore::WebKitCSSShaderValue::cachedShader):
  • history/PageCache.cpp: (WebCore::PageCache::releaseAutoreleasedPagesNow):
  • loader/ImageLoader.cpp: (WebCore::ImageLoader::updateFromElement):
  • loader/TextTrackLoader.cpp: (WebCore::TextTrackLoader::load):
  • loader/cache/CachedResourceLoader.cpp:

(WebCore::CachedResourceLoader::requestImage):
(WebCore::CachedResourceLoader::requestFont):
(WebCore::CachedResourceLoader::requestTextTrack):
(WebCore::CachedResourceLoader::requestShader):
(WebCore::CachedResourceLoader::requestCSSStyleSheet):
(WebCore::CachedResourceLoader::requestUserCSSStyleSheet):
(WebCore::CachedResourceLoader::requestScript):
(WebCore::CachedResourceLoader::requestXSLStyleSheet):
(WebCore::CachedResourceLoader::requestSVGDocument):
(WebCore::CachedResourceLoader::requestLinkResource):
(WebCore::CachedResourceLoader::requestRawResource):
(WebCore::CachedResourceLoader::requestResource):
(WebCore::CachedResourceLoader::revalidateResource):
(WebCore::CachedResourceLoader::loadResource):
(WebCore::CachedResourceLoader::requestPreload):

  • loader/cache/CachedResourceLoader.h: (CachedResourceLoader):
  • loader/cache/MemoryCache.h: (WebCore::MemoryCache::setPruneEnabled):
  • loader/cache/CachedResourceHandle.h:

(WebCore::CachedResourceHandle::CachedResourceHandle):
(WebCore::CachedResourceHandle::operator=):
Teach CachedResourceHandle how to make CachedResourceHandle<CachedResource> from
a handle to subclass.

Tools:

Added a test that's very similar to MemoryCachePruneWithinResourceLoadDelegate,
but for disabling the cache instead of triggering a prune.

  • TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj:
  • TestWebKitAPI/Tests/mac/MemoryCacheDisableWithinResourceLoadDelegate.html: Added.
  • TestWebKitAPI/Tests/mac/MemoryCacheDisableWithinResourceLoadDelegate.mm: Added.

(-[MemoryCacheDisableTestResourceLoadDelegate webView:identifierForInitialRequest:fromDataSource:]):
(-[MemoryCacheDisableTestResourceLoadDelegate webView:resource:willSendRequest:redirectResponse:fromDataSource:]):
(-[MemoryCacheDisableTestResourceLoadDelegate webView:resource:didFinishLoadingFromDataSource:]):
(-[MemoryCacheDisableTestResourceLoadDelegate webView:resource:didFailLoadingWithError:fromDataSource:]):
(TestWebKitAPI::TEST):

Location:
trunk
Files:
2 added
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r116718 r116719  
     12012-05-10  Alexey Proskuryakov  <ap@apple.com>
     2
     3        Crash in 3rd party WebKit apps that disable cache at a wrong time
     4        https://bugs.webkit.org/show_bug.cgi?id=86027
     5        <rdar://problem/10615880>
     6
     7        Reviewed by Antti Koivisto.
     8
     9        Added an API test.
     10
     11        The fix is to use CachedResourceHandle throughout MemoryCache, which will certainly
     12        keep the resource alive. Also removed earlier fixes.
     13
     14        * css/CSSImageSetValue.cpp: (WebCore::CSSImageSetValue::cachedImageSet):
     15        * css/CSSImageValue.cpp: (WebCore::CSSImageValue::cachedImage):
     16        * css/WebKitCSSShaderValue.cpp: (WebCore::WebKitCSSShaderValue::cachedShader):
     17        * history/PageCache.cpp: (WebCore::PageCache::releaseAutoreleasedPagesNow):
     18        * loader/ImageLoader.cpp: (WebCore::ImageLoader::updateFromElement):
     19        * loader/TextTrackLoader.cpp: (WebCore::TextTrackLoader::load):
     20        * loader/cache/CachedResourceLoader.cpp:
     21        (WebCore::CachedResourceLoader::requestImage):
     22        (WebCore::CachedResourceLoader::requestFont):
     23        (WebCore::CachedResourceLoader::requestTextTrack):
     24        (WebCore::CachedResourceLoader::requestShader):
     25        (WebCore::CachedResourceLoader::requestCSSStyleSheet):
     26        (WebCore::CachedResourceLoader::requestUserCSSStyleSheet):
     27        (WebCore::CachedResourceLoader::requestScript):
     28        (WebCore::CachedResourceLoader::requestXSLStyleSheet):
     29        (WebCore::CachedResourceLoader::requestSVGDocument):
     30        (WebCore::CachedResourceLoader::requestLinkResource):
     31        (WebCore::CachedResourceLoader::requestRawResource):
     32        (WebCore::CachedResourceLoader::requestResource):
     33        (WebCore::CachedResourceLoader::revalidateResource):
     34        (WebCore::CachedResourceLoader::loadResource):
     35        (WebCore::CachedResourceLoader::requestPreload):
     36        * loader/cache/CachedResourceLoader.h: (CachedResourceLoader):
     37        * loader/cache/MemoryCache.h: (WebCore::MemoryCache::setPruneEnabled):
     38
     39        * loader/cache/CachedResourceHandle.h:
     40        (WebCore::CachedResourceHandle::CachedResourceHandle):
     41        (WebCore::CachedResourceHandle::operator=):
     42        Teach CachedResourceHandle how to make CachedResourceHandle<CachedResource> from
     43        a handle to subclass.
     44
    1452012-05-10  Tien-Ren Chen  <trchen@chromium.org>
    246

  • trunk/Source/WebCore/css/CSSImageSetValue.cpp

    r114669 r116719  
    107107        ImageWithScale image = bestImageForScaleFactor();
    108108        ResourceRequest request(loader->document()->completeURL(image.imageURL));
    109         if (CachedImage* cachedImage = loader->requestImage(request)) {
    110             m_imageSet = StyleCachedImageSet::create(cachedImage, image.scaleFactor, this);
     109        if (CachedResourceHandle<CachedImage> cachedImage = loader->requestImage(request)) {
     110            m_imageSet = StyleCachedImageSet::create(cachedImage.get(), image.scaleFactor, this);
    111111            m_accessedBestFitImage = true;
    112112        }

  • trunk/Source/WebCore/css/CSSImageValue.cpp

    r115991 r116719  
    8383
    8484        ResourceRequest request(loader->document()->completeURL(url));
    85         if (CachedImage* cachedImage = loader->requestImage(request))
    86             m_image = StyleCachedImage::create(cachedImage);
     85        if (CachedResourceHandle<CachedImage> cachedImage = loader->requestImage(request))
     86            m_image = StyleCachedImage::create(cachedImage.get());
    8787    }
    8888

  • trunk/Source/WebCore/css/WebKitCSSShaderValue.cpp

    r108952 r116719  
    6060
    6161        ResourceRequest request(loader->document()->completeURL(m_url));
    62         if (CachedShader* cachedShader = loader->requestShader(request))
    63             m_shader = StyleCachedShader::create(cachedShader);
     62        if (CachedResourceHandle<CachedShader> cachedShader = loader->requestShader(request))
     63            m_shader = StyleCachedShader::create(cachedShader.get());
    6464    }
    6565

  • trunk/Source/WebCore/history/PageCache.cpp

    r116167 r116719  
    536536
    537537    // Postpone dead pruning until all our resources have gone dead.
    538     bool pruneWasEnabled = memoryCache()->pruneEnabled();
    539538    memoryCache()->setPruneEnabled(false);
    540539
    … …  
    547546
    548547    // Now do the prune.
    549     if (pruneWasEnabled) {
    550         memoryCache()->setPruneEnabled(true);
    551         memoryCache()->prune();
    552     }
     548    memoryCache()->setPruneEnabled(true);
     549    memoryCache()->prune();
    553550}
    554551

  • trunk/Source/WebCore/loader/ImageLoader.cpp

    r112215 r116719  
    155155    // Do not load any image if the 'src' attribute is missing or if it is
    156156    // an empty string.
    157     CachedImage* newImage = 0;
     157    CachedResourceHandle<CachedImage> newImage = 0;
    158158    if (!attr.isNull() && !stripLeadingAndTrailingHTMLSpaces(attr).isEmpty()) {
    159159        ResourceRequest request = ResourceRequest(document->completeURL(sourceURI(attr)));
    … …  
    171171            newImage->setLoading(true);
    172172            newImage->setOwningCachedResourceLoader(document->cachedResourceLoader());
    173             document->cachedResourceLoader()->m_documentResources.set(newImage->url(), newImage);
     173            document->cachedResourceLoader()->m_documentResources.set(newImage->url(), newImage.get());
    174174            document->cachedResourceLoader()->setAutoLoadImages(autoLoadOtherImages);
    175175        } else

  • trunk/Source/WebCore/loader/TextTrackLoader.cpp

    r113343 r116719  
    168168
    169169    CachedResourceLoader* cachedResourceLoader = document->cachedResourceLoader();
    170     m_cachedCueData = static_cast<CachedTextTrack*>(cachedResourceLoader->requestTextTrack(cueRequest));
     170    m_cachedCueData = cachedResourceLoader->requestTextTrack(cueRequest);
    171171    if (m_cachedCueData)
    172172        m_cachedCueData->addClient(this);

  • trunk/Source/WebCore/loader/cache/CachedResourceHandle.h

    r100086 r116719  
    6262        CachedResourceHandle(R* res) : CachedResourceHandleBase(res) { }
    6363        CachedResourceHandle(const CachedResourceHandle<R>& o) : CachedResourceHandleBase(o) { }
     64        template<typename U> CachedResourceHandle(const CachedResourceHandle<U>& o) : CachedResourceHandleBase(o.get()) { }
    6465
    6566        R* get() const { return reinterpret_cast<R*>(CachedResourceHandleBase::get()); }
    … …  
    6869        CachedResourceHandle& operator=(R* res) { setResource(res); return *this; }
    6970        CachedResourceHandle& operator=(const CachedResourceHandle& o) { setResource(o.get()); return *this; }
     71        template<typename U> CachedResourceHandle& operator=(const CachedResourceHandle<U>& o) { setResource(o.get()); return *this; }
     72
    7073        bool operator==(const CachedResourceHandleBase& o) const { return get() == o.get(); }
    7174        bool operator!=(const CachedResourceHandleBase& o) const { return get() != o.get(); }

  • trunk/Source/WebCore/loader/cache/CachedResourceLoader.cpp

    r114328 r116719  
    152152}
    153153
    154 CachedImage* CachedResourceLoader::requestImage(ResourceRequest& request)
     154CachedResourceHandle<CachedImage> CachedResourceLoader::requestImage(ResourceRequest& request)
    155155{
    156156    if (Frame* f = frame()) {
    … …  
    162162        }
    163163    }
    164     CachedImage* resource = static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request, String(), defaultCachedResourceOptions()));
     164    CachedResourceHandle<CachedImage> resource(static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request, String(), defaultCachedResourceOptions()).get()));
    165165    if (autoLoadImages() && resource && resource->stillNeedsLoad())
    166166        resource->load(this, defaultCachedResourceOptions());
    … …  
    168168}
    169169
    170 CachedFont* CachedResourceLoader::requestFont(ResourceRequest& request)
    171 {
    172     return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, request, String(), defaultCachedResourceOptions()));
     170CachedResourceHandle<CachedFont> CachedResourceLoader::requestFont(ResourceRequest& request)
     171{
     172    return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, request, String(), defaultCachedResourceOptions()).get());
    173173}
    174174
    175175#if ENABLE(VIDEO_TRACK)
    176 CachedTextTrack* CachedResourceLoader::requestTextTrack(ResourceRequest& request)
    177 {
    178     return static_cast<CachedTextTrack*>(requestResource(CachedResource::TextTrackResource, request, String(), defaultCachedResourceOptions()));
     176CachedResourceHandle<CachedTextTrack> CachedResourceLoader::requestTextTrack(ResourceRequest& request)
     177{
     178    return static_cast<CachedTextTrack*>(requestResource(CachedResource::TextTrackResource, request, String(), defaultCachedResourceOptions()).get());
    179179}
    180180#endif
    181181
    182182#if ENABLE(CSS_SHADERS)
    183 CachedShader* CachedResourceLoader::requestShader(ResourceRequest& request)
    184 {
    185     return static_cast<CachedShader*>(requestResource(CachedResource::ShaderResource, request, String(), defaultCachedResourceOptions()));
    186 }
    187 #endif
    188 
    189 CachedCSSStyleSheet* CachedResourceLoader::requestCSSStyleSheet(ResourceRequest& request, const String& charset, ResourceLoadPriority priority)
    190 {
    191     return static_cast<CachedCSSStyleSheet*>(requestResource(CachedResource::CSSStyleSheet, request, charset, defaultCachedResourceOptions(), priority));
    192 }
    193 
    194 CachedCSSStyleSheet* CachedResourceLoader::requestUserCSSStyleSheet(ResourceRequest& request, const String& charset)
     183CachedResourceHandle<CachedShader> CachedResourceLoader::requestShader(ResourceRequest& request)
     184{
     185    return static_cast<CachedShader*>(requestResource(CachedResource::ShaderResource, request, String(), defaultCachedResourceOptions()).get());
     186}
     187#endif
     188
     189CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestCSSStyleSheet(ResourceRequest& request, const String& charset, ResourceLoadPriority priority)
     190{
     191    return static_cast<CachedCSSStyleSheet*>(requestResource(CachedResource::CSSStyleSheet, request, charset, defaultCachedResourceOptions(), priority).get());
     192}
     193
     194CachedResourceHandle<CachedCSSStyleSheet> CachedResourceLoader::requestUserCSSStyleSheet(ResourceRequest& request, const String& charset)
    195195{
    196196    KURL url = MemoryCache::removeFragmentIdentifierIfNeeded(request.url());
    … …  
    204204        request.setURL(url);
    205205
    206     CachedCSSStyleSheet* userSheet = new CachedCSSStyleSheet(request, charset);
    207    
    208     bool inCache = memoryCache()->add(userSheet);
    209     if (!inCache)
    210         userSheet->setInCache(true);
     206    CachedResourceHandle<CachedCSSStyleSheet> userSheet = new CachedCSSStyleSheet(request, charset);
     207
     208    memoryCache()->add(userSheet.get());
     209    // FIXME: loadResource calls setOwningCachedResourceLoader() if the resource couldn't be added to cache. Does this function need to call it, too?
    211210
    212211    userSheet->load(this, ResourceLoaderOptions(DoNotSendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials, SkipSecurityCheck));
    213 
    214     if (!inCache)
    215         userSheet->setInCache(false);
    216212   
    217213    return userSheet;
    218214}
    219215
    220 CachedScript* CachedResourceLoader::requestScript(ResourceRequest& request, const String& charset)
    221 {
    222     return static_cast<CachedScript*>(requestResource(CachedResource::Script, request, charset, defaultCachedResourceOptions()));
     216CachedResourceHandle<CachedScript> CachedResourceLoader::requestScript(ResourceRequest& request, const String& charset)
     217{
     218    return static_cast<CachedScript*>(requestResource(CachedResource::Script, request, charset, defaultCachedResourceOptions()).get());
    223219}
    224220
    225221#if ENABLE(XSLT)
    226 CachedXSLStyleSheet* CachedResourceLoader::requestXSLStyleSheet(ResourceRequest& request)
    227 {
    228     return static_cast<CachedXSLStyleSheet*>(requestResource(CachedResource::XSLStyleSheet, request, String(), defaultCachedResourceOptions()));
     222CachedResourceHandle<CachedXSLStyleSheet> CachedResourceLoader::requestXSLStyleSheet(ResourceRequest& request)
     223{
     224    return static_cast<CachedXSLStyleSheet*>(requestResource(CachedResource::XSLStyleSheet, request, String(), defaultCachedResourceOptions()).get());
    229225}
    230226#endif
    231227
    232228#if ENABLE(SVG)
    233 CachedSVGDocument* CachedResourceLoader::requestSVGDocument(ResourceRequest& request)
    234 {
    235     return static_cast<CachedSVGDocument*>(requestResource(CachedResource::SVGDocumentResource, request, request.url(), defaultCachedResourceOptions()));
     229CachedResourceHandle<CachedSVGDocument> CachedResourceLoader::requestSVGDocument(ResourceRequest& request)
     230{
     231    return static_cast<CachedSVGDocument*>(requestResource(CachedResource::SVGDocumentResource, request, request.url(), defaultCachedResourceOptions()).get());
    236232}
    237233#endif
    238234
    239235#if ENABLE(LINK_PREFETCH)
    240 CachedResource* CachedResourceLoader::requestLinkResource(CachedResource::Type type, ResourceRequest& request, ResourceLoadPriority priority)
     236CachedResourceHandle<CachedResource> CachedResourceLoader::requestLinkResource(CachedResource::Type type, ResourceRequest& request, ResourceLoadPriority priority)
    241237{
    242238    ASSERT(frame());
    … …  
    246242#endif
    247243
    248 CachedRawResource* CachedResourceLoader::requestRawResource(ResourceRequest& request, const ResourceLoaderOptions& options)
    249 {
    250     return static_cast<CachedRawResource*>(requestResource(CachedResource::RawResource, request, String(), options, ResourceLoadPriorityUnresolved, false));
     244CachedResourceHandle<CachedRawResource> CachedResourceLoader::requestRawResource(ResourceRequest& request, const ResourceLoaderOptions& options)
     245{
     246    return static_cast<CachedRawResource*>(requestResource(CachedResource::RawResource, request, String(), options, ResourceLoadPriorityUnresolved, false).get());
    251247}
    252248
    … …  
    411407}
    412408
    413 CachedResource* CachedResourceLoader::requestResource(CachedResource::Type type, ResourceRequest& request, const String& charset, const ResourceLoaderOptions& options, ResourceLoadPriority priority, bool forPreload)
     409CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(CachedResource::Type type, ResourceRequest& request, const String& charset, const ResourceLoaderOptions& options, ResourceLoadPriority priority, bool forPreload)
    414410{
    415411    KURL url = request.url();
    … …  
    435431
    436432    // See if we can use an existing resource from the cache.
    437     CachedResource* resource = memoryCache()->resourceForURL(url);
     433    CachedResourceHandle<CachedResource> resource = memoryCache()->resourceForURL(url);
    438434
    439435    if (request.url() != url)
    440436        request.setURL(url);
    441437
    442     switch (determineRevalidationPolicy(type, request, forPreload, resource)) {
     438    switch (determineRevalidationPolicy(type, request, forPreload, resource.get())) {
    443439    case Load:
    444440        resource = loadResource(type, request, charset, priority, options);
    445441        break;
    446442    case Reload:
    447         memoryCache()->remove(resource);
     443        memoryCache()->remove(resource.get());
    448444        resource = loadResource(type, request, charset, priority, options);
    449445        break;
    450446    case Revalidate:
    451         resource = revalidateResource(resource, priority, options);
     447        resource = revalidateResource(resource.get(), priority, options);
    452448        break;
    453449    case Use:
    454         memoryCache()->resourceAccessed(resource);
    455         notifyLoadedFromMemoryCache(resource);
     450        memoryCache()->resourceAccessed(resource.get());
     451        notifyLoadedFromMemoryCache(resource.get());
    456452        break;
    457453    }
    … …  
    464460    return resource;
    465461}
    466    
    467 CachedResource* CachedResourceLoader::revalidateResource(CachedResource* resource, ResourceLoadPriority priority, const ResourceLoaderOptions& options)
     462
     463CachedResourceHandle<CachedResource> CachedResourceLoader::revalidateResource(CachedResource* resource, ResourceLoadPriority priority, const ResourceLoaderOptions& options)
    468464{
    469465    ASSERT(resource);
    … …  
    476472    String url = resource->url();
    477473    bool urlProtocolIsData = resource->url().protocolIsData();
    478     CachedResource* newResource = createResource(resource->type(), resource->resourceRequest(), resource->encoding());
    479    
    480     LOG(ResourceLoading, "Resource %p created to revalidate %p", newResource, resource);
     474    CachedResourceHandle<CachedResource> newResource = createResource(resource->type(), resource->resourceRequest(), resource->encoding());
     475   
     476    LOG(ResourceLoading, "Resource %p created to revalidate %p", newResource.get(), resource);
    481477    newResource->setResourceToRevalidate(resource);
    482478   
    483479    memoryCache()->remove(resource);
    484     memoryCache()->add(newResource);
     480    memoryCache()->add(newResource.get());
    485481   
    486482    newResource->setLoadPriority(priority);
    … …  
    492488}
    493489
    494 CachedResource* CachedResourceLoader::loadResource(CachedResource::Type type, ResourceRequest& request, const String& charset, ResourceLoadPriority priority, const ResourceLoaderOptions& options)
     490CachedResourceHandle<CachedResource> CachedResourceLoader::loadResource(CachedResource::Type type, ResourceRequest& request, const String& charset, ResourceLoadPriority priority, const ResourceLoaderOptions& options)
    495491{
    496492    ASSERT(!memoryCache()->resourceForURL(request.url()));
    … …  
    498494    LOG(ResourceLoading, "Loading CachedResource for '%s'.", request.url().string().latin1().data());
    499495   
    500     CachedResource* resource = createResource(type, request, charset);
    501    
    502     bool inCache = memoryCache()->add(resource);
    503    
    504     // Pretend the resource is in the cache, to prevent it from being deleted during the load() call.
    505     // FIXME: CachedResource should just use normal refcounting instead.
     496    CachedResourceHandle<CachedResource> resource = createResource(type, request, charset);
     497   
     498    bool inCache = memoryCache()->add(resource.get());
     499   
     500    resource->setLoadPriority(priority);
     501    resource->load(this, options);
     502   
    506503    if (!inCache)
    507         resource->setInCache(true);
    508    
    509     resource->setLoadPriority(priority);
    510    
    511     bool wasPruneEnabled = memoryCache()->pruneEnabled();
    512     memoryCache()->setPruneEnabled(false);
    513     resource->load(this, options);
    514     memoryCache()->setPruneEnabled(wasPruneEnabled);
    515    
    516     if (!inCache) {
    517504        resource->setOwningCachedResourceLoader(this);
    518         resource->setInCache(false);
    519     }
    520505
    521506    // We don't support immediate loads, but we do support immediate failure.
    522507    if (resource->errorOccurred()) {
    523508        if (inCache)
    524             memoryCache()->remove(resource);
    525         else
    526             delete resource;
     509            memoryCache()->remove(resource.get());
    527510        return 0;
    528511    }
    … …  
    782765        encoding = charset.isEmpty() ? m_document->charset() : charset;
    783766
    784     CachedResource* resource = requestResource(type, request, encoding, defaultCachedResourceOptions(), ResourceLoadPriorityUnresolved, true);
    785     if (!resource || (m_preloads && m_preloads->contains(resource)))
     767    CachedResourceHandle<CachedResource> resource = requestResource(type, request, encoding, defaultCachedResourceOptions(), ResourceLoadPriorityUnresolved, true);
     768    if (!resource || (m_preloads && m_preloads->contains(resource.get())))
    786769        return;
    787770    resource->increasePreloadCount();
    … …  
    789772    if (!m_preloads)
    790773        m_preloads = adoptPtr(new ListHashSet<CachedResource*>);
    791     m_preloads->add(resource);
     774    m_preloads->add(resource.get());
    792775
    793776#if PRELOAD_DEBUG

  • trunk/Source/WebCore/loader/cache/CachedResourceLoader.h

    r114328 r116719  
    6464    ~CachedResourceLoader();
    6565
    66     CachedImage* requestImage(ResourceRequest&);
    67     CachedCSSStyleSheet* requestCSSStyleSheet(ResourceRequest&, const String& charset, ResourceLoadPriority = ResourceLoadPriorityUnresolved);
    68     CachedCSSStyleSheet* requestUserCSSStyleSheet(ResourceRequest&, const String& charset);
    69     CachedScript* requestScript(ResourceRequest&, const String& charset);
    70     CachedFont* requestFont(ResourceRequest&);
    71     CachedRawResource* requestRawResource(ResourceRequest&, const ResourceLoaderOptions&);
     66    CachedResourceHandle<CachedImage> requestImage(ResourceRequest&);
     67    CachedResourceHandle<CachedCSSStyleSheet> requestCSSStyleSheet(ResourceRequest&, const String& charset, ResourceLoadPriority = ResourceLoadPriorityUnresolved);
     68    CachedResourceHandle<CachedCSSStyleSheet> requestUserCSSStyleSheet(ResourceRequest&, const String& charset);
     69    CachedResourceHandle<CachedScript> requestScript(ResourceRequest&, const String& charset);
     70    CachedResourceHandle<CachedFont> requestFont(ResourceRequest&);
     71    CachedResourceHandle<CachedRawResource> requestRawResource(ResourceRequest&, const ResourceLoaderOptions&);
    7272
    7373#if ENABLE(SVG)
    74     CachedSVGDocument* requestSVGDocument(ResourceRequest&);
     74    CachedResourceHandle<CachedSVGDocument> requestSVGDocument(ResourceRequest&);
    7575#endif
    7676#if ENABLE(XSLT)
    77     CachedXSLStyleSheet* requestXSLStyleSheet(ResourceRequest&);
     77    CachedResourceHandle<CachedXSLStyleSheet> requestXSLStyleSheet(ResourceRequest&);
    7878#endif
    7979#if ENABLE(LINK_PREFETCH)
    80     CachedResource* requestLinkResource(CachedResource::Type, ResourceRequest&, ResourceLoadPriority = ResourceLoadPriorityUnresolved);
     80    CachedResourceHandle<CachedResource> requestLinkResource(CachedResource::Type, ResourceRequest&, ResourceLoadPriority = ResourceLoadPriorityUnresolved);
    8181#endif
    8282#if ENABLE(VIDEO_TRACK)
    83     CachedTextTrack* requestTextTrack(ResourceRequest&);
     83    CachedResourceHandle<CachedTextTrack> requestTextTrack(ResourceRequest&);
    8484#endif
    8585#if ENABLE(CSS_SHADERS)
    86     CachedShader* requestShader(ResourceRequest&);
     86    CachedResourceHandle<CachedShader> requestShader(ResourceRequest&);
    8787#endif
    8888
    … …  
    120120   
    121121private:
    122     CachedResource* requestResource(CachedResource::Type, ResourceRequest&, const String& charset, const ResourceLoaderOptions&, ResourceLoadPriority = ResourceLoadPriorityUnresolved, bool isPreload = false);
    123     CachedResource* revalidateResource(CachedResource*, ResourceLoadPriority, const ResourceLoaderOptions&);
    124     CachedResource* loadResource(CachedResource::Type, ResourceRequest&, const String& charset, ResourceLoadPriority, const ResourceLoaderOptions&);
     122    CachedResourceHandle<CachedResource> requestResource(CachedResource::Type, ResourceRequest&, const String& charset, const ResourceLoaderOptions&, ResourceLoadPriority = ResourceLoadPriorityUnresolved, bool isPreload = false);
     123    CachedResourceHandle<CachedResource> revalidateResource(CachedResource*, ResourceLoadPriority, const ResourceLoaderOptions&);
     124    CachedResourceHandle<CachedResource> loadResource(CachedResource::Type, ResourceRequest&, const String& charset, ResourceLoadPriority, const ResourceLoaderOptions&);
    125125    void requestPreload(CachedResource::Type, ResourceRequest&, const String& charset);
    126126

  • trunk/Source/WebCore/loader/cache/MemoryCache.h

    r115454 r116719  
    130130   
    131131    void setPruneEnabled(bool enabled) { m_pruneEnabled = enabled; }
    132     bool pruneEnabled() const { return m_pruneEnabled; }
    133132    void prune();
    134133    void pruneToPercentage(float targetPercentLive);

  • trunk/Tools/ChangeLog

    r116716 r116719  
     12012-05-10  Alexey Proskuryakov  <ap@apple.com>
     2
     3        Crash in 3rd party WebKit apps that disable cache at a wrong time
     4        https://bugs.webkit.org/show_bug.cgi?id=86027
     5        <rdar://problem/10615880>
     6
     7        Reviewed by Antti Koivisto.
     8
     9        Added a test that's very similar to MemoryCachePruneWithinResourceLoadDelegate,
     10        but for disabling the cache instead of triggering a prune.
     11
     12        * TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj:
     13        * TestWebKitAPI/Tests/mac/MemoryCacheDisableWithinResourceLoadDelegate.html: Added.
     14        * TestWebKitAPI/Tests/mac/MemoryCacheDisableWithinResourceLoadDelegate.mm: Added.
     15        (-[MemoryCacheDisableTestResourceLoadDelegate webView:identifierForInitialRequest:fromDataSource:]):
     16        (-[MemoryCacheDisableTestResourceLoadDelegate webView:resource:willSendRequest:redirectResponse:fromDataSource:]):
     17        (-[MemoryCacheDisableTestResourceLoadDelegate webView:resource:didFinishLoadingFromDataSource:]):
     18        (-[MemoryCacheDisableTestResourceLoadDelegate webView:resource:didFailLoadingWithError:fromDataSource:]):
     19        (TestWebKitAPI::TEST):
     20
    1212012-05-10  Anders Carlsson  <andersca@apple.com>
    222

  • trunk/Tools/TestWebKitAPI/TestWebKitAPI.xcodeproj/project.pbxproj

    r116595 r116719  
    142142                C540F776152E4DA000A40C8C /* SimplifyMarkup.mm in Sources */ = {isa = PBXBuildFile; fileRef = C540F775152E4DA000A40C8C /* SimplifyMarkup.mm */; };
    143143                C540F784152E5A9A00A40C8C /* verboseMarkup.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = C540F783152E5A7800A40C8C /* verboseMarkup.html */; };
     144                E1220DA0155B25480013E2FC /* MemoryCacheDisableWithinResourceLoadDelegate.mm in Sources */ = {isa = PBXBuildFile; fileRef = E1220D9F155B25480013E2FC /* MemoryCacheDisableWithinResourceLoadDelegate.mm */; };
     145                E1220DCA155B28AA0013E2FC /* MemoryCacheDisableWithinResourceLoadDelegate.html in Copy Resources */ = {isa = PBXBuildFile; fileRef = E1220DC9155B287D0013E2FC /* MemoryCacheDisableWithinResourceLoadDelegate.html */; };
    144146                E490296814E2E3A4002BEDD1 /* TypingStyleCrash.mm in Sources */ = {isa = PBXBuildFile; fileRef = E490296714E2E3A4002BEDD1 /* TypingStyleCrash.mm */; };
    145147                F3FC3EE313678B7300126A65 /* libgtest.a in Frameworks */ = {isa = PBXBuildFile; fileRef = F3FC3EE213678B7300126A65 /* libgtest.a */; };
    … …  
    183185                                76E182DF154767E600F1FADD /* auto-submitting-form.html in Copy Resources */,
    184186                                5142B2731517C8C800C32B19 /* ContextMenuCanCopyURL.html in Copy Resources */,
     187                                E1220DCA155B28AA0013E2FC /* MemoryCacheDisableWithinResourceLoadDelegate.html in Copy Resources */,
    185188                                517E7E04151119C100D0B008 /* MemoryCachePruneWithinResourceLoadDelegate.html in Copy Resources */,
    186189                                379028B914FAC24C007E6B43 /* acceptsFirstMouse.html in Copy Resources */,
    … …  
    361364                C540F775152E4DA000A40C8C /* SimplifyMarkup.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = SimplifyMarkup.mm; sourceTree = "<group>"; };
    362365                C540F783152E5A7800A40C8C /* verboseMarkup.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = verboseMarkup.html; sourceTree = "<group>"; };
     366                E1220D9F155B25480013E2FC /* MemoryCacheDisableWithinResourceLoadDelegate.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = MemoryCacheDisableWithinResourceLoadDelegate.mm; sourceTree = "<group>"; };
     367                E1220DC9155B287D0013E2FC /* MemoryCacheDisableWithinResourceLoadDelegate.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = MemoryCacheDisableWithinResourceLoadDelegate.html; sourceTree = "<group>"; };
    363368                E490296714E2E3A4002BEDD1 /* TypingStyleCrash.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = TypingStyleCrash.mm; sourceTree = "<group>"; };
    364369                F3FC3EE213678B7300126A65 /* libgtest.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libgtest.a; sourceTree = BUILT_PRODUCTS_DIR; };
    … …  
    655660                                939BA91614103412001A01BD /* DeviceScaleFactorOnBack.mm */,
    656661                                C507E8A614C6545B005D6B3B /* InspectorBar.mm */,
     662                                E1220D9F155B25480013E2FC /* MemoryCacheDisableWithinResourceLoadDelegate.mm */,
    657663                                517E7DFB15110EA600D0B008 /* MemoryCachePruneWithinResourceLoadDelegate.mm */,
    658664                                3722C8681461E03E00C45D00 /* RenderedImageFromDOMRange.mm */,
    … …  
    674680                                5142B2721517C89100C32B19 /* ContextMenuCanCopyURL.html */,
    675681                                37DC678F140D7D3A00ABCCDB /* DOMRangeOfString.html */,
     682                                E1220DC9155B287D0013E2FC /* MemoryCacheDisableWithinResourceLoadDelegate.html */,
     683                                517E7E031511187500D0B008 /* MemoryCachePruneWithinResourceLoadDelegate.html */,
    676684                                C07E6CB113FD738A0038B22B /* devicePixelRatio.html */,
    677                                 517E7E031511187500D0B008 /* MemoryCachePruneWithinResourceLoadDelegate.html */,
    678685                                C540F783152E5A7800A40C8C /* verboseMarkup.html */,
    679686                        );
    … …  
    879886                                51393E201523944A005F39C5 /* DOMWindowExtensionBasic.cpp in Sources */,
    880887                                76E182DA1547550100F1FADD /* WillSendSubmitEvent.cpp in Sources */,
     888                                E1220DA0155B25480013E2FC /* MemoryCacheDisableWithinResourceLoadDelegate.mm in Sources */,
    881889                                F6F49C6915545C8E0007F39D /* DOMWindowExtensionNoCache.cpp in Sources */,
    882890                        );
Note: See TracChangeset for help on using the changeset viewer.