⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 176450 in webkit


Ignore:
Timestamp:
Nov 21, 2014, 9:04:42 AM (12 years ago)
Author:
andersca@apple.com
Message:

Make memoryCache() return a reference
​https://bugs.webkit.org/show_bug.cgi?id=138939

Reviewed by Antti Koivisto.

Source/WebCore:

  • inspector/InspectorPageAgent.cpp:

(WebCore::InspectorPageAgent::cachedResource):

  • inspector/InspectorResourceAgent.cpp:

(WebCore::InspectorResourceAgent::replayXHR):
(WebCore::InspectorResourceAgent::setCacheDisabled):
(WebCore::InspectorResourceAgent::mainFrameNavigated):

  • loader/DocumentLoader.cpp:

(WebCore::areAllLoadersPageCacheAcceptable):
(WebCore::DocumentLoader::finishedLoading):
(WebCore::DocumentLoader::responseReceived):

  • loader/FrameLoader.cpp:

(WebCore::FrameLoader::tellClientAboutPastMemoryCacheLoads):

  • loader/SubresourceLoader.cpp:

(WebCore::SubresourceLoader::willSendRequest):
(WebCore::SubresourceLoader::didReceiveResponse):
(WebCore::SubresourceLoader::didFail):
(WebCore::SubresourceLoader::willCancel):

  • loader/archive/cf/LegacyWebArchive.cpp:

(WebCore::LegacyWebArchive::create):

  • loader/cache/CachedImage.cpp:

(WebCore::CachedImage::addIncrementalDataBuffer):
(WebCore::CachedImage::finishLoading):

  • loader/cache/CachedResource.cpp:

(WebCore::deadDecodedDataDeletionIntervalForResourceType):
(WebCore::CachedResource::~CachedResource):
(WebCore::CachedResource::failBeforeStarting):
(WebCore::CachedResource::addClientToSet):
(WebCore::CachedResource::removeClient):
(WebCore::CachedResource::destroyDecodedDataIfNeeded):
(WebCore::CachedResource::setDecodedSize):
(WebCore::CachedResource::setEncodedSize):
(WebCore::CachedResource::didAccessDecodedData):

  • loader/cache/CachedResourceLoader.cpp:

(WebCore::CachedResourceLoader::requestUserCSSStyleSheet):
(WebCore::CachedResourceLoader::requestResource):
(WebCore::CachedResourceLoader::revalidateResource):
(WebCore::CachedResourceLoader::loadResource):
(WebCore::CachedResourceLoader::clearPreloads):
(WebCore::CachedResourceLoader::printPreloadStats):

  • loader/cache/MemoryCache.cpp:

(WebCore::memoryCache):
(WebCore::MemoryCache::removeRequestFromCache):
(WebCore::MemoryCache::removeRequestFromSessionCaches):

  • loader/cache/MemoryCache.h:
  • loader/cocoa/DiskCacheMonitorCocoa.mm:

(WebCore::DiskCacheMonitor::resourceBecameFileBacked):

  • page/FrameView.cpp:

(WebCore::FrameView::willPaintContents):
(WebCore::FrameView::didPaintContents):

  • platform/MemoryPressureHandler.cpp:

(WebCore::MemoryPressureHandler::releaseCriticalMemory):

  • testing/Internals.cpp:

(WebCore::Internals::isLoadingFromMemoryCache):

Source/WebKit/mac:

  • Misc/WebCache.mm:

(+[WebCache statistics]):
(+[WebCache emptyInMemoryResources]):
(+[WebCache sizeOfDeadResources:]):
(+[WebCache addImageToCache:forURL:forFrame:]):
(+[WebCache removeImageFromCacheForURL:forFrame:]):
(+[WebCache imageForURL:]):
(+[WebCache setDisabled:]):
(+[WebCache isDisabled]):

  • WebView/WebView.mm:

(+[WebView _setCacheModel:]):

Source/WebKit/win:

  • WebCache.cpp:

(WebCache::statistics):
(WebCache::empty):
(WebCache::setDisabled):
(WebCache::disabled):

  • WebView.cpp:

(WebView::setCacheModel):

Source/WebKit2:

  • WebProcess/Network/NetworkProcessConnection.cpp:

(WebKit::NetworkProcessConnection::didCacheResource):

  • WebProcess/ResourceCache/WebResourceCacheManager.cpp:

(WebKit::WebResourceCacheManager::getCacheOrigins):
(WebKit::WebResourceCacheManager::clearCacheForOrigin):

  • WebProcess/WebProcess.cpp:

(WebKit::WebProcess::terminate):
(WebKit::WebProcess::didClose):
(WebKit::WebProcess::clearResourceCaches):
(WebKit::getWebCoreMemoryCacheStatistics):
(WebKit::WebProcess::setMemoryCacheDisabled):

  • WebProcess/cocoa/WebProcessCocoa.mm:

(WebKit::WebProcess::platformSetCacheModel):

  • WebProcess/soup/WebProcessSoup.cpp:

(WebKit::WebProcess::platformSetCacheModel):

