Changeset 222824 in webkit


Ignore:
Timestamp:
Oct 3, 2017 5:51:24 PM (6 years ago)
Author:
achristensen@apple.com
Message:

Moderize WebKit's back forward list code
https://bugs.webkit.org/show_bug.cgi?id=177843

Reviewed by Tim Horton.

Use Ref instead of RefPtr when possible.
Use references instead of pointers when possible.
Remove unnecessary null checks.
Reduce unnecessary Vector copying.

  • Shared/SessionState.h:
  • Shared/WebBackForwardListItem.h:
  • UIProcess/API/APILoaderClient.h:

(API::LoaderClient::didChangeBackForwardList):
(API::LoaderClient::shouldKeepCurrentBackForwardListItemInList):

  • UIProcess/API/C/WKPage.cpp:

(WKPageSetPageLoaderClient):

  • UIProcess/WebBackForwardList.cpp:

(WebKit::WebBackForwardList::pageClosed):
(WebKit::WebBackForwardList::addItem):
(WebKit::WebBackForwardList::goToItem):
(WebKit::WebBackForwardList::currentItem const):
(WebKit::WebBackForwardList::backItem const):
(WebKit::WebBackForwardList::forwardItem const):
(WebKit::WebBackForwardList::itemAtIndex const):
(WebKit::WebBackForwardList::backListAsAPIArrayWithLimit const):
(WebKit::WebBackForwardList::forwardListAsAPIArrayWithLimit const):
(WebKit::WebBackForwardList::removeAllItems):
(WebKit::WebBackForwardList::clear):
(WebKit::WebBackForwardList::backForwardListState const):
(WebKit::WebBackForwardList::restoreFromState):

  • UIProcess/WebBackForwardList.h:
  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::reattachToWebProcessWithItem):
(WebKit::WebPageProxy::initializeWebPage):
(WebKit::WebPageProxy::didChangeBackForwardList):
(WebKit::WebPageProxy::shouldKeepCurrentBackForwardListItemInList):
(WebKit::WebPageProxy::backForwardGoToItem):

  • UIProcess/WebPageProxy.h:
  • UIProcess/WebProcessProxy.cpp:

(WebKit::WebProcessProxy::registerNewWebBackForwardListItem):

  • UIProcess/WebProcessProxy.h:
  • WebProcess/WebPage/WebBackForwardListProxy.cpp:

(WebKit::WebBackForwardListProxy::itemAtIndex):

