Changeset 179347 in webkit

Timestamp:

Jan 29, 2015 10:38:51 AM (9 years ago)

Author:

Chris Dumez

Message:

Clean up / modernize PageCache class
​https://bugs.webkit.org/show_bug.cgi?id=141009

Reviewed by Darin Adler.

Source/WebCore:

Clean up / modernize PageCache class:

• Use more references instead of pointers
• Use a ListHashSet<Ref<HistoryItem>> internally instead of a linked list of HistoryItem*. This avoids having the ref/unref HistoryItems manually and maintaining the list size separately. It also simplifies the code dealing with the container and makes looking up HistoryItems faster as a bonus. Similarly to the previous implementation, we are adding elements to one end and removing from the opposite end when pruning to drop old history items first. Note that even though the previous implementation was called LRUList, it did not move items to the front when accessed. The new implementation doesn't either.
  • Rename "capacity" to "maxSize" to avoid confusing with containers' capacity (which doesn't limit the size of the container).
  • Use unsigned instead of int for all values that are supposed to be positive.
  • Do not explicitely define the default constructor and let the compiler generate it for us (and use in-class initialization for members)
  • Fix indentation in the header.

Source/WebKit/mac:

Clean up / modernize PageCache class.

• History/WebBackForwardList.mm:

(-[WebBackForwardList pageCacheSize]):

• WebView/WebView.mm:

(-[WebView _loadBackForwardListFromOtherView:]):
(-[WebView goToBackForwardItem:]):
(+[WebView _setCacheModel:]):

Source/WebKit/win:

Clean up / modernize PageCache class.

• WebView.cpp:

(WebView::setCacheModel):

Source/WebKit2:

Clean up / modernize PageCache class.

• WebProcess/WebPage/WebBackForwardListProxy.cpp:

(WebKit::WebBackForwardListProxy::removeItem):
(WebKit::WebBackForwardListProxy::close):

• WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::goForward):
(WebKit::WebPage::goBack):
(WebKit::WebPage::goToBackForwardItem):

• WebProcess/WebProcess.cpp:

(WebKit::WebProcess::releasePageCache):

• WebProcess/cocoa/WebProcessCocoa.mm:

(WebKit::WebProcess::platformSetCacheModel):

• WebProcess/soup/WebProcessSoup.cpp:

(WebKit::WebProcess::platformSetCacheModel):

Location:

trunk/Source

Files:

• WebCore/ChangeLog (modified) (1 diff)
• WebCore/WebCore.exp.in (modified) (2 diffs)
• WebCore/history/BackForwardController.cpp (modified) (3 diffs)
• WebCore/history/BackForwardList.cpp (modified) (5 diffs)
• WebCore/history/HistoryItem.cpp (modified) (1 diff)
• WebCore/history/PageCache.cpp (modified) (13 diffs)
• WebCore/history/PageCache.h (modified) (2 diffs)
• WebCore/loader/FrameLoader.cpp (modified) (11 diffs)
• WebCore/loader/FrameLoader.h (modified) (2 diffs)
• WebCore/loader/HistoryController.cpp (modified) (13 diffs)
• WebCore/loader/HistoryController.h (modified) (2 diffs)
• WebCore/page/DiagnosticLoggingKeys.cpp (modified) (1 diff)
• WebCore/page/DiagnosticLoggingKeys.h (modified) (1 diff)
• WebCore/page/Frame.cpp (modified) (1 diff)
• WebCore/page/Page.cpp (modified) (4 diffs)
• WebCore/page/Page.h (modified) (1 diff)
• WebCore/page/Settings.cpp (modified) (1 diff)
• WebCore/platform/MemoryPressureHandler.cpp (modified) (1 diff)
• WebKit/mac/ChangeLog (modified) (1 diff)
• WebKit/mac/History/WebBackForwardList.mm (modified) (1 diff)
• WebKit/mac/WebView/WebView.mm (modified) (9 diffs)
• WebKit/win/ChangeLog (modified) (1 diff)
• WebKit/win/WebView.cpp (modified) (7 diffs)
• WebKit2/ChangeLog (modified) (1 diff)
• WebKit2/WebProcess/WebPage/WebBackForwardListProxy.cpp (modified) (2 diffs)
• WebKit2/WebProcess/WebPage/WebPage.cpp (modified) (3 diffs)
• WebKit2/WebProcess/WebProcess.cpp (modified) (1 diff)
• WebKit2/WebProcess/cocoa/WebProcessCocoa.mm (modified) (2 diffs)
• WebKit2/WebProcess/soup/WebProcessSoup.cpp (modified) (2 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2015-01-29  Chris Dumez  <cdumez@apple.com>
+
+        Clean up / modernize PageCache class
+        https://bugs.webkit.org/show_bug.cgi?id=141009
+
+        Reviewed by Darin Adler.
+
+        Clean up / modernize PageCache class:
+        - Use more references instead of pointers
+        - Use a ListHashSet<Ref<HistoryItem>> internally instead of a linked
+          list of HistoryItem*. This avoids having the ref/unref HistoryItems
+          manually and maintaining the list size separately. It also simplifies
+          the code dealing with the container and makes looking up HistoryItems
+          faster as a bonus. Similarly to the previous implementation, we are
+          adding elements to one end and removing from the opposite end when
+          pruning to drop old history items first. Note that even though the
+          previous implementation was called LRUList, it did not move items to
+          the front when accessed. The new implementation doesn't either.
+         - Rename "capacity" to "maxSize" to avoid confusing with containers'
+           capacity (which doesn't limit the size of the container).
+         - Use unsigned instead of int for all values that are supposed to be
+           positive.
+         - Do not explicitely define the default constructor and let the
+           compiler generate it for us (and use in-class initialization for
+           members)
+         - Fix indentation in the header.
+
 2015-01-29  Julien Isorce  <j.isorce@samsung.com>
 

trunk/Source/WebCore/WebCore.exp.in

@@ -1240 +1240 @@
 __ZN7WebCore4Page36suspendActiveDOMObjectsAndAnimationsEv
 __ZN7WebCore4Page37setInLowQualityImageInterpolationModeEb
-__ZN7WebCore4Page8goToItemEPNS_11HistoryItemENS_13FrameLoadTypeE
+__ZN7WebCore4Page8goToItemERNS_11HistoryItemENS_13FrameLoadTypeE
 __ZN7WebCore4Page8setMutedEb
 __ZN7WebCore4Page9initGroupEv
@@ -1607 +1607 @@
 __ZN7WebCore9LayerPoolC1Ev
 __ZN7WebCore9LayerPoolD1Ev
-__ZN7WebCore9PageCache11setCapacityEi
-__ZN7WebCore9PageCache18pruneToCapacityNowEiNS_13PruningReasonE
+__ZN7WebCore9PageCache10setMaxSizeEj
+__ZN7WebCore9PageCache14pruneToSizeNowEjNS_13PruningReasonE
 __ZN7WebCore9PageCache34markPagesForVisitedLinkStyleRecalcEv
-__ZN7WebCore9PageCache6removeEPNS_11HistoryItemE
+__ZN7WebCore9PageCache6removeERNS_11HistoryItemE
 __ZN7WebCore9PageCache6sharedEv
 __ZN7WebCore9PageGroup9pageGroupERKN3WTF6StringE

trunk/Source/WebCore/history/BackForwardController.cpp

@@ -75 +75 @@
         return;
 
-    m_page.goToItem(item, FrameLoadType::IndexedBackForward);
+    m_page.goToItem(*item, FrameLoadType::IndexedBackForward);
 }
 
@@ -84 +84 @@
         return false;
 
-    m_page.goToItem(item, FrameLoadType::Back);
+    m_page.goToItem(*item, FrameLoadType::Back);
     return true;
 }