Location:
trunk/Source
Files:
28 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r176448 r176450  
     12014-11-21  Anders Carlsson  <andersca@apple.com>
     2
     3        Make memoryCache() return a reference
     4        https://bugs.webkit.org/show_bug.cgi?id=138939
     5
     6        Reviewed by Antti Koivisto.
     7
     8        * inspector/InspectorPageAgent.cpp:
     9        (WebCore::InspectorPageAgent::cachedResource):
     10        * inspector/InspectorResourceAgent.cpp:
     11        (WebCore::InspectorResourceAgent::replayXHR):
     12        (WebCore::InspectorResourceAgent::setCacheDisabled):
     13        (WebCore::InspectorResourceAgent::mainFrameNavigated):
     14        * loader/DocumentLoader.cpp:
     15        (WebCore::areAllLoadersPageCacheAcceptable):
     16        (WebCore::DocumentLoader::finishedLoading):
     17        (WebCore::DocumentLoader::responseReceived):
     18        * loader/FrameLoader.cpp:
     19        (WebCore::FrameLoader::tellClientAboutPastMemoryCacheLoads):
     20        * loader/SubresourceLoader.cpp:
     21        (WebCore::SubresourceLoader::willSendRequest):
     22        (WebCore::SubresourceLoader::didReceiveResponse):
     23        (WebCore::SubresourceLoader::didFail):
     24        (WebCore::SubresourceLoader::willCancel):
     25        * loader/archive/cf/LegacyWebArchive.cpp:
     26        (WebCore::LegacyWebArchive::create):
     27        * loader/cache/CachedImage.cpp:
     28        (WebCore::CachedImage::addIncrementalDataBuffer):
     29        (WebCore::CachedImage::finishLoading):
     30        * loader/cache/CachedResource.cpp:
     31        (WebCore::deadDecodedDataDeletionIntervalForResourceType):
     32        (WebCore::CachedResource::~CachedResource):
     33        (WebCore::CachedResource::failBeforeStarting):
     34        (WebCore::CachedResource::addClientToSet):
     35        (WebCore::CachedResource::removeClient):
     36        (WebCore::CachedResource::destroyDecodedDataIfNeeded):
     37        (WebCore::CachedResource::setDecodedSize):
     38        (WebCore::CachedResource::setEncodedSize):
     39        (WebCore::CachedResource::didAccessDecodedData):
     40        * loader/cache/CachedResourceLoader.cpp:
     41        (WebCore::CachedResourceLoader::requestUserCSSStyleSheet):
     42        (WebCore::CachedResourceLoader::requestResource):
     43        (WebCore::CachedResourceLoader::revalidateResource):
     44        (WebCore::CachedResourceLoader::loadResource):
     45        (WebCore::CachedResourceLoader::clearPreloads):
     46        (WebCore::CachedResourceLoader::printPreloadStats):
     47        * loader/cache/MemoryCache.cpp:
     48        (WebCore::memoryCache):
     49        (WebCore::MemoryCache::removeRequestFromCache):
     50        (WebCore::MemoryCache::removeRequestFromSessionCaches):
     51        * loader/cache/MemoryCache.h:
     52        * loader/cocoa/DiskCacheMonitorCocoa.mm:
     53        (WebCore::DiskCacheMonitor::resourceBecameFileBacked):
     54        * page/FrameView.cpp:
     55        (WebCore::FrameView::willPaintContents):
     56        (WebCore::FrameView::didPaintContents):
     57        * platform/MemoryPressureHandler.cpp:
     58        (WebCore::MemoryPressureHandler::releaseCriticalMemory):
     59        * testing/Internals.cpp:
     60        (WebCore::Internals::isLoadingFromMemoryCache):
     61
    1622014-11-21  Daniel Bates  <dabates@apple.com>
    263

  • trunk/Source/WebCore/inspector/InspectorPageAgent.cpp

    r176358 r176450  
    264264        request.setDomainForCachePartition(frame->document()->topOrigin()->domainForCachePartition());
    265265#endif
    266         cachedResource = memoryCache()->resourceForRequest(request, frame->page()->sessionID());
     266        cachedResource = memoryCache().resourceForRequest(request, frame->page()->sessionID());
    267267    }
    268268

  • trunk/Source/WebCore/inspector/InspectorResourceAgent.cpp

    r175549 r176450  
    708708#endif
    709709
    710     CachedResource* cachedResource = memoryCache()->resourceForRequest(request, m_pageAgent->page()->sessionID());
     710    CachedResource* cachedResource = memoryCache().resourceForRequest(request, m_pageAgent->page()->sessionID());
    711711    if (cachedResource)
    712         memoryCache()->remove(cachedResource);
     712        memoryCache().remove(cachedResource);
    713713
    714714    xhr->open(xhrReplayData->method(), xhrReplayData->url(), xhrReplayData->async(), IGNORE_EXCEPTION);
    … …  
    742742    m_cacheDisabled = cacheDisabled;
    743743    if (cacheDisabled)
    744         memoryCache()->evictResources();
     744        memoryCache().evictResources();
    745745}
    746746
    … …  
    790790{
    791791    if (m_cacheDisabled)
    792         memoryCache()->evictResources();
     792        memoryCache().evictResources();
    793793
    794794    m_resourcesData->clear(m_pageAgent->loaderId(loader));

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

    r175740 r176450  
    107107            return false;
    108108
    109         CachedResource* cachedResource = memoryCache()->resourceForURL(handle->firstRequest().url(), loader->frameLoader()->frame().page()->sessionID());
     109        CachedResource* cachedResource = memoryCache().resourceForURL(handle->firstRequest().url(), loader->frameLoader()->frame().page()->sessionID());
    110110        if (!cachedResource)
    111111            return false;
    … …  
    449449    if (m_frame) {
    450450        if (m_mainResource && m_frame->document()->hasManifest())
    451             memoryCache()->remove(m_mainResource.get());
     451            memoryCache().remove(m_mainResource.get());
    452452    }
    453453    m_applicationCacheHost->finishedLoadingMainResource();
    … …  
    600600    // from the application cache, ensure we don't save the result for future use.
    601601    if (willLoadFallback)
    602         memoryCache()->remove(m_mainResource.get());
     602        memoryCache().remove(m_mainResource.get());
    603603
    604604    if (willLoadFallback)

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

    r176096 r176450  
    33843384    size_t size = pastLoads.size();
    33853385    for (size_t i = 0; i < size; ++i) {
    3386         CachedResource* resource = memoryCache()->resourceForRequest(pastLoads[i], m_frame.page()->sessionID());
     3386        CachedResource* resource = memoryCache().resourceForRequest(pastLoads[i], m_frame.page()->sessionID());
    33873387
    33883388        // FIXME: These loads, loaded from cache, but now gone from the cache by the time

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

    r176172 r176450  
    157157        if (newRequest.isConditional() && m_resource->resourceToRevalidate() && newRequest.url() != m_resource->resourceToRevalidate()->response().url()) {
    158158            newRequest.makeUnconditional();
    159             memoryCache()->revalidationFailed(m_resource);
     159            memoryCache().revalidationFailed(m_resource);
    160160        }
    161161       
    … …  
    203203            // Existing resource is ok, just use it updating the expiration time.
    204204            m_resource->setResponse(response);
    205             memoryCache()->revalidationSucceeded(m_resource, response);
     205            memoryCache().revalidationSucceeded(m_resource, response);
    206206            if (!reachedTerminalState())
    207207                ResourceLoader::didReceiveResponse(response);
    … …  
    209209        }
    210210        // Did not get 304 response, continue as a regular resource load.
    211         memoryCache()->revalidationFailed(m_resource);
     211        memoryCache().revalidationFailed(m_resource);
    212212    }
    213213
    … …  
    329329    m_state = Finishing;
    330330    if (m_resource->resourceToRevalidate())
    331         memoryCache()->revalidationFailed(m_resource);
     331        memoryCache().revalidationFailed(m_resource);
    332332    m_resource->setResourceError(error);
    333333    if (!m_resource->isPreloaded())
    334         memoryCache()->remove(m_resource);
     334        memoryCache().remove(m_resource);
    335335    m_resource->error(CachedResource::LoadError);
    336336    cleanupForError(error);
    … …  
    362362#endif
    363363    if (m_resource->resourceToRevalidate())
    364         memoryCache()->revalidationFailed(m_resource);
     364        memoryCache().revalidationFailed(m_resource);
    365365    m_resource->setResourceError(error);
    366     memoryCache()->remove(m_resource);
     366    memoryCache().remove(m_resource);
    367367}
    368368

  • trunk/Source/WebCore/loader/archive/cf/LegacyWebArchive.cpp

    r176172 r176450  
    548548                request.setDomainForCachePartition(frame->document()->topOrigin()->domainForCachePartition());
    549549#endif
    550                 CachedResource* cachedResource = memoryCache()->resourceForRequest(request, frame->page()->sessionID());
     550                CachedResource* cachedResource = memoryCache().resourceForRequest(request, frame->page()->sessionID());
    551551                if (cachedResource) {
    552552                    if (RefPtr<ArchiveResource> resource = ArchiveResource::create(cachedResource->resourceBuffer(), subresourceURL, cachedResource->response())) {

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

    r175549 r176450  
    382382        error(errorOccurred() ? status() : DecodeError);
    383383        if (inCache())
    384             memoryCache()->remove(this);
     384            memoryCache().remove(this);
    385385        return;
    386386    }
    … …  
    423423        error(errorOccurred() ? status() : DecodeError);
    424424        if (inCache())
    425             memoryCache()->remove(this);
     425            memoryCache().remove(this);
    426426        return;
    427427    }

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

    r176276 r176450  
    104104        return std::chrono::milliseconds { 0 };
    105105
    106     return memoryCache()->deadDecodedDataDeletionInterval();
     106    return memoryCache().deadDecodedDataDeletionInterval();
    107107}
    108108
    … …  
    163163    ASSERT(!inCache());
    164164    ASSERT(!m_deleted);
    165     ASSERT(url().isNull() || memoryCache()->resourceForRequest(resourceRequest(), sessionID()) != this);
     165    ASSERT(url().isNull() || memoryCache().resourceForRequest(resourceRequest(), sessionID()) != this);
    166166
    167167#ifndef NDEBUG
    … …  
    179179    LOG(ResourceLoading, "Cannot start loading '%s'", url().string().latin1().data());
    180180    if (m_resourceToRevalidate)
    181         memoryCache()->revalidationFailed(this);
     181        memoryCache().revalidationFailed(this);
    182182    error(CachedResource::LoadError);
    183183}
    … …  
    416416    }
    417417    if (!hasClients() && inCache())
    418         memoryCache()->addToLiveResourcesSize(this);
     418        memoryCache().addToLiveResourcesSize(this);
    419419
    420420    if ((m_type == RawResource || m_type == MainResource) && !m_response.isNull() && !m_proxyResource) {
    … …  
    448448    if (!deleted && !hasClients()) {
    449449        if (inCache()) {
    450             memoryCache()->removeFromLiveResourcesSize(this);
    451             memoryCache()->removeFromLiveDecodedResourcesList(this);
     450            memoryCache().removeFromLiveResourcesSize(this);
     451            memoryCache().removeFromLiveDecodedResourcesList(this);
    452452        }
    453453        if (!m_switchingClientsToRevalidatedResource)
    … …  
    459459            // "... History buffers MAY store such responses as part of their normal operation."
    460460            // We allow non-secure content to be reused in history, but we do not allow secure content to be reused.
    461             memoryCache()->remove(this);
     461            memoryCache().remove(this);
    462462        }
    463         memoryCache()->prune();
     463        memoryCache().prune();
    464464    }
    465465    // This object may be dead here.
    … …  
    470470    if (!m_decodedSize)
    471471        return;
    472     if (!memoryCache()->deadDecodedDataDeletionInterval().count())
     472    if (!memoryCache().deadDecodedDataDeletionInterval().count())
    473473        return;
    474474    m_decodedDataDeletionTimer.restart();
    … …  
    500500    // Remove before updating m_decodedSize, so we find the resource in the correct LRU list.
    501501    if (inCache())
    502         memoryCache()->removeFromLRUList(this);
     502        memoryCache().removeFromLRUList(this);
    503503   
    504504    m_decodedSize = size;
    … …  
    506506    if (inCache()) {
    507507        // Now insert into the new LRU list.
    508         memoryCache()->insertInLRUList(this);
     508        memoryCache().insertInLRUList(this);
    509509       
    510510        // Insert into or remove from the live decoded list if necessary.
    … …  
    516516        // a problem. For more details please see: https://bugs.webkit.org/show_bug.cgi?id=30209
    517517        if (m_decodedSize && !m_inLiveDecodedResourcesList && hasClients())
    518             memoryCache()->insertInLiveDecodedResourcesList(this);
     518            memoryCache().insertInLiveDecodedResourcesList(this);
    519519        else if (!m_decodedSize && m_inLiveDecodedResourcesList)
    520             memoryCache()->removeFromLiveDecodedResourcesList(this);
     520            memoryCache().removeFromLiveDecodedResourcesList(this);
    521521
    522522        // Update the cache's size totals.
    523         memoryCache()->adjustSize(hasClients(), delta);
     523        memoryCache().adjustSize(hasClients(), delta);
    524524    }
    525525}
    … …  
    535535    // Remove before updating m_encodedSize, so we find the resource in the correct LRU list.
    536536    if (inCache())
    537         memoryCache()->removeFromLRUList(this);
     537        memoryCache().removeFromLRUList(this);
    538538
    539539    m_encodedSize = size;
    540540
    541541    if (inCache()) {
    542         memoryCache()->insertInLRUList(this);
    543         memoryCache()->adjustSize(hasClients(), delta);
     542        memoryCache().insertInLRUList(this);
     543        memoryCache().adjustSize(hasClients(), delta);
    544544    }
    545545}
    … …  
    551551    if (inCache()) {
    552552        if (m_inLiveDecodedResourcesList) {
    553             memoryCache()->removeFromLiveDecodedResourcesList(this);
    554             memoryCache()->insertInLiveDecodedResourcesList(this);
     553            memoryCache().removeFromLiveDecodedResourcesList(this);
     554            memoryCache().insertInLiveDecodedResourcesList(this);
    555555        }
    556         memoryCache()->prune();
     556        memoryCache().prune();
    557557    }
    558558}

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

    r176410 r176450  
    212212#endif
    213213
    214     if (CachedResource* existing = memoryCache()->resourceForRequest(request.resourceRequest(), sessionID())) {
     214    if (CachedResource* existing = memoryCache().resourceForRequest(request.resourceRequest(), sessionID())) {
    215215        if (is<CachedCSSStyleSheet>(*existing))
    216216            return downcast<CachedCSSStyleSheet>(existing);
    217         memoryCache()->remove(existing);
     217        memoryCache().remove(existing);
    218218    }
    219219    if (url.string() != request.resourceRequest().url())
    … …  
    222222    CachedResourceHandle<CachedCSSStyleSheet> userSheet = new CachedCSSStyleSheet(request.resourceRequest(), request.charset(), sessionID());
    223223
    224     memoryCache()->add(userSheet.get());
     224    memoryCache().add(userSheet.get());
    225225    // FIXME: loadResource calls setOwningCachedResourceLoader() if the resource couldn't be added to cache. Does this function need to call it, too?
    226226
    … …  
    456456        f->loader().client().dispatchWillRequestResource(&request);
    457457
    458     if (memoryCache()->disabled()) {
     458    if (memoryCache().disabled()) {
    459459        DocumentResourceMap::iterator it = m_documentResources.find(url.string());
    460460        if (it != m_documentResources.end()) {
    … …  
    471471#endif
    472472
    473     resource = memoryCache()->resourceForRequest(request.resourceRequest(), sessionID());
     473    resource = memoryCache().resourceForRequest(request.resourceRequest(), sessionID());
    474474
    475475    const RevalidationPolicy policy = determineRevalidationPolicy(type, request.mutableResourceRequest(), request.forPreload(), resource.get(), request.defer());
    476476    switch (policy) {
    477477    case Reload:
    478         memoryCache()->remove(resource.get());
     478        memoryCache().remove(resource.get());
    479479        FALLTHROUGH;
    480480    case Load:
    … …  
    487487        if (!shouldContinueAfterNotifyingLoadedFromMemoryCache(request, resource.get()))
    488488            return 0;
    489         memoryCache()->resourceAccessed(resource.get());
     489        memoryCache().resourceAccessed(resource.get());
    490490        break;
    491491    }
    … …  
    503503        if (resource->errorOccurred()) {
    504504            if (resource->inCache())
    505                 memoryCache()->remove(resource.get());
     505                memoryCache().remove(resource.get());
    506506            return 0;
    507507        }
    … …  
    525525    ASSERT(resource);
    526526    ASSERT(resource->inCache());
    527     ASSERT(!memoryCache()->disabled());
     527    ASSERT(!memoryCache().disabled());
    528528    ASSERT(resource->canUseCacheValidator());
    529529    ASSERT(!resource->resourceToRevalidate());
    … …  
    537537    newResource->setResourceToRevalidate(resource);
    538538   
    539     memoryCache()->remove(resource);
    540     memoryCache()->add(newResource.get());
     539    memoryCache().remove(resource);
     540    memoryCache().add(newResource.get());
    541541#if ENABLE(RESOURCE_TIMING)
    542542    storeResourceTimingInitiatorInformation(resource, request);
    … …  
    549549CachedResourceHandle<CachedResource> CachedResourceLoader::loadResource(CachedResource::Type type, CachedResourceRequest& request)
    550550{
    551     ASSERT(!memoryCache()->resourceForRequest(request.resourceRequest(), sessionID()));
     551    ASSERT(!memoryCache().resourceForRequest(request.resourceRequest(), sessionID()));
    552552
    553553    LOG(ResourceLoading, "Loading CachedResource for '%s'.", request.resourceRequest().url().stringCenterEllipsizedToLength().latin1().data());
    … …  
    555555    CachedResourceHandle<CachedResource> resource = createResource(type, request.mutableResourceRequest(), request.charset(), sessionID());
    556556
    557     if (!memoryCache()->add(resource.get()))
     557    if (!memoryCache().add(resource.get()))
    558558        resource->setOwningCachedResourceLoader(this);
    559559#if ENABLE(RESOURCE_TIMING)
    … …  
    942942        bool deleted = res->deleteIfPossible();
    943943        if (!deleted && res->preloadResult() == CachedResource::PreloadNotReferenced)
    944             memoryCache()->remove(res);
     944            memoryCache().remove(res);
    945945    }
    946946    m_preloads = nullptr;
    … …  
    986986       
    987987        if (res->errorOccurred())
    988             memoryCache()->remove(res);
     988            memoryCache().remove(res);
    989989       
    990990        res->decreasePreloadCount();

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

    r176276 r176450  
    5656static const auto defaultDecodedDataDeletionInterval = std::chrono::seconds { 0 };
    5757
    58 MemoryCache* memoryCache()
    59 {
    60     static MemoryCache* staticCache = new MemoryCache;
     58MemoryCache& memoryCache()
     59{
    6160    ASSERT(WTF::isMainThread());
    6261
    63     return staticCache;
     62    static NeverDestroyed<MemoryCache> memoryCache;
     63
     64    return memoryCache;
    6465}
    6566
    … …  
    767768    }
    768769
    769     if (CachedResource* resource = memoryCache()->resourceForRequest(request, sessionID))
    770         memoryCache()->remove(resource);
     770    if (CachedResource* resource = memoryCache().resourceForRequest(request, sessionID))
     771        memoryCache().remove(resource);
    771772}
    772773
    … …  
    783784    }
    784785
    785     for (auto& resources : memoryCache()->m_sessionResources) {
    786         if (CachedResource* resource = memoryCache()->resourceForRequestImpl(request, *resources.value))
    787         memoryCache()->remove(resource);
     786    for (auto& resources : memoryCache().m_sessionResources) {
     787        if (CachedResource* resource = memoryCache().resourceForRequestImpl(request, *resources.value))
     788        memoryCache().remove(resource);
    788789    }
    789790}

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

    r174921 r176450  
    2929#include "SecurityOriginHash.h"
    3030#include "SessionIDHash.h"
     31#include <wtf/Forward.h>
    3132#include <wtf/HashMap.h>
    3233#include <wtf/HashSet.h>
    … …  
    6566    WTF_MAKE_NONCOPYABLE(MemoryCache); WTF_MAKE_FAST_ALLOCATED;
    6667public:
    67     friend MemoryCache* memoryCache();
     68    friend NeverDestroyed<MemoryCache>;
    6869
    6970#if ENABLE(CACHE_PARTITIONING)
    … …  
    234235
    235236// Function to obtain the global cache.
    236 WEBCORE_EXPORT MemoryCache* memoryCache();
     237WEBCORE_EXPORT MemoryCache& memoryCache();
    237238
    238239}

  • trunk/Source/WebCore/loader/cocoa/DiskCacheMonitorCocoa.mm

    r176347 r176450  
    115115void DiskCacheMonitor::resourceBecameFileBacked(SharedBuffer& fileBackedBuffer)
    116116{
    117     CachedResource* resource = memoryCache()->resourceForRequest(m_resourceRequest, m_sessionID);
     117    CachedResource* resource = memoryCache().resourceForRequest(m_resourceRequest, m_sessionID);
    118118    if (!resource)
    119119        return;

  • trunk/Source/WebCore/page/FrameView.cpp

    r176384 r176450  
    37373737        // To avoid unnecessary image decoding, we don't prune recently-decoded live resources here since
    37383738        // we might need some live bitmaps on painting.
    3739         memoryCache()->prune();
     3739        memoryCache().prune();
    37403740    }
    37413741
    … …  
    37773777    // If we are low on memory, wipe them out after the paint.
    37783778    if (paintingState.isTopLevelPainter && memoryPressureHandler().isUnderMemoryPressure())
    3779         memoryCache()->pruneLiveResources(true);
     3779        memoryCache().pruneLiveResources(true);
    37803780
    37813781    // Regions may have changed as a result of the visibility/z-index of element changing.

  • trunk/Source/WebCore/platform/MemoryPressureHandler.cpp

    r173176 r176450  
    104104    {
    105105        ReliefLogger log("Prune MemoryCache");
    106         memoryCache()->pruneToPercentage(0);
     106        memoryCache().pruneToPercentage(0);
    107107    }
    108108

  • trunk/Source/WebCore/testing/Internals.cpp

    r176350 r176450  
    381381    if (!contextDocument() || !contextDocument()->page())
    382382        return false;
    383     CachedResource* resource = memoryCache()->resourceForURL(contextDocument()->completeURL(url), contextDocument()->page()->sessionID());
     383    CachedResource* resource = memoryCache().resourceForURL(contextDocument()->completeURL(url), contextDocument()->page()->sessionID());
    384384    return resource && resource->status() == CachedResource::Cached;
    385385}

  • trunk/Source/WebKit/mac/ChangeLog

    r176437 r176450  
     12014-11-21  Anders Carlsson  <andersca@apple.com>
     2
     3        Make memoryCache() return a reference
     4        https://bugs.webkit.org/show_bug.cgi?id=138939
     5
     6        Reviewed by Antti Koivisto.
     7
     8        * Misc/WebCache.mm:
     9        (+[WebCache statistics]):
     10        (+[WebCache emptyInMemoryResources]):
     11        (+[WebCache sizeOfDeadResources:]):
     12        (+[WebCache addImageToCache:forURL:forFrame:]):
     13        (+[WebCache removeImageFromCacheForURL:forFrame:]):
     14        (+[WebCache imageForURL:]):
     15        (+[WebCache setDisabled:]):
     16        (+[WebCache isDisabled]):
     17        * WebView/WebView.mm:
     18        (+[WebView _setCacheModel:]):
     19
    1202014-11-20  Benjamin Poulain  <bpoulain@apple.com>
    221

  • trunk/Source/WebKit/mac/Misc/WebCache.mm

    r174921 r176450  
    6666+ (NSArray *)statistics
    6767{
    68     WebCore::MemoryCache::Statistics s = WebCore::memoryCache()->getStatistics();
     68    WebCore::MemoryCache::Statistics s = WebCore::memoryCache().getStatistics();
    6969
    7070    return [NSArray arrayWithObjects:
    … …  
    141141        [WebView _setCacheModel:cacheModel];
    142142
    143         WebCore::memoryCache()->pruneLiveResources(true);
     143        WebCore::memoryCache().pruneLiveResources(true);
    144144    });
    145145}
    … …  
    147147+ (void)sizeOfDeadResources:(int *)resources
    148148{
    149     WebCore::MemoryCache::Statistics stats = WebCore::memoryCache()->getStatistics();
     149    WebCore::MemoryCache::Statistics stats = WebCore::memoryCache().getStatistics();
    150150    if (resources) {
    151151        *resources = (stats.images.size - stats.images.liveSize)
    … …  
    177177        topOrigin = core(frame)->document()->topOrigin();
    178178#endif
    179     return WebCore::memoryCache()->addImageToCache(image, url, topOrigin ? topOrigin->domainForCachePartition() : emptyString());
     179    return WebCore::memoryCache().addImageToCache(image, url, topOrigin ? topOrigin->domainForCachePartition() : emptyString());
    180180}
    181181
    … …  
    194194        topOrigin = core(frame)->document()->topOrigin();
    195195#endif
    196     WebCore::memoryCache()->removeImageFromCache(url, topOrigin ? topOrigin->domainForCachePartition() : emptyString());
     196    WebCore::memoryCache().removeImageFromCache(url, topOrigin ? topOrigin->domainForCachePartition() : emptyString());
    197197}
    198198
    … …  
    202202        return nullptr;
    203203   
    204     WebCore::CachedResource* cachedResource = WebCore::memoryCache()->resourceForURL(url);
     204    WebCore::CachedResource* cachedResource = WebCore::memoryCache().resourceForURL(url);
    205205    if (!is<WebCore::CachedImage>(cachedResource))
    206206        return nullptr;
    … …  
    218218        return [[self _webkit_invokeOnMainThread] setDisabled:disabled];
    219219
    220     WebCore::memoryCache()->setDisabled(disabled);
     220    WebCore::memoryCache().setDisabled(disabled);
    221221}
    222222
    223223+ (BOOL)isDisabled
    224224{
    225     return WebCore::memoryCache()->disabled();
     225    return WebCore::memoryCache().disabled();
    226226}
    227227

  • trunk/Source/WebKit/mac/WebView/WebView.mm

    r176347 r176450  
    79017901    nsurlCacheDiskCapacity = std::max(nsurlCacheDiskCapacity, [nsurlCache diskCapacity]);
    79027902
    7903     memoryCache()->setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
    7904     memoryCache()->setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
     7903    memoryCache().setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
     7904    memoryCache().setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
    79057905    pageCache()->setCapacity(pageCacheCapacity);
    79067906#if PLATFORM(IOS)

  • trunk/Source/WebKit/win/ChangeLog

    r176173 r176450  
     12014-11-21  Anders Carlsson  <andersca@apple.com>
     2
     3        Make memoryCache() return a reference
     4        https://bugs.webkit.org/show_bug.cgi?id=138939
     5
     6        Reviewed by Antti Koivisto.
     7
     8        * WebCache.cpp:
     9        (WebCache::statistics):
     10        (WebCache::empty):
     11        (WebCache::setDisabled):
     12        (WebCache::disabled):
     13        * WebView.cpp:
     14        (WebView::setCacheModel):
     15
    1162014-11-16  Zan Dobersek  <zdobersek@igalia.com>
    217

  • trunk/Source/WebKit/win/WebCache.cpp

    r173988 r176450  
    101101        return S_OK;
    102102
    103     WebCore::MemoryCache::Statistics stat = WebCore::memoryCache()->getStatistics();
     103    WebCore::MemoryCache::Statistics stat = WebCore::memoryCache().getStatistics();
    104104
    105105    static CFStringRef imagesKey = CFSTR("images");
    … …  
    208208HRESULT STDMETHODCALLTYPE WebCache::empty( void)
    209209{
    210     if (WebCore::memoryCache()->disabled())
     210    if (WebCore::memoryCache().disabled())
    211211        return S_OK;
    212     WebCore::memoryCache()->setDisabled(true);
    213     WebCore::memoryCache()->setDisabled(false);
     212    WebCore::memoryCache().setDisabled(true);
     213    WebCore::memoryCache().setDisabled(false);
    214214
    215215    // Empty the application cache.
    … …  
    225225    /* [in] */ BOOL disabled)
    226226{
    227     WebCore::memoryCache()->setDisabled(!!disabled);
     227    WebCore::memoryCache().setDisabled(!!disabled);
    228228    return S_OK;
    229229}
    … …  
    234234    if (!disabled)
    235235        return E_POINTER;
    236     *disabled = WebCore::memoryCache()->disabled();
     236    *disabled = WebCore::memoryCache().disabled();
    237237    return S_OK;
    238238}

  • trunk/Source/WebKit/win/WebView.cpp

    r176065 r176450  
    672672    }
    673673
    674     memoryCache()->setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
    675     memoryCache()->setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
     674    memoryCache().setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
     675    memoryCache().setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
    676676    pageCache()->setCapacity(pageCacheCapacity);
    677677

  • trunk/Source/WebKit2/ChangeLog

    r176448 r176450  
     12014-11-21  Anders Carlsson  <andersca@apple.com>
     2
     3        Make memoryCache() return a reference
     4        https://bugs.webkit.org/show_bug.cgi?id=138939
     5
     6        Reviewed by Antti Koivisto.
     7
     8        * WebProcess/Network/NetworkProcessConnection.cpp:
     9        (WebKit::NetworkProcessConnection::didCacheResource):
     10        * WebProcess/ResourceCache/WebResourceCacheManager.cpp:
     11        (WebKit::WebResourceCacheManager::getCacheOrigins):
     12        (WebKit::WebResourceCacheManager::clearCacheForOrigin):
     13        * WebProcess/WebProcess.cpp:
     14        (WebKit::WebProcess::terminate):
     15        (WebKit::WebProcess::didClose):
     16        (WebKit::WebProcess::clearResourceCaches):
     17        (WebKit::getWebCoreMemoryCacheStatistics):
     18        (WebKit::WebProcess::setMemoryCacheDisabled):
     19        * WebProcess/cocoa/WebProcessCocoa.mm:
     20        (WebKit::WebProcess::platformSetCacheModel):
     21        * WebProcess/soup/WebProcessSoup.cpp:
     22        (WebKit::WebProcess::platformSetCacheModel):
     23
    1242014-11-21  Daniel Bates  <dabates@apple.com>
    225

  • trunk/Source/WebKit2/WebProcess/Network/NetworkProcessConnection.cpp

    r175549 r176450  
    8484void NetworkProcessConnection::didCacheResource(const ResourceRequest& request, const ShareableResource::Handle& handle, SessionID sessionID)
    8585{
    86     CachedResource* resource = memoryCache()->resourceForRequest(request, sessionID);
     86    CachedResource* resource = memoryCache().resourceForRequest(request, sessionID);
    8787    if (!resource)
    8888        return;

  • trunk/Source/WebKit2/WebProcess/ResourceCache/WebResourceCacheManager.cpp

    r160464 r176450  
    5858    MemoryCache::SecurityOriginSet origins;
    5959#endif
    60     memoryCache()->getOriginsWithCache(origins);
     60    memoryCache().getOriginsWithCache(origins);
    6161
    6262#if USE(CFURLCACHE)
    … …  
    115115        return;
    116116
    117     memoryCache()->removeResourcesWithOrigin(origin.get());
     117    memoryCache().removeResourcesWithOrigin(origin.get());
    118118
    119119#if USE(CFURLCACHE)

  • trunk/Source/WebKit2/WebProcess/WebProcess.cpp

    r176421 r176450  
    586586    gcController().garbageCollectNow();
    587587    fontCache().invalidate();
    588     memoryCache()->setDisabled(true);
     588    memoryCache().setDisabled(true);
    589589#endif
    590590
    … …  
    639639    gcController().garbageCollectSoon();
    640640    fontCache().invalidate();
    641     memoryCache()->setDisabled(true);
     641    memoryCache().setDisabled(true);
    642642#endif   
    643643
    … …  
    711711    setCacheModel(cacheModel);
    712712
    713     memoryCache()->evictResources();
     713    memoryCache().evictResources();
    714714
    715715    // Empty the cross-origin preflight cache.
    … …  
    867867    String javaScriptString(ASCIILiteral("JavaScript"));
    868868   
    869     MemoryCache::Statistics memoryCacheStatistics = memoryCache()->getStatistics();
     869    MemoryCache::Statistics memoryCacheStatistics = memoryCache().getStatistics();
    870870   
    871871    HashMap<String, uint64_t> counts;
    … …  
    12491249void WebProcess::setMemoryCacheDisabled(bool disabled)
    12501250{
    1251     if (memoryCache()->disabled() != disabled)
    1252         memoryCache()->setDisabled(disabled);
     1251    if (memoryCache().disabled() != disabled)
     1252        memoryCache().setDisabled(disabled);
    12531253}
    12541254

  • trunk/Source/WebKit2/WebProcess/cocoa/WebProcessCocoa.mm

    r176347 r176450  
    110110
    111111
    112     memoryCache()->setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
    113     memoryCache()->setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
     112    memoryCache().setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
     113    memoryCache().setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
    114114    pageCache()->setCapacity(pageCacheCapacity);
    115115

  • trunk/Source/WebKit2/WebProcess/soup/WebProcessSoup.cpp

    r174639 r176450  
    102102                        pageCacheCapacity, urlCacheMemoryCapacity, urlCacheDiskCapacity);
    103103
    104     WebCore::memoryCache()->setDisabled(cacheModel == CacheModelDocumentViewer);
    105     WebCore::memoryCache()->setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
    106     WebCore::memoryCache()->setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
     104    WebCore::memoryCache().setDisabled(cacheModel == CacheModelDocumentViewer);
     105    WebCore::memoryCache().setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
     106    WebCore::memoryCache().setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
    107107    WebCore::pageCache()->setCapacity(pageCacheCapacity);
    108108
Note: See TracChangeset for help on using the changeset viewer.