Location:
trunk/Source/WebKit
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebKit/ChangeLog

    r222820 r222824  
     12017-10-03  Alex Christensen  <achristensen@webkit.org>
     2
     3        Moderize WebKit's back forward list code
     4        https://bugs.webkit.org/show_bug.cgi?id=177843
     5
     6        Reviewed by Tim Horton.
     7
     8        Use Ref instead of RefPtr when possible.
     9        Use references instead of pointers when possible.
     10        Remove unnecessary null checks.
     11        Reduce unnecessary Vector copying.
     12
     13        * Shared/SessionState.h:
     14        * Shared/WebBackForwardListItem.h:
     15        * UIProcess/API/APILoaderClient.h:
     16        (API::LoaderClient::didChangeBackForwardList):
     17        (API::LoaderClient::shouldKeepCurrentBackForwardListItemInList):
     18        * UIProcess/API/C/WKPage.cpp:
     19        (WKPageSetPageLoaderClient):
     20        * UIProcess/WebBackForwardList.cpp:
     21        (WebKit::WebBackForwardList::pageClosed):
     22        (WebKit::WebBackForwardList::addItem):
     23        (WebKit::WebBackForwardList::goToItem):
     24        (WebKit::WebBackForwardList::currentItem const):
     25        (WebKit::WebBackForwardList::backItem const):
     26        (WebKit::WebBackForwardList::forwardItem const):
     27        (WebKit::WebBackForwardList::itemAtIndex const):
     28        (WebKit::WebBackForwardList::backListAsAPIArrayWithLimit const):
     29        (WebKit::WebBackForwardList::forwardListAsAPIArrayWithLimit const):
     30        (WebKit::WebBackForwardList::removeAllItems):
     31        (WebKit::WebBackForwardList::clear):
     32        (WebKit::WebBackForwardList::backForwardListState const):
     33        (WebKit::WebBackForwardList::restoreFromState):
     34        * UIProcess/WebBackForwardList.h:
     35        * UIProcess/WebPageProxy.cpp:
     36        (WebKit::WebPageProxy::reattachToWebProcessWithItem):
     37        (WebKit::WebPageProxy::initializeWebPage):
     38        (WebKit::WebPageProxy::didChangeBackForwardList):
     39        (WebKit::WebPageProxy::shouldKeepCurrentBackForwardListItemInList):
     40        (WebKit::WebPageProxy::backForwardGoToItem):
     41        * UIProcess/WebPageProxy.h:
     42        * UIProcess/WebProcessProxy.cpp:
     43        (WebKit::WebProcessProxy::registerNewWebBackForwardListItem):
     44        * UIProcess/WebProcessProxy.h:
     45        * WebProcess/WebPage/WebBackForwardListProxy.cpp:
     46        (WebKit::WebBackForwardListProxy::itemAtIndex):
     47
    1482017-10-03  Chris Dumez  <cdumez@apple.com>
    249
  • trunk/Source/WebKit/Shared/SessionState.h

    r222233 r222824  
    2424 */
    2525
    26 #ifndef SessionState_h
    27 #define SessionState_h
     26#pragma once
    2827
    2928#if PLATFORM(COCOA)
     
    151150
    152151} // namespace WebKit
    153 
    154 #endif // SessionState_h
  • trunk/Source/WebKit/Shared/WebBackForwardListItem.h

    r216764 r222824  
    2424 */
    2525
    26 #ifndef WebBackForwardListItem_h
    27 #define WebBackForwardListItem_h
     26#pragma once
    2827
    2928#include "APIObject.h"
    3029#include "SessionState.h"
    31 #include <wtf/RefPtr.h>
     30#include <wtf/Ref.h>
    3231#include <wtf/text/WTFString.h>
    3332
     
    7574};
    7675
    77 typedef Vector<RefPtr<WebBackForwardListItem>> BackForwardListItemVector;
     76typedef Vector<Ref<WebBackForwardListItem>> BackForwardListItemVector;
    7877
    7978} // namespace WebKit
    80 
    81 #endif // WebBackForwardListItem_h
  • trunk/Source/WebKit/UIProcess/API/APILoaderClient.h

    r222802 r222824  
    9090    virtual void processDidCrash(WebKit::WebPageProxy&) { }
    9191
    92     virtual void didChangeBackForwardList(WebKit::WebPageProxy&, WebKit::WebBackForwardListItem*, Vector<RefPtr<WebKit::WebBackForwardListItem>>) { }
    93     virtual bool shouldKeepCurrentBackForwardListItemInList(WebKit::WebPageProxy&, WebKit::WebBackForwardListItem*) { return true; }
     92    virtual void didChangeBackForwardList(WebKit::WebPageProxy&, WebKit::WebBackForwardListItem*, Vector<Ref<WebKit::WebBackForwardListItem>>&&) { }
     93    virtual bool shouldKeepCurrentBackForwardListItemInList(WebKit::WebPageProxy&, WebKit::WebBackForwardListItem&) { return true; }
    9494    virtual void willGoToBackForwardListItem(WebKit::WebPageProxy&, WebKit::WebBackForwardListItem&, API::Object*) { }
    9595
  • trunk/Source/WebKit/UIProcess/API/C/WKPage.cpp

    r222802 r222824  
    12051205        }
    12061206
    1207         void didChangeBackForwardList(WebPageProxy& page, WebBackForwardListItem* addedItem, Vector<RefPtr<WebBackForwardListItem>> removedItems) override
     1207        void didChangeBackForwardList(WebPageProxy& page, WebBackForwardListItem* addedItem, Vector<Ref<WebBackForwardListItem>>&& removedItems) override
    12081208        {
    12091209            if (!m_client.didChangeBackForwardList)
     
    12231223        }
    12241224
    1225         bool shouldKeepCurrentBackForwardListItemInList(WebKit::WebPageProxy& page, WebKit::WebBackForwardListItem* item) override
     1225        bool shouldKeepCurrentBackForwardListItemInList(WebKit::WebPageProxy& page, WebKit::WebBackForwardListItem& item) override
    12261226        {
    12271227            if (!m_client.shouldKeepCurrentBackForwardListItemInList)
    12281228                return true;
    12291229
    1230             return m_client.shouldKeepCurrentBackForwardListItemInList(toAPI(&page), toAPI(item), m_client.base.clientInfo);
     1230            return m_client.shouldKeepCurrentBackForwardListItemInList(toAPI(&page), toAPI(&item), m_client.base.clientInfo);
    12311231        }
    12321232
  • trunk/Source/WebKit/UIProcess/API/glib/WebKitBackForwardList.cpp

    r218487 r222824  
    129129}
    130130
    131 void webkitBackForwardListChanged(WebKitBackForwardList* backForwardList, WebBackForwardListItem* webAddedItem, const Vector<RefPtr<WebBackForwardListItem>>& webRemovedItems)
     131void webkitBackForwardListChanged(WebKitBackForwardList* backForwardList, WebBackForwardListItem* webAddedItem, Vector<Ref<WebBackForwardListItem>>&& webRemovedItems)
    132132{
    133133    WebKitBackForwardListItem* addedItem = webkitBackForwardListGetOrCreateItem(backForwardList, webAddedItem);
     
    139139        // the removed items are not in the map. In that case we create a wrapper now to pass it the changed signal, but
    140140        // without adding it to the item map. See https://bugs.webkit.org/show_bug.cgi?id=153233.
    141         GRefPtr<WebKitBackForwardListItem> removedItem = priv->itemsMap.get(webItem.get());
     141        GRefPtr<WebKitBackForwardListItem> removedItem = priv->itemsMap.get(webItem.ptr());
    142142        if (removedItem) {
    143143            removedItems = g_list_prepend(removedItems, g_object_ref(removedItem.get()));
    144             priv->itemsMap.remove(webItem.get());
     144            priv->itemsMap.remove(webItem.ptr());
    145145        } else
    146             removedItems = g_list_prepend(removedItems, webkitBackForwardListItemGetOrCreate(webItem.get()));
     146            removedItems = g_list_prepend(removedItems, webkitBackForwardListItemGetOrCreate(webItem.ptr()));
    147147    }
    148148
  • trunk/Source/WebKit/UIProcess/API/glib/WebKitBackForwardListPrivate.h

    r218487 r222824  
    2424 */
    2525
    26 #ifndef WebKitBackForwardListPrivate_h
    27 #define WebKitBackForwardListPrivate_h
     26#pragma once
    2827
    2928#include "WebBackForwardList.h"
     
    3332WebKitBackForwardListItem* webkitBackForwardListItemGetOrCreate(WebKit::WebBackForwardListItem*);
    3433WebKit::WebBackForwardListItem* webkitBackForwardListItemGetItem(WebKitBackForwardListItem*);
    35 void webkitBackForwardListChanged(WebKitBackForwardList*, WebKit::WebBackForwardListItem* webAddedItem, const Vector<RefPtr<WebKit::WebBackForwardListItem>>&);
    36 
    37 #endif // WebKitBackForwardListPrivate_h
     34void webkitBackForwardListChanged(WebKitBackForwardList*, WebKit::WebBackForwardListItem* webAddedItem, Vector<Ref<WebKit::WebBackForwardListItem>>&&);
  • trunk/Source/WebKit/UIProcess/API/glib/WebKitLoaderClient.cpp

    r218487 r222824  
    101101    }
    102102
    103     void didChangeBackForwardList(WebPageProxy&, WebBackForwardListItem* addedItem, Vector<RefPtr<WebBackForwardListItem>> removedItems) override
     103    void didChangeBackForwardList(WebPageProxy&, WebBackForwardListItem* addedItem, Vector<Ref<WebBackForwardListItem>>&& removedItems) override
    104104    {
    105         webkitBackForwardListChanged(webkit_web_view_get_back_forward_list(m_webView), addedItem, removedItems);
     105        webkitBackForwardListChanged(webkit_web_view_get_back_forward_list(m_webView), addedItem, WTFMove(removedItems));
    106106    }
    107107
  • trunk/Source/WebKit/UIProcess/WebBackForwardList.cpp

    r218457 r222824  
    7373    if (m_page) {
    7474        size_t size = m_entries.size();
    75         for (size_t i = 0; i < size; ++i) {
    76             ASSERT(m_entries[i]);
    77             if (!m_entries[i])
    78                 continue;
    79 
    80             didRemoveItem(*m_entries[i]);
    81         }
     75        for (size_t i = 0; i < size; ++i)
     76            didRemoveItem(m_entries[i]);
    8277    }
    8378
     
    9489        return;
    9590
    96     Vector<RefPtr<WebBackForwardListItem>> removedItems;
     91    Vector<Ref<WebBackForwardListItem>> removedItems;
    9792   
    9893    if (m_hasCurrentIndex) {
     
    10398        removedItems.reserveCapacity(m_entries.size() - targetSize);
    10499        while (m_entries.size() > targetSize) {
    105             didRemoveItem(*m_entries.last());
     100            didRemoveItem(m_entries.last());
    106101            removedItems.append(WTFMove(m_entries.last()));
    107102            m_entries.removeLast();
     
    111106        // (or even if we are, if we only want 1 entry).
    112107        if (m_entries.size() == m_capacity && (m_currentIndex || m_capacity == 1)) {
    113             didRemoveItem(*m_entries[0]);
     108            didRemoveItem(m_entries[0]);
    114109            removedItems.append(WTFMove(m_entries[0]));
    115110            m_entries.remove(0);
     
    127122        size_t size = m_entries.size();
    128123        for (size_t i = 0; i < size; ++i) {
    129             ASSERT(m_entries[i]);
    130             if (!m_entries[i])
    131                 continue;
    132             didRemoveItem(*m_entries[i]);
     124            didRemoveItem(m_entries[i]);
    133125            removedItems.append(WTFMove(m_entries[i]));
    134126        }
     
    143135        m_hasCurrentIndex = true;
    144136    } else {
    145         shouldKeepCurrentItem = m_page->shouldKeepCurrentBackForwardListItemInList(m_entries[m_currentIndex].get());
     137        shouldKeepCurrentItem = m_page->shouldKeepCurrentBackForwardListItemInList(m_entries[m_currentIndex]);
    146138        if (shouldKeepCurrentItem)
    147139            m_currentIndex++;
     
    153145        ASSERT(m_currentIndex < m_entries.size());
    154146
    155         removedItems.append(m_entries[m_currentIndex]);
    156         m_entries[m_currentIndex] = newItem;
     147        removedItems.append(m_entries[m_currentIndex].copyRef());
     148        m_entries[m_currentIndex] = *newItem;
    157149    } else {
    158150        // m_current should never be pointing more than 1 past the end of the entries Vector.
     
    161153
    162154        if (m_currentIndex <= m_entries.size())
    163             m_entries.insert(m_currentIndex, newItem);
     155            m_entries.insert(m_currentIndex, *newItem);
    164156    }
    165157
     
    167159}
    168160
    169 void WebBackForwardList::goToItem(WebBackForwardListItem* item)
    170 {
    171     ASSERT(!m_hasCurrentIndex || m_currentIndex < m_entries.size());
    172 
    173     if (!m_entries.size() || !item || !m_page || !m_hasCurrentIndex)
     161void WebBackForwardList::goToItem(WebBackForwardListItem& item)
     162{
     163    ASSERT(!m_hasCurrentIndex || m_currentIndex < m_entries.size());
     164
     165    if (!m_entries.size() || !m_page || !m_hasCurrentIndex)
    174166        return;
    175167
    176     size_t targetIndex = m_entries.find(item);
     168    size_t targetIndex = notFound;
     169    for (size_t i = 0; i < m_entries.size(); ++i) {
     170        if (m_entries[i].ptr() == &item) {
     171            targetIndex = i;
     172            break;
     173        }
     174    }
    177175
    178176    // If the target item wasn't even in the list, there's nothing else to do.
     
    188186    // If we're going to an item different from the current item, ask the client if the current
    189187    // item should remain in the list.
    190     WebBackForwardListItem* currentItem = m_entries[m_currentIndex].get();
     188    auto& currentItem = m_entries[m_currentIndex];
    191189    bool shouldKeepCurrentItem = true;
    192     if (currentItem != item) {
     190    if (currentItem.ptr() != &item) {
    193191        m_page->recordAutomaticNavigationSnapshot();
    194         shouldKeepCurrentItem = m_page->shouldKeepCurrentBackForwardListItemInList(m_entries[m_currentIndex].get());
     192        shouldKeepCurrentItem = m_page->shouldKeepCurrentBackForwardListItemInList(m_entries[m_currentIndex]);
    195193    }
    196194
    197195    // If the client said to remove the current item, remove it and then update the target index.
    198     Vector<RefPtr<WebBackForwardListItem>> removedItems;
     196    Vector<Ref<WebBackForwardListItem>> removedItems;
    199197    if (!shouldKeepCurrentItem) {
    200         removedItems.append(currentItem);
     198        removedItems.append(currentItem.copyRef());
    201199        m_entries.remove(m_currentIndex);
    202         targetIndex = m_entries.find(item);
    203 
     200        targetIndex = notFound;
     201        for (size_t i = 0; i < m_entries.size(); ++i) {
     202            if (m_entries[0].ptr() == &item) {
     203                targetIndex = i;
     204                break;
     205            }
     206        }
    204207        ASSERT(targetIndex != notFound);
    205208    }
    206209
    207210    m_currentIndex = targetIndex;
    208     m_page->didChangeBackForwardList(nullptr, removedItems);
     211    m_page->didChangeBackForwardList(nullptr, WTFMove(removedItems));
    209212}
    210213
     
    213216    ASSERT(!m_hasCurrentIndex || m_currentIndex < m_entries.size());
    214217
    215     return m_page && m_hasCurrentIndex ? m_entries[m_currentIndex].get() : nullptr;
     218    return m_page && m_hasCurrentIndex ? m_entries[m_currentIndex].ptr() : nullptr;
    216219}
    217220
     
    220223    ASSERT(!m_hasCurrentIndex || m_currentIndex < m_entries.size());
    221224
    222     return m_page && m_hasCurrentIndex && m_currentIndex ? m_entries[m_currentIndex - 1].get() : nullptr;
     225    return m_page && m_hasCurrentIndex && m_currentIndex ? m_entries[m_currentIndex - 1].ptr() : nullptr;
    223226}
    224227
     
    227230    ASSERT(!m_hasCurrentIndex || m_currentIndex < m_entries.size());
    228231
    229     return m_page && m_hasCurrentIndex && m_entries.size() && m_currentIndex < m_entries.size() - 1 ? m_entries[m_currentIndex + 1].get() : nullptr;
     232    return m_page && m_hasCurrentIndex && m_entries.size() && m_currentIndex < m_entries.size() - 1 ? m_entries[m_currentIndex + 1].ptr() : nullptr;
    230233}
    231234
     
    244247        return nullptr;
    245248       
    246     return m_entries[index + m_currentIndex].get();
     249    return m_entries[index + m_currentIndex].ptr();
    247250}
    248251
     
    287290
    288291    ASSERT(backListSize >= size);
    289     for (unsigned i = backListSize - size; i < backListSize; ++i) {
    290         ASSERT(m_entries[i]);
    291         vector.uncheckedAppend(m_entries[i].get());
    292     }
     292    for (unsigned i = backListSize - size; i < backListSize; ++i)
     293        vector.uncheckedAppend(m_entries[i].ptr());
    293294
    294295    return API::Array::create(WTFMove(vector));
     
    311312    unsigned last = m_currentIndex + size;
    312313    ASSERT(last < m_entries.size());
    313     for (unsigned i = m_currentIndex + 1; i <= last; ++i) {
    314         ASSERT(m_entries[i]);
    315         vector.uncheckedAppend(m_entries[i].get());
    316     }
     314    for (unsigned i = m_currentIndex + 1; i <= last; ++i)
     315        vector.uncheckedAppend(m_entries[i].ptr());
    317316
    318317    return API::Array::create(WTFMove(vector));
     
    323322    ASSERT(!m_hasCurrentIndex || m_currentIndex < m_entries.size());
    324323
    325     Vector<RefPtr<WebBackForwardListItem>> removedItems;
     324    Vector<Ref<WebBackForwardListItem>> removedItems;
    326325
    327326    for (auto& entry : m_entries) {
    328         ASSERT(entry);
    329         if (!entry)
    330             continue;
    331 
    332         didRemoveItem(*entry);
     327        didRemoveItem(entry);
    333328        removedItems.append(WTFMove(entry));
    334329    }
     
    348343
    349344    RefPtr<WebBackForwardListItem> currentItem = this->currentItem();
    350     Vector<RefPtr<WebBackForwardListItem>> removedItems;
     345    Vector<Ref<WebBackForwardListItem>> removedItems;
    351346
    352347    if (!currentItem) {
     
    356351        // But just in case it does happen in practice we should get back into a consistent state now.
    357352        for (size_t i = 0; i < size; ++i) {
    358             ASSERT(m_entries[i]);
    359             if (!m_entries[i])
    360                 continue;
    361 
    362             didRemoveItem(*m_entries[i]);
     353            didRemoveItem(m_entries[i]);
    363354            removedItems.append(WTFMove(m_entries[i]));
    364355        }
     
    372363
    373364    for (size_t i = 0; i < size; ++i) {
    374         ASSERT(m_entries[i]);
    375         if (m_entries[i] && m_entries[i] != currentItem)
    376             didRemoveItem(*m_entries[i]);
     365        if (m_entries[i].ptr() != currentItem)
     366            didRemoveItem(m_entries[i]);
    377367    }
    378368
    379369    removedItems.reserveCapacity(size - 1);
    380370    for (size_t i = 0; i < size; ++i) {
    381         if (i != m_currentIndex && m_hasCurrentIndex && m_entries[i])
     371        if (i != m_currentIndex && m_hasCurrentIndex)
    382372            removedItems.append(WTFMove(m_entries[i]));
    383373    }
     
    387377    if (currentItem) {
    388378        m_entries.shrink(1);
    389         m_entries[0] = WTFMove(currentItem);
     379        m_entries[0] = currentItem.releaseNonNull();
    390380    } else {
    391381        m_entries.clear();
     
    405395
    406396    for (size_t i = 0; i < m_entries.size(); ++i) {
    407         auto& entry = *m_entries[i];
     397        auto& entry = m_entries[i];
    408398
    409399        if (filter && !filter(entry)) {
     
    415405        }
    416406
    417         backForwardListState.items.append(entry.itemState());
     407        backForwardListState.items.append(entry->itemState());
    418408    }
    419409
     
    428418void WebBackForwardList::restoreFromState(BackForwardListState backForwardListState)
    429419{
    430     Vector<RefPtr<WebBackForwardListItem>> items;
     420    Vector<Ref<WebBackForwardListItem>> items;
    431421    items.reserveInitialCapacity(backForwardListState.items.size());
    432422
  • trunk/Source/WebKit/UIProcess/WebBackForwardList.h

    r218457 r222824  
    2424 */
    2525
    26 #ifndef WebBackForwardList_h
    27 #define WebBackForwardList_h
     26#pragma once
    2827
    2928#include "APIObject.h"
     
    3130#include "WebPageProxy.h"
    3231#include <wtf/Ref.h>
    33 #include <wtf/RefPtr.h>
    3432#include <wtf/Vector.h>
    35 #if USE(CF)
    36 #include <CoreFoundation/CFDictionary.h>
    37 #endif
    3833
    3934namespace WebKit {
     
    5247
    5348    void addItem(WebBackForwardListItem*);
    54     void goToItem(WebBackForwardListItem*);
     49    void goToItem(WebBackForwardListItem&);
    5550    void removeAllItems();
    5651    void clear();
     
    8681    BackForwardListItemVector m_entries;
    8782   
     83    // FIXME: m_currentIndex should be a std::optional<size_t>
    8884    bool m_hasCurrentIndex;
    89     unsigned m_currentIndex;
    90     unsigned m_capacity;
     85    size_t m_currentIndex;
     86    size_t m_capacity;
    9187};
    9288
    9389} // namespace WebKit
    94 
    95 #endif // WebBackForwardList_h
  • trunk/Source/WebKit/UIProcess/WebPageProxy.cpp

    r222809 r222824  
    685685
    686686    if (item != m_backForwardList->currentItem())
    687         m_backForwardList->goToItem(item);
     687        m_backForwardList->goToItem(*item);
    688688
    689689    auto navigation = m_navigationState->createBackForwardNavigation();
     
    699699    ASSERT(isValid());
    700700
    701     BackForwardListItemVector items = m_backForwardList->entries();
     701    const BackForwardListItemVector& items = m_backForwardList->entries();
    702702    for (size_t i = 0; i < items.size(); ++i)
    703703        m_process->registerNewWebBackForwardListItem(items[i].get());
     
    11931193}
    11941194
    1195 void WebPageProxy::didChangeBackForwardList(WebBackForwardListItem* added, Vector<RefPtr<WebBackForwardListItem>> removed)
     1195void WebPageProxy::didChangeBackForwardList(WebBackForwardListItem* added, Vector<Ref<WebBackForwardListItem>>&& removed)
    11961196{
    11971197    PageClientProtector protector(m_pageClient);
     
    12161216}
    12171217
    1218 bool WebPageProxy::shouldKeepCurrentBackForwardListItemInList(WebBackForwardListItem* item)
     1218bool WebPageProxy::shouldKeepCurrentBackForwardListItemInList(WebBackForwardListItem& item)
    12191219{
    12201220    PageClientProtector protector(m_pageClient);
     
    44954495    if (createdExtension)
    44964496        m_process->willAcquireUniversalFileReadSandboxExtension();
    4497     m_backForwardList->goToItem(item);
     4497    m_backForwardList->goToItem(*item);
    44984498}
    44994499
  • trunk/Source/WebKit/UIProcess/WebPageProxy.h

    r222794 r222824  
    410410    RefPtr<API::Navigation> goToBackForwardItem(WebBackForwardListItem*);
    411411    void tryRestoreScrollPosition();
    412     void didChangeBackForwardList(WebBackForwardListItem* addedItem, Vector<RefPtr<WebBackForwardListItem>> removed);
     412    void didChangeBackForwardList(WebBackForwardListItem* addedItem, Vector<Ref<WebBackForwardListItem>>&& removed);
    413413    void willGoToBackForwardListItem(uint64_t itemID, bool inPageCache, const UserData&);
    414414
    415     bool shouldKeepCurrentBackForwardListItemInList(WebBackForwardListItem*);
     415    bool shouldKeepCurrentBackForwardListItemInList(WebBackForwardListItem&);
    416416
    417417    bool willHandleHorizontalScrollEvents() const;
  • trunk/Source/WebKit/UIProcess/WebProcessProxy.cpp

    r220857 r222824  
    425425}
    426426
    427 void WebProcessProxy::registerNewWebBackForwardListItem(WebBackForwardListItem* item)
     427void WebProcessProxy::registerNewWebBackForwardListItem(WebBackForwardListItem& item)
    428428{
    429429    // This item was just created by the UIProcess and is being added to the map for the first time
    430430    // so we should not already have an item for this ID.
    431     ASSERT(!m_backForwardListItemMap.contains(item->itemID()));
    432 
    433     m_backForwardListItemMap.set(item->itemID(), item);
     431    ASSERT(!m_backForwardListItemMap.contains(item.itemID()));
     432
     433    m_backForwardListItemMap.set(item.itemID(), &item);
    434434}
    435435
  • trunk/Source/WebKit/UIProcess/WebProcessProxy.h

    r222664 r222824  
    124124    void updateTextCheckerState();
    125125
    126     void registerNewWebBackForwardListItem(WebBackForwardListItem*);
     126    void registerNewWebBackForwardListItem(WebBackForwardListItem&);
    127127    void removeBackForwardItem(uint64_t);
    128128
  • trunk/Source/WebKit/WebProcess/WebPage/WebBackForwardListProxy.cpp

    r217564 r222824  
    173173{
    174174    if (!m_page)
    175         return 0;
     175        return nullptr;
    176176
    177177    uint64_t itemID = 0;
    178178    if (!WebProcess::singleton().parentProcessConnection()->sendSync(Messages::WebPageProxy::BackForwardItemAtIndex(itemIndex), Messages::WebPageProxy::BackForwardItemAtIndex::Reply(itemID), m_page->pageID()))
    179         return 0;
     179        return nullptr;
    180180
    181181    if (!itemID)
    182         return 0;
     182        return nullptr;
    183183
    184184    return idToHistoryItemMap().get(itemID);
Note: See TracChangeset for help on using the changeset viewer.