@@ -94 +94 @@
         return false;
 
-    m_page.goToItem(item, FrameLoadType::Forward);
+    m_page.goToItem(*item, FrameLoadType::Forward);
     return true;
 }

trunk/Source/WebCore/history/BackForwardList.cpp

@@ -69 +69 @@
             m_entries.removeLast();
             m_entryHash.remove(item);
-            PageCache::shared().remove(item.get());
+            PageCache::shared().remove(*item);
         }
     }
@@ -79 +79 @@
         m_entries.remove(0);
         m_entryHash.remove(item);
-        PageCache::shared().remove(item.get());
+        PageCache::shared().remove(*item);
         m_current--;
     }
@@ -176 +176 @@
         m_entries.removeLast();
         m_entryHash.remove(item);
-        PageCache::shared().remove(item.get());
+        PageCache::shared().remove(*item);
     }
 
@@ -243 +243 @@
 {
     bool didRemoveAtLeastOneItem = false;
-    unsigned length = m_entries.size();
-    for (unsigned i = 0; i < length; ++i) {
-        HistoryItem* item = m_entries[i].get();
+    for (auto& item : m_entries) {
         if (item->isInPageCache()) {
             didRemoveAtLeastOneItem = true;
-            PageCache::shared().remove(item);
+            PageCache::shared().remove(*item);
         }
     }
@@ -257 +255 @@
 void BackForwardList::close()
 {
-    int size = m_entries.size();
-    for (int i = 0; i < size; ++i)
-        PageCache::shared().remove(m_entries[i].get());
+    for (auto& item : m_entries)
+        PageCache::shared().remove(*item);
     m_entries.clear();
     m_entryHash.clear();
-    m_page = 0;
+    m_page = nullptr;
     m_closed = true;
 }

trunk/Source/WebCore/history/HistoryItem.cpp

@@ -287 +287 @@
 void HistoryItem::setURL(const URL& url)
 {
-    PageCache::shared().remove(this);
+    PageCache::shared().remove(*this);
     setURLString(url.string());
     clearDocumentState();

trunk/Source/WebCore/history/PageCache.cpp

@@ -1 +1 @@
 /*
- * Copyright (C) 2007, 2014 Apple Inc.  All rights reserved.
+ * Copyright (C) 2007, 2014, 2015 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -44 +44 @@
 #include "FrameView.h"
 #include "HistoryController.h"
-#include "HistoryItem.h"
 #include "Logging.h"
 #include "MainFrame.h"
@@ -111 +110 @@
 }
 
-static unsigned logCanCacheFrameDecision(Frame& frame, DiagnosticLoggingClient& diagnosticLoggingClient, int indentLevel)
+static unsigned logCanCacheFrameDecision(Frame& frame, DiagnosticLoggingClient& diagnosticLoggingClient, unsigned indentLevel)
 {
     PCLOG("+---");
@@ -235 +234 @@
         return;
     
-    int indentLevel = 0;    
+    unsigned indentLevel = 0;
     PCLOG("--------\n Determining if page can be cached:");
     
@@ -298 +297 @@
     return globalPageCache;
 }
-
-PageCache::PageCache()
-    : m_capacity(0)
-    , m_size(0)
-    , m_head(0)
-    , m_tail(0)
-    , m_shouldClearBackingStores(false)
-{
-}
-    
-bool PageCache::canCachePageContainingThisFrame(Frame* frame)
-{
-    for (Frame* child = frame->tree().firstChild(); child; child = child->tree().nextSibling()) {
-        if (!canCachePageContainingThisFrame(child))
+    
+bool PageCache::canCachePageContainingThisFrame(Frame& frame)
+{
+    for (Frame* child = frame.tree().firstChild(); child; child = child->tree().nextSibling()) {
+        if (!canCachePageContainingThisFrame(*child))
             return false;
     }
     
-    FrameLoader& frameLoader = frame->loader();
+    FrameLoader& frameLoader = frame.loader();
     DocumentLoader* documentLoader = frameLoader.documentLoader();
-    Document* document = frame->document();
+    Document* document = frame.document();
     
     return documentLoader
@@ -327 +317 @@
         // Do not cache error pages (these can be recognized as pages with substitute data or unreachable URLs).
         && !(documentLoader->substituteData().isValid() && !documentLoader->substituteData().failingURL().isEmpty())
-        && (!frameLoader.subframeLoader().containsPlugins() || frame->page()->settings().pageCacheSupportsPlugins())
-        && !(frame->isMainFrame() && document->url().protocolIs("https") && documentLoader->response().cacheControlContainsNoStore())
+        && (!frameLoader.subframeLoader().containsPlugins() || frame.page()->settings().pageCacheSupportsPlugins())
+        && !(frame.isMainFrame() && document->url().protocolIs("https") && documentLoader->response().cacheControlContainsNoStore())
         && !DatabaseManager::manager().hasOpenDatabases(document)
         && frameLoader.history().currentItem()
@@ -358 +348 @@
     FrameLoadType loadType = page->mainFrame().loader().loadType();
     
-    return m_capacity > 0
-        && canCachePageContainingThisFrame(&page->mainFrame())
+    return m_maxSize > 0
+        && canCachePageContainingThisFrame(page->mainFrame())
         && page->settings().usesPageCache()
 #if ENABLE(DEVICE_ORIENTATION) && !PLATFORM(IOS)
@@ -374 +364 @@
 }
 
-void PageCache::pruneToCapacityNow(int capacity, PruningReason pruningReason)
-{
-    TemporaryChange<int>(m_capacity, std::max(capacity, 0));
+void PageCache::pruneToSizeNow(unsigned size, PruningReason pruningReason)
+{
+    TemporaryChange<unsigned>(m_maxSize, size);
     prune(pruningReason);
 }
 
-void PageCache::setCapacity(int capacity)
-{
-    ASSERT(capacity >= 0);
-    m_capacity = std::max(capacity, 0);
-
+void PageCache::setMaxSize(unsigned maxSize)
+{
+    m_maxSize = maxSize;
     prune(PruningReason::None);
 }
 
-int PageCache::frameCount() const
-{
-    int frameCount = 0;
-    for (HistoryItem* current = m_head; current; current = current->m_next) {
-        ++frameCount;
-        ASSERT(current->m_cachedPage);
-        frameCount += current->m_cachedPage->cachedMainFrame()->descendantFrameCount();
+unsigned PageCache::frameCount() const
+{
+    unsigned frameCount = m_items.size();
+    for (auto& item : m_items) {
+        ASSERT(item->m_cachedPage);
+        frameCount += item->m_cachedPage->cachedMainFrame()->descendantFrameCount();
     }
     
@@ -402 +389 @@
 void PageCache::markPagesForVisitedLinkStyleRecalc()
 {
-    for (HistoryItem* current = m_head; current; current = current->m_next) {
-        ASSERT(current->m_cachedPage);
-        current->m_cachedPage->markForVisitedLinkStyleRecalc();
-    }
-}
-
-void PageCache::markPagesForFullStyleRecalc(Page* page)
-{
-    for (HistoryItem* current = m_head; current; current = current->m_next) {
-        CachedPage& cachedPage = *current->m_cachedPage;
-        if (&page->mainFrame() == &cachedPage.cachedMainFrame()->view()->frame())
+    for (auto& item : m_items) {
+        ASSERT(item->m_cachedPage);
+        item->m_cachedPage->markForVisitedLinkStyleRecalc();
+    }
+}
+
+void PageCache::markPagesForFullStyleRecalc(Page& page)
+{
+    for (auto& item : m_items) {
+        CachedPage& cachedPage = *item->m_cachedPage;
+        if (&page.mainFrame() == &cachedPage.cachedMainFrame()->view()->frame())
             cachedPage.markForFullStyleRecalc();
     }
 }
 
-void PageCache::markPagesForDeviceScaleChanged(Page* page)
-{
-    for (HistoryItem* current = m_head; current; current = current->m_next) {
-        CachedPage& cachedPage = *current->m_cachedPage;
-        if (&page->mainFrame() == &cachedPage.cachedMainFrame()->view()->frame())
+void PageCache::markPagesForDeviceScaleChanged(Page& page)
+{
+    for (auto& item : m_items) {
+        CachedPage& cachedPage = *item->m_cachedPage;
+        if (&page.mainFrame() == &cachedPage.cachedMainFrame()->view()->frame())
             cachedPage.markForDeviceScaleChanged();
     }
@@ -429 +416 @@
 void PageCache::markPagesForCaptionPreferencesChanged()
 {
-    for (HistoryItem* current = m_head; current; current = current->m_next) {
-        ASSERT(current->m_cachedPage);
-        current->m_cachedPage->markForCaptionPreferencesChanged();
+    for (auto& item : m_items) {
+        ASSERT(item->m_cachedPage);
+        item->m_cachedPage->markForCaptionPreferencesChanged();
     }
 }
@@ -443 +430 @@
     case PruningReason::ProcessSuspended:
         return DiagnosticLoggingKeys::prunedDueToProcessSuspended();
-    case PruningReason::ReachedCapacity:
-        return DiagnosticLoggingKeys::prunedDueToCapacityReached();
+    case PruningReason::ReachedMaxSize:
+        return DiagnosticLoggingKeys::prunedDueToMaxSizeReached();
     case PruningReason::None:
         break;
@@ -452 +439 @@
 }
 
-void PageCache::add(PassRefPtr<HistoryItem> prpItem, Page& page)
-{
-    ASSERT(prpItem);
+void PageCache::add(HistoryItem& item, Page& page)
+{
     ASSERT(canCache(&page));
-    
-    HistoryItem* item = prpItem.leakRef(); // Balanced in remove().
 
     // Remove stale cache entry if necessary.
-    if (item->m_cachedPage)
-        remove(item);
-
-    item->m_cachedPage = std::make_unique<CachedPage>(page);
-    item->m_pruningReason = PruningReason::None;
-    addToLRUList(item);
-    ++m_size;
-    
-    prune(PruningReason::ReachedCapacity);
-}
-
-std::unique_ptr<CachedPage> PageCache::take(HistoryItem* item, Page* page)
-{
-    if (!item)
+    remove(item);
+
+    item.m_cachedPage = std::make_unique<CachedPage>(page);
+    item.m_pruningReason = PruningReason::None;
+    m_items.add(&item);
+    
+    prune(PruningReason::ReachedMaxSize);
+}
+
+std::unique_ptr<CachedPage> PageCache::take(HistoryItem& item, Page* page)
+{
+    if (!item.m_cachedPage) {
+        if (item.m_pruningReason != PruningReason::None)
+            logPageCacheFailureDiagnosticMessage(page, pruningReasonToDiagnosticLoggingKey(item.m_pruningReason));
         return nullptr;
-
-    std::unique_ptr<CachedPage> cachedPage = WTF::move(item->m_cachedPage);
-
-    removeFromLRUList(item);
-    --m_size;
-
-    item->deref(); // Balanced in add().
-
-    if (!cachedPage) {
-        if (item->m_pruningReason != PruningReason::None)
-            logPageCacheFailureDiagnosticMessage(page, pruningReasonToDiagnosticLoggingKey(item->m_pruningReason));
-        return nullptr;
-    }
+    }
+
+    std::unique_ptr<CachedPage> cachedPage = WTF::move(item.m_cachedPage);
+    m_items.remove(&item);
 
     if (cachedPage->hasExpired()) {
-        LOG(PageCache, "Not restoring page for %s from back/forward cache because cache entry has expired", item->url().string().ascii().data());
+        LOG(PageCache, "Not restoring page for %s from back/forward cache because cache entry has expired", item.url().string().ascii().data());
         logPageCacheFailureDiagnosticMessage(page, DiagnosticLoggingKeys::expiredKey());
         return nullptr;
@@ -498 +473 @@
 }
 
-CachedPage* PageCache::get(HistoryItem* item, Page* page)
-{
-    if (!item)
+CachedPage* PageCache::get(HistoryItem& item, Page* page) const
+{
+    CachedPage* cachedPage = item.m_cachedPage.get();
+    if (!cachedPage) {
+        if (item.m_pruningReason != PruningReason::None)
+            logPageCacheFailureDiagnosticMessage(page, pruningReasonToDiagnosticLoggingKey(item.m_pruningReason));
         return nullptr;
-
-    if (CachedPage* cachedPage = item->m_cachedPage.get()) {
-        if (!cachedPage->hasExpired())
-            return cachedPage;
-        
-        LOG(PageCache, "Not restoring page for %s from back/forward cache because cache entry has expired", item->url().string().ascii().data());
+    }
+
+    if (cachedPage->hasExpired()) {
+        LOG(PageCache, "Not restoring page for %s from back/forward cache because cache entry has expired", item.url().string().ascii().data());
         logPageCacheFailureDiagnosticMessage(page, DiagnosticLoggingKeys::expiredKey());
         PageCache::shared().remove(item);
-    } else if (item->m_pruningReason != PruningReason::None)
-        logPageCacheFailureDiagnosticMessage(page, pruningReasonToDiagnosticLoggingKey(item->m_pruningReason));
-
-    return nullptr;
-}
-
-void PageCache::remove(HistoryItem* item)
+        return nullptr;
+    }
+    return cachedPage;
+}
+
+void PageCache::remove(HistoryItem& item)
 {
     // Safely ignore attempts to remove items not in the cache.
-    if (!item || !item->m_cachedPage)
+    if (!item.m_cachedPage)
         return;
 
-    item->m_cachedPage = nullptr;
-    removeFromLRUList(item);
-    --m_size;
-
-    item->deref(); // Balanced in add().
+    item.m_cachedPage = nullptr;
+    m_items.remove(&item);
 }
 
 void PageCache::prune(PruningReason pruningReason)
 {
-    while (m_size > m_capacity) {
-        ASSERT(m_tail && m_tail->m_cachedPage);
-        m_tail->m_pruningReason = pruningReason;
-        remove(m_tail);
-    }
-}
-
-void PageCache::addToLRUList(HistoryItem* item)
-{
-    item->m_next = m_head;
-    item->m_prev = 0;
-
-    if (m_head) {
-        ASSERT(m_tail);
-        m_head->m_prev = item;
-    } else {
-        ASSERT(!m_tail);
-        m_tail = item;
-    }
-
-    m_head = item;
-}
-
-void PageCache::removeFromLRUList(HistoryItem* item)
-{
-    if (!item->m_next) {
-        ASSERT(item == m_tail);
-        m_tail = item->m_prev;
-    } else {
-        ASSERT(item != m_tail);
-        item->m_next->m_prev = item->m_prev;
-    }
-
-    if (!item->m_prev) {
-        ASSERT(item == m_head);
-        m_head = item->m_next;
-    } else {
-        ASSERT(item != m_head);
-        item->m_prev->m_next = item->m_next;
+    while (pageCount() > maxSize()) {
+        auto& oldestItem = m_items.first();
+        oldestItem->m_cachedPage = nullptr;
+        oldestItem->m_pruningReason = pruningReason;
+        m_items.removeFirst();
     }
 }

trunk/Source/WebCore/history/PageCache.h

@@ -1 +1 @@
 /*
- * Copyright (C) 2007 Apple Inc.  All rights reserved.
+ * Copyright (C) 2007, 2015 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -27 +27 @@
 #define PageCache_h
 
+#include "HistoryItem.h"
 #include "Timer.h"
 #include <wtf/Forward.h>
-#include <wtf/HashSet.h>
+#include <wtf/ListHashSet.h>
 #include <wtf/Noncopyable.h>
 
 namespace WebCore {
 
-    class CachedPage;
-    class Frame;
-    class HistoryItem;
-    class Page;
+class CachedPage;
+class Frame;
+class Page;
 
-    enum class PruningReason { None, ProcessSuspended, MemoryPressure, ReachedCapacity };
-    
-    class PageCache {
-        WTF_MAKE_NONCOPYABLE(PageCache); WTF_MAKE_FAST_ALLOCATED;
-    public:
-        // Function to obtain the global page cache.
-        WEBCORE_EXPORT static PageCache& shared();
-        
-        bool canCache(Page*) const;
+enum class PruningReason { None, ProcessSuspended, MemoryPressure, ReachedMaxSize };
 
-        WEBCORE_EXPORT void setCapacity(int); // number of pages to cache
-        int capacity() { return m_capacity; }
-        
-        void add(PassRefPtr<HistoryItem>, Page&); // Prunes if capacity() is exceeded.
-        WEBCORE_EXPORT void remove(HistoryItem*);
-        CachedPage* get(HistoryItem*, Page*);
-        std::unique_ptr<CachedPage> take(HistoryItem*, Page*);
+class PageCache {
+    WTF_MAKE_NONCOPYABLE(PageCache); WTF_MAKE_FAST_ALLOCATED;
+public:
+    // Function to obtain the global page cache.
+    WEBCORE_EXPORT static PageCache& shared();
 
-        int pageCount() const { return m_size; }
-        WEBCORE_EXPORT int frameCount() const;
+    bool canCache(Page*) const;
 
-        WEBCORE_EXPORT void markPagesForVisitedLinkStyleRecalc();
+    // Used when memory is low to prune some cached pages.
+    WEBCORE_EXPORT void pruneToSizeNow(unsigned maxSize, PruningReason);
+    WEBCORE_EXPORT void setMaxSize(unsigned); // number of pages to cache.
+    unsigned maxSize() const { return m_maxSize; }
 
-        // Will mark all cached pages associated with the given page as needing style recalc.
-        void markPagesForFullStyleRecalc(Page*);
+    void add(HistoryItem&, Page&); // Prunes if maxSize() is exceeded.
+    WEBCORE_EXPORT void remove(HistoryItem&);
+    CachedPage* get(HistoryItem&, Page*) const;
+    std::unique_ptr<CachedPage> take(HistoryItem&, Page*);
 
-        // Used when memory is low to prune some cached pages.
-        WEBCORE_EXPORT void pruneToCapacityNow(int capacity, PruningReason);
+    unsigned pageCount() const { return m_items.size(); }
+    WEBCORE_EXPORT unsigned frameCount() const;
 
+    WEBCORE_EXPORT void markPagesForVisitedLinkStyleRecalc();
+    // Will mark all cached pages associated with the given page as needing style recalc.
+    void markPagesForFullStyleRecalc(Page&);
+    void markPagesForDeviceScaleChanged(Page&);
 #if ENABLE(VIDEO_TRACK)
-        void markPagesForCaptionPreferencesChanged();
+    void markPagesForCaptionPreferencesChanged();
 #endif
 
-        bool shouldClearBackingStores() const { return m_shouldClearBackingStores; }
-        void setShouldClearBackingStores(bool flag) { m_shouldClearBackingStores = flag; }
-        void markPagesForDeviceScaleChanged(Page*);
+    bool shouldClearBackingStores() const { return m_shouldClearBackingStores; }
+    void setShouldClearBackingStores(bool flag) { m_shouldClearBackingStores = flag; }
 
-    private:
-        PageCache(); // Use shared() instead.
-        ~PageCache(); // Not implemented to make sure nobody accidentally calls delete -- WebCore does not delete singletons.
-        
-        static bool canCachePageContainingThisFrame(Frame*);
+private:
+    PageCache() = default; // Use shared() instead.
+    ~PageCache() = delete; // Make sure nobody accidentally calls delete -- WebCore does not delete singletons.
 
-        void addToLRUList(HistoryItem*); // Adds to the head of the list.
-        void removeFromLRUList(HistoryItem*);
+    static bool canCachePageContainingThisFrame(Frame&);
 
-        void prune(PruningReason);
+    void prune(PruningReason);
 
-        int m_capacity;
-        int m_size;
+    ListHashSet<RefPtr<HistoryItem>> m_items;
+    unsigned m_maxSize {0};
+    bool m_shouldClearBackingStores {false};
 
-        // LRU List
-        HistoryItem* m_head;
-        HistoryItem* m_tail;
-        
-        bool m_shouldClearBackingStores;
-
-        friend class WTF::NeverDestroyed<PageCache>;
-    };
+    friend class WTF::NeverDestroyed<PageCache>;
+};
 
 } // namespace WebCore

trunk/Source/WebCore/loader/FrameLoader.cpp

@@ -922 +922 @@
         if (childItem) {
             childFrame->loader().m_requestedHistoryItem = childItem;
-            childFrame->loader().loadDifferentDocumentItem(childItem, loadType(), MayAttemptCacheOnlyLoadForFormSubmissionItem);
+            childFrame->loader().loadDifferentDocumentItem(*childItem, loadType(), MayAttemptCacheOnlyLoadForFormSubmissionItem);
             return;
         }
@@ -1741 +1741 @@
 
     std::unique_ptr<CachedPage> cachedPage;
-    if (m_loadingFromCachedPage)
-        cachedPage = PageCache::shared().take(history().provisionalItem(), m_frame.page());
+    if (m_loadingFromCachedPage && history().provisionalItem())
+        cachedPage = PageCache::shared().take(*history().provisionalItem(), m_frame.page());
 
     LOG(PageCache, "WebCoreLoading %s: About to commit provisional load from previous URL '%s' to new URL '%s'", m_frame.tree().uniqueName().string().utf8().data(),
@@ -1759 +1759 @@
             LOG(PageCache, "Pruning page cache to 0 due to memory pressure");
             // Don't cache any page if we are under memory pressure.
-            PageCache::shared().pruneToCapacityNow(0, PruningReason::MemoryPressure);
+            PageCache::shared().pruneToSizeNow(0, PruningReason::MemoryPressure);
         } else if (systemMemoryLevel() <= memoryLevelThresholdToPrunePageCache) {
             LOG(MemoryPressure, "Pruning page cache because system memory level is %d at: %s", systemMemoryLevel(), __PRETTY_FUNCTION__);
             LOG(PageCache, "Pruning page cache to %d due to low memory (level %d less or equal to %d threshold)", PageCache::shared().capacity() / 2, systemMemoryLevel(), memoryLevelThresholdToPrunePageCache);
-            PageCache::shared().pruneToCapacityNow(PageCache::shared().capacity() / 2, PruningReason::MemoryPressure);
+            PageCache::shared().pruneToSizeNow(PageCache::shared().maxSize() / 2, PruningReason::MemoryPressure);
         }
     }
@@ -1772 +1772 @@
     // Check to see if we need to cache the page we are navigating away from into the back/forward cache.
     // We are doing this here because we know for sure that a new page is about to be loaded.
-    HistoryItem* item = history().currentItem();
-    if (!m_frame.tree().parent() && PageCache::shared().canCache(m_frame.page()) && !item->isInPageCache())
+    HistoryItem& item = *history().currentItem();
+    if (!m_frame.tree().parent() && PageCache::shared().canCache(m_frame.page()) && !item.isInPageCache())
         PageCache::shared().add(item, *m_frame.page());
 
@@ -3128 +3128 @@
 
     if (!activeDocument->canNavigate(frame))
-        return 0;
+        return nullptr;
 
     return frame;
 }
 
-void FrameLoader::loadSameDocumentItem(HistoryItem* item)
-{
-    ASSERT(item->documentSequenceNumber() == history().currentItem()->documentSequenceNumber());
+void FrameLoader::loadSameDocumentItem(HistoryItem& item)
+{
+    ASSERT(item.documentSequenceNumber() == history().currentItem()->documentSequenceNumber());
 
     // Save user view state to the current history item here since we don't do a normal load.
@@ -3143 +3143 @@
         view->setWasScrolledByUser(false);
 
-    history().setCurrentItem(item);
+    history().setCurrentItem(&item);
         
     // loadInSameDocument() actually changes the URL and notifies load delegates of a "fake" load
-    loadInSameDocument(item->url(), item->stateObject(), false);
+    loadInSameDocument(item.url(), item.stateObject(), false);
 
     // Restore user view state from the current history item here since we don't do a normal load.
@@ -3155 +3155 @@
 // which should be methods of HistoryController and some of which should be
 // methods of FrameLoader.
-void FrameLoader::loadDifferentDocumentItem(HistoryItem* item, FrameLoadType loadType, FormSubmissionCacheLoadPolicy cacheLoadPolicy)
+void FrameLoader::loadDifferentDocumentItem(HistoryItem& item, FrameLoadType loadType, FormSubmissionCacheLoadPolicy cacheLoadPolicy)
 {
     // Remember this item so we can traverse any child items as child frames load
-    history().setProvisionalItem(item);
+    history().setProvisionalItem(&item);
 
     if (CachedPage* cachedPage = PageCache::shared().get(item, m_frame.page())) {
@@ -3168 +3168 @@
     }
 
-    URL itemURL = item->url();
-    URL itemOriginalURL = item->originalURL();
+    URL itemURL = item.url();
+    URL itemOriginalURL = item.originalURL();
     URL currentURL;
     if (documentLoader())
         currentURL = documentLoader()->url();
-    RefPtr<FormData> formData = item->formData();
+    RefPtr<FormData> formData = item.formData();
 
     ResourceRequest request(itemURL);
 
-    if (!item->referrer().isNull())
-        request.setHTTPReferrer(item->referrer());
+    if (!item.referrer().isNull())
+        request.setHTTPReferrer(item.referrer());
     
     // If this was a repost that failed the page cache, we might try to repost the form.
@@ -3187 +3187 @@
         request.setHTTPMethod("POST");
         request.setHTTPBody(formData);
-        request.setHTTPContentType(item->formContentType());
-        RefPtr<SecurityOrigin> securityOrigin = SecurityOrigin::createFromString(item->referrer());
+        request.setHTTPContentType(item.formContentType());
+        RefPtr<SecurityOrigin> securityOrigin = SecurityOrigin::createFromString(item.referrer());
         addHTTPOriginIfNeeded(request, securityOrigin->toString());
 
@@ -3243 +3243 @@
 
 // Loads content into this frame, as specified by history item
-void FrameLoader::loadItem(HistoryItem* item, FrameLoadType loadType)
-{
-    m_requestedHistoryItem = item;
+void FrameLoader::loadItem(HistoryItem& item, FrameLoadType loadType)
+{
+    m_requestedHistoryItem = &item;
     HistoryItem* currentItem = history().currentItem();
-    bool sameDocumentNavigation = currentItem && item->shouldDoSameDocumentNavigationTo(currentItem);
+    bool sameDocumentNavigation = currentItem && item.shouldDoSameDocumentNavigationTo(currentItem);
 
     if (sameDocumentNavigation)
@@ -3261 +3261 @@
     // We only use cache-only loads to avoid resubmitting forms.
     ASSERT(isBackForwardLoadType(m_loadType));
+    ASSERT(history().provisionalItem());
     ASSERT(history().provisionalItem()->formData());
     ASSERT(history().provisionalItem() == m_requestedHistoryItem.get());
 
     FrameLoadType loadType = m_loadType;
-    HistoryItem* item = history().provisionalItem();
+    HistoryItem& item = *history().provisionalItem();
 
     stopAllLoaders(ShouldNotClearProvisionalItem);

trunk/Source/WebCore/loader/FrameLoader.h

@@ -126 +126 @@
 
     void open(CachedFrameBase&);
-    void loadItem(HistoryItem*, FrameLoadType);
+    void loadItem(HistoryItem&, FrameLoadType);
     HistoryItem* requestedHistoryItem() const { return m_requestedHistoryItem.get(); }
 
@@ -300 +300 @@
     void checkTimerFired();
     
-    void loadSameDocumentItem(HistoryItem*);
-    void loadDifferentDocumentItem(HistoryItem*, FrameLoadType, FormSubmissionCacheLoadPolicy);
+    void loadSameDocumentItem(HistoryItem&);
+    void loadDifferentDocumentItem(HistoryItem&, FrameLoadType, FormSubmissionCacheLoadPolicy);
     
     void loadProvisionalItemFromCachedPage();

trunk/Source/WebCore/loader/HistoryController.cpp

@@ -235 +235 @@
 void HistoryController::invalidateCurrentItemCachedPage()
 {
+    if (!currentItem())
+        return;
+
     // When we are pre-commit, the currentItem is where any page cache data resides.
-    if (!PageCache::shared().get(currentItem(), m_frame.page()))
-        return;
-
-    std::unique_ptr<CachedPage> cachedPage = PageCache::shared().take(currentItem(), m_frame.page());
+    std::unique_ptr<CachedPage> cachedPage = PageCache::shared().take(*currentItem(), m_frame.page());
+    if (!cachedPage)
+        return;
 
     // FIXME: This is a grotesque hack to fix <rdar://problem/4059059> Crash in RenderFlow::detach
@@ -266 +268 @@
 // Main funnel for navigating to a previous location (back/forward, non-search snap-back)
 // This includes recursion to handle loading into framesets properly
-void HistoryController::goToItem(HistoryItem* targetItem, FrameLoadType type)
+void HistoryController::goToItem(HistoryItem& targetItem, FrameLoadType type)
 {
     ASSERT(!m_frame.tree().parent());
@@ -277 +279 @@
     if (!page)
         return;
-    if (!m_frame.loader().client().shouldGoToHistoryItem(targetItem))
+    if (!m_frame.loader().client().shouldGoToHistoryItem(&targetItem))
         return;
     if (m_defersLoading) {
-        m_deferredItem = targetItem;
+        m_deferredItem = &targetItem;
         m_deferredFrameLoadType = type;
         return;
@@ -289 +291 @@
     // as opposed to happening for some/one of the page commits that might happen soon
     RefPtr<HistoryItem> currentItem = page->backForward().currentItem();
-    page->backForward().setCurrentItem(targetItem);
+    page->backForward().setCurrentItem(&targetItem);
     m_frame.loader().client().updateGlobalHistoryItemForPage();
 
@@ -306 +308 @@
     m_defersLoading = defer;
     if (!defer && m_deferredItem) {
-        goToItem(m_deferredItem.get(), m_deferredFrameLoadType);
-        m_deferredItem = 0;
+        goToItem(*m_deferredItem, m_deferredFrameLoadType);
+        m_deferredItem = nullptr;
     }
 }
@@ -335 +337 @@
 
     if (m_currentItem) {
-        PageCache::shared().remove(m_currentItem.get());
+        PageCache::shared().remove(*m_currentItem);
     
         if (m_frame.loader().loadType() == FrameLoadType::Reload || m_frame.loader().loadType() == FrameLoadType::ReloadFromOrigin)
@@ -500 +502 @@
     // (a matching URL and frame tree snapshot), just restore the scroll position.
     // Save form state (works from currentItem, since m_frameLoadComplete is true)
-    if (m_currentItem && itemsAreClones(m_currentItem.get(), m_provisionalItem.get())) {
+    if (m_currentItem && itemsAreClones(*m_currentItem, m_provisionalItem.get())) {
         ASSERT(m_frameLoadComplete);
         saveDocumentState();
@@ -708 +710 @@
 // a match, we set the provisional item and recurse.  Otherwise we will reload that
 // frame and all its kids in recursiveGoToItem.
-void HistoryController::recursiveSetProvisionalItem(HistoryItem* item, HistoryItem* fromItem)
-{
-    ASSERT(item);
-
+void HistoryController::recursiveSetProvisionalItem(HistoryItem& item, HistoryItem* fromItem)
+{
     if (!itemsAreClones(item, fromItem))
         return;
 
     // Set provisional item, which will be committed in recursiveUpdateForCommit.
-    m_provisionalItem = item;
-
-    for (const auto& childItem : item->children()) {
+    m_provisionalItem = &item;
+
+    for (const auto& childItem : item.children()) {
         const String& childFrameName = childItem->target();
 
@@ -726 +726 @@
         ASSERT(childFrame);
 
-        childFrame->loader().history().recursiveSetProvisionalItem(childItem.get(), fromChildItem);
+        childFrame->loader().history().recursiveSetProvisionalItem(*childItem, fromChildItem);
     }
 }
@@ -732 +732 @@
 // We now traverse the frame tree and item tree a second time, loading frames that
 // do have the content the item requests.
-void HistoryController::recursiveGoToItem(HistoryItem* item, HistoryItem* fromItem, FrameLoadType type)
-{
-    ASSERT(item);
-
+void HistoryController::recursiveGoToItem(HistoryItem& item, HistoryItem* fromItem, FrameLoadType type)
+{
     if (!itemsAreClones(item, fromItem)) {
         m_frame.loader().loadItem(item, type);
@@ -742 +740 @@
 
     // Just iterate over the rest, looking for frames to navigate.
-    for (const auto& childItem : item->children()) {
+    for (const auto& childItem : item.children()) {
         const String& childFrameName = childItem->target();
 
@@ -749 +747 @@
         Frame* childFrame = m_frame.tree().child(childFrameName);
         ASSERT(childFrame);
-        childFrame->loader().history().recursiveGoToItem(childItem.get(), fromChildItem, type);
-    }
-}
-
-bool HistoryController::itemsAreClones(HistoryItem* item1, HistoryItem* item2) const
+        childFrame->loader().history().recursiveGoToItem(*childItem, fromChildItem, type);
+    }
+}
+
+bool HistoryController::itemsAreClones(HistoryItem& item1, HistoryItem* item2) const
 {
     // If the item we're going to is a clone of the item we're at, then we do
@@ -762 +760 @@
     // new document and should not consider them clones.
     // (See http://webkit.org/b/35532 for details.)
-    return item1
-        && item2
-        && item1 != item2
-        && item1->itemSequenceNumber() == item2->itemSequenceNumber()
-        && currentFramesMatchItem(item1)
-        && item2->hasSameFrames(item1);
+    return item2
+        && &item1 != item2
+        && item1.itemSequenceNumber() == item2->itemSequenceNumber()
+        && currentFramesMatchItem(&item1)
+        && item2->hasSameFrames(&item1);
 }
 

trunk/Source/WebCore/loader/HistoryController.h

@@ -94 +94 @@
     friend class Page;
     bool shouldStopLoadingForHistoryItem(HistoryItem*) const;
-    void goToItem(HistoryItem*, FrameLoadType);
+    void goToItem(HistoryItem&, FrameLoadType);
 
     void initializeItem(HistoryItem*);
@@ -100 +100 @@
     PassRefPtr<HistoryItem> createItemTree(Frame& targetFrame, bool clipAtTarget);
 
-    void recursiveSetProvisionalItem(HistoryItem*, HistoryItem*);
-    void recursiveGoToItem(HistoryItem*, HistoryItem*, FrameLoadType);
+    void recursiveSetProvisionalItem(HistoryItem&, HistoryItem*);
+    void recursiveGoToItem(HistoryItem&, HistoryItem*, FrameLoadType);
     bool isReplaceLoadTypeWithProvisionalItem(FrameLoadType);
     bool isReloadTypeWithProvisionalItem(FrameLoadType);
     void recursiveUpdateForCommit();
     void recursiveUpdateForSameDocumentNavigation();
-    bool itemsAreClones(HistoryItem*, HistoryItem*) const;
+    bool itemsAreClones(HistoryItem&, HistoryItem*) const;
     bool currentFramesMatchItem(HistoryItem*) const;
     void updateBackForwardListClippedAtTarget(bool doClip);

trunk/Source/WebCore/page/DiagnosticLoggingKeys.cpp

@@ -389 +389 @@
 }
 
-String DiagnosticLoggingKeys::prunedDueToCapacityReached()
+String DiagnosticLoggingKeys::prunedDueToMaxSizeReached()
 {
     return ASCIILiteral("pruned.capacityReached");

trunk/Source/WebCore/page/DiagnosticLoggingKeys.h

@@ -77 +77 @@
     static String pluginLoadedKey();
     static String pluginLoadingFailedKey();
-    static String prunedDueToCapacityReached();
+    static String prunedDueToMaxSizeReached();
     static String prunedDueToMemoryPressureKey();
     static String prunedDueToProcessSuspended();

trunk/Source/WebCore/page/Frame.cpp

@@ -990 +990 @@
 
     if (isMainFrame())
-        PageCache::shared().markPagesForFullStyleRecalc(page);
+        PageCache::shared().markPagesForFullStyleRecalc(*page);
 }
 

trunk/Source/WebCore/page/Page.cpp

@@ -431 +431 @@
 }
 
-void Page::goToItem(HistoryItem* item, FrameLoadType type)
+void Page::goToItem(HistoryItem& item, FrameLoadType type)
 {
     // stopAllLoaders may end up running onload handlers, which could cause further history traversals that may lead to the passed in HistoryItem
     // being deref()-ed. Make sure we can still use it with HistoryController::goToItem later.
-    RefPtr<HistoryItem> protector(item);
-
-    if (m_mainFrame->loader().history().shouldStopLoadingForHistoryItem(item))
+    Ref<HistoryItem> protector(item);
+
+    if (m_mainFrame->loader().history().shouldStopLoadingForHistoryItem(&item))
         m_mainFrame->loader().stopAllLoaders();
 
@@ -840 +840 @@
 
     mainFrame().deviceOrPageScaleFactorChanged();
-    PageCache::shared().markPagesForDeviceScaleChanged(this);
-
-    PageCache::shared().markPagesForFullStyleRecalc(this);
+    PageCache::shared().markPagesForDeviceScaleChanged(*this);
+
+    PageCache::shared().markPagesForFullStyleRecalc(*this);
     GraphicsContext::updateDocumentMarkerResources();
 
@@ -922 +922 @@
 
     setNeedsRecalcStyleInAllFrames();
-    PageCache::shared().markPagesForFullStyleRecalc(this);
+    PageCache::shared().markPagesForFullStyleRecalc(*this);
 }
 
@@ -1662 +1662 @@
 
     invalidateStylesForAllLinks();
-    PageCache::shared().markPagesForFullStyleRecalc(this);
+    PageCache::shared().markPagesForFullStyleRecalc(*this);
 }
 

trunk/Source/WebCore/page/Page.h

@@ -151 +151 @@
     void setOpenedByDOM();
 
-    WEBCORE_EXPORT void goToItem(HistoryItem*, FrameLoadType);
+    WEBCORE_EXPORT void goToItem(HistoryItem&, FrameLoadType);
 
     WEBCORE_EXPORT void setGroupName(const String&);

trunk/Source/WebCore/page/Settings.cpp

@@ -520 +520 @@
         return;
 
-    if (!m_usesPageCache) {
-        int first = -m_page->backForward().backCount();
-        int last = m_page->backForward().forwardCount();
-        for (int i = first; i <= last; i++)
-            PageCache::shared().remove(m_page->backForward().itemAtIndex(i));
-    }
+    if (!m_usesPageCache)
+        PageCache::shared().pruneToSizeNow(0, PruningReason::None);
 }
 

trunk/Source/WebCore/platform/MemoryPressureHandler.cpp

@@ -103 +103 @@
         // Right now, the only reason we call release critical memory while not under memory pressure is if the process is about to be suspended.
         PruningReason pruningReason = memoryPressureHandler().isUnderMemoryPressure() ? PruningReason::MemoryPressure : PruningReason::ProcessSuspended;
-        PageCache::shared().pruneToCapacityNow(0, pruningReason);
+        PageCache::shared().pruneToSizeNow(0, pruningReason);
     }
 

trunk/Source/WebKit/mac/ChangeLog

@@ +1 @@
+2015-01-29  Chris Dumez  <cdumez@apple.com>
+
+        Clean up / modernize PageCache class
+        https://bugs.webkit.org/show_bug.cgi?id=141009
+
+        Reviewed by Darin Adler.
+
+        Clean up / modernize PageCache class.
+
+        * History/WebBackForwardList.mm:
+        (-[WebBackForwardList pageCacheSize]):
+        * WebView/WebView.mm:
+        (-[WebView _loadBackForwardListFromOtherView:]):
+        (-[WebView goToBackForwardItem:]):
+        (+[WebView _setCacheModel:]):
+
 2015-01-28  Beth Dakin  <bdakin@apple.com>
 

trunk/Source/WebKit/mac/History/WebBackForwardList.mm

@@ -356 +356 @@
 - (NSUInteger)pageCacheSize
 {
-    return [kit(core(self)->page()) usesPageCache] ? PageCache::shared().capacity() : 0;
+    return [kit(core(self)->page()) usesPageCache] ? PageCache::shared().maxSize() : 0;
 }
 

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

@@ -1998 +1998 @@
         return; // empty back forward list, bail
     
-    HistoryItem* newItemToGoTo = 0;
+    HistoryItem* newItemToGoTo = nullptr;
 
     int lastItemIndex = otherBackForwardClient->forwardListCount();
@@ -2015 +2015 @@
     
     ASSERT(newItemToGoTo);
-    _private->page->goToItem(newItemToGoTo, FrameLoadType::IndexedBackForward);
+    _private->page->goToItem(*newItemToGoTo, FrameLoadType::IndexedBackForward);
 }
 
@@ -5648 +5648 @@
         return NO;
 
-    _private->page->goToItem(core(item), FrameLoadType::IndexedBackForward);
+    ASSERT(item);
+    _private->page->goToItem(*core(item), FrameLoadType::IndexedBackForward);
     return YES;
 }
@@ -7743 +7744 @@
     auto deadDecodedDataDeletionInterval = std::chrono::seconds { 0 };
 
-    unsigned pageCacheCapacity = 0;
+    unsigned pageCacheSize = 0;
 
     NSUInteger nsurlCacheMemoryCapacity = 0;
@@ -7754 +7755 @@
     case WebCacheModelDocumentViewer: {
         // Page cache capacity (in pages)
-        pageCacheCapacity = 0;
+        pageCacheSize = 0;
 
         // Object cache capacities (in bytes)
@@ -7791 +7792 @@
         // Page cache capacity (in pages)
         if (memSize >= 1024)
-            pageCacheCapacity = 3;
+            pageCacheSize = 3;
         else if (memSize >= 512)
-            pageCacheCapacity = 2;
+            pageCacheSize = 2;
         else if (memSize >= 256)
-            pageCacheCapacity = 1;
+            pageCacheSize = 1;
         else
-            pageCacheCapacity = 0;
+            pageCacheSize = 0;
 
         // Object cache capacities (in bytes)
@@ -7845 +7846 @@
         // (Research indicates that value / page drops substantially after 3 pages.)
         if (memSize >= 2048)
-            pageCacheCapacity = 5;
+            pageCacheSize = 5;
         else if (memSize >= 1024)
-            pageCacheCapacity = 4;
+            pageCacheSize = 4;
         else if (memSize >= 512)
-            pageCacheCapacity = 3;
+            pageCacheSize = 3;
         else if (memSize >= 256)
-            pageCacheCapacity = 2;
+            pageCacheSize = 2;
         else
-            pageCacheCapacity = 1;
+            pageCacheSize = 1;
 
 #if PLATFORM(IOS)
@@ -7859 +7860 @@
         // FIXME (<rdar://problem/11779846>): Avoiding jettisoning should not have to require reducing the page cache capacity.
         // Reducing the capacity by 1 reduces overall back-forward performance.
-        if (pageCacheCapacity > 0)
-            pageCacheCapacity -= 1;
+        if (pageCacheSize > 0)
+            pageCacheSize -= 1;
 #endif
 
@@ -7936 +7937 @@
     memoryCache().setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
     memoryCache().setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
-    PageCache::shared().setCapacity(pageCacheCapacity);
+    PageCache::shared().setMaxSize(pageCacheSize);
 #if PLATFORM(IOS)
     PageCache::shared().setShouldClearBackingStores(true);

trunk/Source/WebKit/win/ChangeLog

@@ +1 @@
+2015-01-29  Chris Dumez  <cdumez@apple.com>
+
+        Clean up / modernize PageCache class
+        https://bugs.webkit.org/show_bug.cgi?id=141009
+
+        Reviewed by Darin Adler.
+
+        Clean up / modernize PageCache class.
+
+        * WebView.cpp:
+        (WebView::setCacheModel):
+
 2015-01-28  peavo@outlook.com  <peavo@outlook.com>
 

trunk/Source/WebKit/win/WebView.cpp

@@ -531 +531 @@
     auto deadDecodedDataDeletionInterval = std::chrono::seconds { 0 };
 
-    unsigned pageCacheCapacity = 0;
+    unsigned pageCacheSize = 0;
 
 
@@ -537 +537 @@
     case WebCacheModelDocumentViewer: {
         // Page cache capacity (in pages)
-        pageCacheCapacity = 0;
+        pageCacheSize = 0;
 
         // Object cache capacities (in bytes)
@@ -564 +564 @@
         // Page cache capacity (in pages)
         if (memSize >= 1024)
-            pageCacheCapacity = 3;
+            pageCacheSize = 3;
         else if (memSize >= 512)
-            pageCacheCapacity = 2;
+            pageCacheSize = 2;
         else if (memSize >= 256)
-            pageCacheCapacity = 1;
+            pageCacheSize = 1;
         else
-            pageCacheCapacity = 0;
+            pageCacheSize = 0;
 
         // Object cache capacities (in bytes)
@@ -611 +611 @@
         // (Research indicates that value / page drops substantially after 3 pages.)
         if (memSize >= 2048)
-            pageCacheCapacity = 5;
+            pageCacheSize = 5;
         else if (memSize >= 1024)
-            pageCacheCapacity = 4;
+            pageCacheSize = 4;
         else if (memSize >= 512)
-            pageCacheCapacity = 3;
+            pageCacheSize = 3;
         else if (memSize >= 256)
-            pageCacheCapacity = 2;
+            pageCacheSize = 2;
         else
-            pageCacheCapacity = 1;
+            pageCacheSize = 1;
 
         // Object cache capacities (in bytes)
@@ -676 +676 @@
     memoryCache().setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
     memoryCache().setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
-    PageCache::shared().setCapacity(pageCacheCapacity);
+    PageCache::shared().setMaxSize(pageCacheSize);
 
 #if USE(CFNETWORK)
@@ -3155 +3155 @@
         return hr;
 
-    m_page->goToItem(webHistoryItem->historyItem(), FrameLoadType::IndexedBackForward);
+    m_page->goToItem(*webHistoryItem->historyItem(), FrameLoadType::IndexedBackForward);
     *succeeded = TRUE;
 
@@ -5502 +5502 @@
     
     ASSERT(newItemToGoTo);
-    m_page->goToItem(newItemToGoTo, FrameLoadType::IndexedBackForward);
+    m_page->goToItem(*newItemToGoTo, FrameLoadType::IndexedBackForward);
     return S_OK;
 }

trunk/Source/WebKit2/ChangeLog

@@ +1 @@
+2015-01-29  Chris Dumez  <cdumez@apple.com>
+
+        Clean up / modernize PageCache class
+        https://bugs.webkit.org/show_bug.cgi?id=141009
+
+        Reviewed by Darin Adler.
+
+        Clean up / modernize PageCache class.
+
+        * WebProcess/WebPage/WebBackForwardListProxy.cpp:
+        (WebKit::WebBackForwardListProxy::removeItem):
+        (WebKit::WebBackForwardListProxy::close):
+        * WebProcess/WebPage/WebPage.cpp:
+        (WebKit::WebPage::goForward):
+        (WebKit::WebPage::goBack):
+        (WebKit::WebPage::goToBackForwardItem):
+        * WebProcess/WebProcess.cpp:
+        (WebKit::WebProcess::releasePageCache):
+        * WebProcess/cocoa/WebProcessCocoa.mm:
+        (WebKit::WebProcess::platformSetCacheModel):
+        * WebProcess/soup/WebProcessSoup.cpp:
+        (WebKit::WebProcess::platformSetCacheModel):
+
 2015-01-29  Csaba Osztrogonác  <ossy@webkit.org>
 

trunk/Source/WebKit2/WebProcess/WebPage/WebBackForwardListProxy.cpp

@@ -133 +133 @@
         return;
         
-    PageCache::shared().remove(item.get());
+    PageCache::shared().remove(*item);
     WebCore::Page::clearPreviousItemFromAllPages(item.get());
     historyItemToIDMap().remove(item);
@@ -217 +217 @@
 void WebBackForwardListProxy::close()
 {
-    HashSet<uint64_t>::iterator end = m_associatedItemIDs.end();
-    for (HashSet<uint64_t>::iterator i = m_associatedItemIDs.begin(); i != end; ++i)
-        WebCore::PageCache::shared().remove(itemForID(*i));
+    for (auto& itemID : m_associatedItemIDs) {
+        if (HistoryItem* item = itemForID(itemID))
+            WebCore::PageCache::shared().remove(*item);
+    }
 
     m_associatedItemIDs.clear();
-
     m_page = nullptr;
 }

trunk/Source/WebKit2/WebProcess/WebPage/WebPage.cpp

@@ -1211 +1211 @@
         m_pendingNavigationID = navigationID;
 
-    m_page->goToItem(item, FrameLoadType::Forward);
+    m_page->goToItem(*item, FrameLoadType::Forward);
 }
 
@@ -1227 +1227 @@
         m_pendingNavigationID = navigationID;
 
-    m_page->goToItem(item, FrameLoadType::Back);
+    m_page->goToItem(*item, FrameLoadType::Back);
 }
 
@@ -1243 +1243 @@
         m_pendingNavigationID = navigationID;
 
-    m_page->goToItem(item, FrameLoadType::IndexedBackForward);
+    m_page->goToItem(*item, FrameLoadType::IndexedBackForward);
 }
 

trunk/Source/WebKit2/WebProcess/WebProcess.cpp

@@ -1117 +1117 @@
 void WebProcess::releasePageCache()
 {
-    PageCache::shared().pruneToCapacityNow(0, PruningReason::MemoryPressure);
+    PageCache::shared().pruneToSizeNow(0, PruningReason::MemoryPressure);
 }
 

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

@@ -105 +105 @@
     unsigned cacheMaxDeadCapacity = 0;
     auto deadDecodedDataDeletionInterval = std::chrono::seconds { 0 };
-    unsigned pageCacheCapacity = 0;
+    unsigned pageCacheSize = 0;
     unsigned long urlCacheMemoryCapacity = 0;
     unsigned long urlCacheDiskCapacity = 0;
@@ -111 +111 @@
     calculateCacheSizes(cacheModel, memSize, diskFreeSize,
         cacheTotalCapacity, cacheMinDeadCapacity, cacheMaxDeadCapacity, deadDecodedDataDeletionInterval,
-        pageCacheCapacity, urlCacheMemoryCapacity, urlCacheDiskCapacity);
+        pageCacheSize, urlCacheMemoryCapacity, urlCacheDiskCapacity);
 
 
     memoryCache().setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
     memoryCache().setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
-    PageCache::shared().setCapacity(pageCacheCapacity);
+    PageCache::shared().setMaxSize(pageCacheSize);
 
     NSURLCache *nsurlCache = [NSURLCache sharedURLCache];

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

@@ -84 +84 @@
     unsigned cacheMaxDeadCapacity = 0;
     auto deadDecodedDataDeletionInterval = std::chrono::seconds { 0 };
-    unsigned pageCacheCapacity = 0;
+    unsigned pageCacheSize = 0;
 
     unsigned long urlCacheMemoryCapacity = 0;
@@ -100 +100 @@
     calculateCacheSizes(cacheModel, memSize, diskFreeSize,
                         cacheTotalCapacity, cacheMinDeadCapacity, cacheMaxDeadCapacity, deadDecodedDataDeletionInterval,
-                        pageCacheCapacity, urlCacheMemoryCapacity, urlCacheDiskCapacity);
+                        pageCacheSize, urlCacheMemoryCapacity, urlCacheDiskCapacity);
 
     WebCore::memoryCache().setDisabled(cacheModel == CacheModelDocumentViewer);
     WebCore::memoryCache().setCapacities(cacheMinDeadCapacity, cacheMaxDeadCapacity, cacheTotalCapacity);
     WebCore::memoryCache().setDeadDecodedDataDeletionInterval(deadDecodedDataDeletionInterval);
-    WebCore::PageCache::shared().setCapacity(pageCacheCapacity);
+    WebCore::PageCache::shared().setMaxSize(pageCacheSize);
 
 #if PLATFORM(GTK)