Changeset 141708 in webkit


Ignore:
Timestamp:
Feb 2, 2013 3:50:18 PM (11 years ago)
Author:
weinig@apple.com
Message:

Stop keeping a frame tree in the UIProcess
​https://bugs.webkit.org/show_bug.cgi?id=81728

Reviewed by Oliver Hunt.

This patch removes the parent/child relationships of WebFrameProxys
in the UIProcess

  • UIProcess/API/C/WKFrame.cpp:

(WKFrameCopyChildFrames):
(WKFrameGetParentFrame):

  • UIProcess/API/C/WKFrame.h:

Null out the implementations of WKFrameCopyChildFrames and WKFrameGetParentFrame,
but keep them around as their symbols are still needed for nightlies.

  • UIProcess/WebFrameProxy.cpp:

(WebKit::WebFrameProxy::WebFrameProxy):
(WebKit::WebFrameProxy::disconnect):

  • UIProcess/WebFrameProxy.h:

Remove parent/child connections.

  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::didCreateSubframe):
(WebKit::WebPageProxy::didRemoveFrameFromHierarchy):

  • UIProcess/WebPageProxy.h:
  • UIProcess/WebPageProxy.messages.in:
  • WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:

(WebKit::WebFrameLoaderClient::didSaveToPageCache):
(WebKit::WebFrameLoaderClient::didRestoreFromPageCache):

  • WebProcess/WebPage/WebFrame.cpp:

(WebKit::WebFrame::createSubframe):
Remove/Update messages that only served to update the parent/child connection.

Location:
trunk/Source/WebKit2
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r141705 r141708  
     12013-02-02  Sam Weinig  <sam@webkit.org>
     2
     3        Stop keeping a frame tree in the UIProcess
     4        https://bugs.webkit.org/show_bug.cgi?id=81728
     5
     6        Reviewed by Oliver Hunt.
     7
     8        This patch removes the parent/child relationships of WebFrameProxys
     9        in the UIProcess
     10
     11        * UIProcess/API/C/WKFrame.cpp:
     12        (WKFrameCopyChildFrames):
     13        (WKFrameGetParentFrame):
     14        * UIProcess/API/C/WKFrame.h:
     15        Null out the implementations of WKFrameCopyChildFrames and WKFrameGetParentFrame,
     16        but keep them around as their symbols are still needed for nightlies.
     17
     18        * UIProcess/WebFrameProxy.cpp:
     19        (WebKit::WebFrameProxy::WebFrameProxy):
     20        (WebKit::WebFrameProxy::disconnect):
     21        * UIProcess/WebFrameProxy.h:
     22        Remove parent/child connections.
     23
     24        * UIProcess/WebPageProxy.cpp:
     25        (WebKit::WebPageProxy::didCreateSubframe):
     26        (WebKit::WebPageProxy::didRemoveFrameFromHierarchy):
     27        * UIProcess/WebPageProxy.h:
     28        * UIProcess/WebPageProxy.messages.in:
     29        * WebProcess/WebCoreSupport/WebFrameLoaderClient.cpp:
     30        (WebKit::WebFrameLoaderClient::didSaveToPageCache):
     31        (WebKit::WebFrameLoaderClient::didRestoreFromPageCache):
     32        * WebProcess/WebPage/WebFrame.cpp:
     33        (WebKit::WebFrame::createSubframe):
     34        Remove/Update messages that only served to update the parent/child connection.
     35
    1362013-02-02  Sam Weinig  <sam@webkit.org>
    237

  • trunk/Source/WebKit2/UIProcess/API/C/WKFrame.cpp

    r99239 r141708  
    9797}
    9898
    99 WKArrayRef WKFrameCopyChildFrames(WKFrameRef frameRef)
    100 {
    101     return toAPI(toImpl(frameRef)->childFrames().leakRef());
    102 }
    103 
    104 WKFrameRef WKFrameGetParentFrame(WKFrameRef frameRef)
    105 {
    106     return toAPI(toImpl(frameRef)->parentFrame());
    107 }
    108 
    10999WKCertificateInfoRef WKFrameGetCertificateInfo(WKFrameRef frameRef)
    110100{
    … …  
    184174}
    185175#endif
     176
     177
     178// NOTE: These are deprecated and should be removed. They currently do nothing.
     179
     180WKArrayRef WKFrameCopyChildFrames(WKFrameRef)
     181{
     182    return 0;
     183}
     184
     185WKFrameRef WKFrameGetParentFrame(WKFrameRef)
     186{
     187    return 0;
     188}

  • trunk/Source/WebKit2/UIProcess/API/C/WKFrame.h

    r95901 r141708  
    5959WK_EXPORT WKPageRef WKFrameGetPage(WKFrameRef frame);
    6060
    61 WK_EXPORT WKArrayRef WKFrameCopyChildFrames(WKFrameRef frame);
    62 
    63 WK_EXPORT WKFrameRef WKFrameGetParentFrame(WKFrameRef frame);
    64 
    6561WK_EXPORT WKCertificateInfoRef WKFrameGetCertificateInfo(WKFrameRef frame);
    6662
    … …  
    8985#endif
    9086
     87
     88// NOTE: These are deprecated and should be removed. They currently do nothing.
     89
     90WK_EXPORT WKArrayRef WKFrameCopyChildFrames(WKFrameRef frame);
     91WK_EXPORT WKFrameRef WKFrameGetParentFrame(WKFrameRef frame);
     92
    9193#ifdef __cplusplus
    9294}

  • trunk/Source/WebKit2/UIProcess/WebFrameProxy.cpp

    r138622 r141708  
    4545WebFrameProxy::WebFrameProxy(WebPageProxy* page, uint64_t frameID)
    4646    : m_page(page)
    47     , m_parentFrame(0)
    48     , m_nextSibling(0)
    49     , m_previousSibling(0)
    50     , m_firstChild(0)
    51     , m_lastChild(0)
    5247    , m_loadState(LoadStateFinished)
    5348    , m_isFrameSet(false)
    … …  
    6560{
    6661    m_page = 0;
    67     m_parentFrame = 0;
    68     m_nextSibling = 0;
    69     m_previousSibling = 0;
    70     m_firstChild = 0;
    71     m_lastChild = 0;
    7262
    7363    if (m_activeListener) {
    … …  
    197187}
    198188
    199 void WebFrameProxy::appendChild(WebFrameProxy* child)
    200 {
    201     ASSERT(child->page() == page());
    202     ASSERT(!child->m_parentFrame);
    203     ASSERT(!child->m_nextSibling);
    204     ASSERT(!child->m_previousSibling);
    205 
    206     child->m_parentFrame = this;
    207 
    208     WebFrameProxy* oldLast = m_lastChild;
    209     m_lastChild = child;
    210 
    211     if (oldLast) {
    212         ASSERT(!oldLast->m_nextSibling);
    213         child->m_previousSibling = oldLast;
    214         oldLast->m_nextSibling = child;
    215     } else
    216         m_firstChild = child;
    217 }
    218 
    219 void WebFrameProxy::removeChild(WebFrameProxy* child)
    220 {
    221     child->m_parentFrame = 0;
    222 
    223     WebFrameProxy*& newLocationForNext = m_firstChild == child ? m_firstChild : child->m_previousSibling->m_nextSibling;
    224     WebFrameProxy*& newLocationForPrevious = m_lastChild == child ? m_lastChild : child->m_nextSibling->m_previousSibling;
    225     swap(newLocationForNext, child->m_nextSibling);
    226     swap(newLocationForPrevious, child->m_previousSibling);
    227     child->m_previousSibling = 0;
    228     child->m_nextSibling = 0;
    229 }
    230 
    231 bool WebFrameProxy::isDescendantOf(const WebFrameProxy* ancestor) const
    232 {
    233     if (!ancestor)
    234         return false;
    235 
    236     if (m_page != ancestor->m_page)
    237         return false;
    238 
    239     for (const WebFrameProxy* frame = this; frame; frame = frame->m_parentFrame) {
    240         if (frame == ancestor)
    241             return true;
    242     }
    243 
    244     return false;
    245 }
    246 
    247 void WebFrameProxy::dumpFrameTreeToSTDOUT(unsigned indent)
    248 {
    249     if (!indent && m_parentFrame)
    250         printf("NOTE: Printing subtree.\n");
    251 
    252     for (unsigned i = 0; i < indent; ++i)
    253         printf(" ");
    254     printf("| FRAME %d %s\n", (int)m_frameID, m_url.utf8().data());
    255 
    256     for (WebFrameProxy* child = m_firstChild; child; child = child->m_nextSibling)
    257         child->dumpFrameTreeToSTDOUT(indent + 4);
    258 }
    259 
    260 void WebFrameProxy::didRemoveFromHierarchy()
    261 {
    262     if (m_parentFrame)
    263         m_parentFrame->removeChild(this);
    264 }
    265 
    266 PassRefPtr<ImmutableArray> WebFrameProxy::childFrames()
    267 {
    268     if (!m_firstChild)
    269         return ImmutableArray::create();
    270 
    271     Vector<RefPtr<APIObject> > vector;
    272     for (WebFrameProxy* child = m_firstChild; child; child = child->m_nextSibling)
    273         vector.append(child);
    274 
    275     return ImmutableArray::adopt(vector);
    276 }
    277 
    278189void WebFrameProxy::receivedPolicyDecision(WebCore::PolicyAction action, uint64_t listenerID)
    279190{

  • trunk/Source/WebKit2/UIProcess/WebFrameProxy.h

    r141472 r141708  
    7272    WebPageProxy* page() const { return m_page; }
    7373
    74     WebFrameProxy* parentFrame() { return m_parentFrame; }
    75     WebFrameProxy* nextSibling() { return m_nextSibling; }
    76     WebFrameProxy* previousSibling() { return m_previousSibling; }
    77     WebFrameProxy* firstChild() { return m_firstChild; }
    78     WebFrameProxy* lastChild() { return m_lastChild; }
    79 
    8074    void disconnect();
    8175
    … …  
    121115    void didChangeTitle(const String&);
    122116
    123     // Frame tree operations.
    124     void appendChild(WebFrameProxy*);
    125     void removeChild(WebFrameProxy*);
    126     void didRemoveFromHierarchy();
    127     PassRefPtr<ImmutableArray> childFrames();
    128     bool isDescendantOf(const WebFrameProxy* ancestor) const;
    129     void dumpFrameTreeToSTDOUT(unsigned indent = 0);
    130 
    131117    // Policy operations.
    132118    void receivedPolicyDecision(WebCore::PolicyAction, uint64_t listenerID);
    … …  
    140126
    141127    WebPageProxy* m_page;
    142     WebFrameProxy* m_parentFrame;
    143     WebFrameProxy* m_nextSibling;
    144     WebFrameProxy* m_previousSibling;
    145     WebFrameProxy* m_firstChild;
    146     WebFrameProxy* m_lastChild;
    147 
    148128    LoadState m_loadState;
    149129    String m_url;

  • trunk/Source/WebKit2/UIProcess/WebPageProxy.cpp

    r141528 r141708  
    19981998}
    19991999
    2000 void WebPageProxy::didCreateSubframe(uint64_t frameID, uint64_t parentFrameID)
     2000void WebPageProxy::didCreateSubframe(uint64_t frameID)
    20012001{
    20022002    MESSAGE_CHECK(m_mainFrame);
    2003 
    2004     WebFrameProxy* parentFrame = m_process->webFrame(parentFrameID);
    2005     MESSAGE_CHECK(parentFrame);
    2006     MESSAGE_CHECK(parentFrame->isDescendantOf(m_mainFrame.get()));
    2007 
    20082003    MESSAGE_CHECK(m_process->canCreateFrame(frameID));
    20092004   
    … …  
    20122007    // Add the frame to the process wide map.
    20132008    m_process->frameCreated(frameID, subFrame.get());
    2014 
    2015     // Insert the frame into the frame hierarchy.
    2016     parentFrame->appendChild(subFrame.get());
    2017 }
    2018 
    2019 static bool isDisconnectedFrame(WebFrameProxy* frame)
    2020 {
    2021     return !frame->page() || !frame->page()->mainFrame() || !frame->isDescendantOf(frame->page()->mainFrame());
    2022 }
    2023 
    2024 void WebPageProxy::didSaveFrameToPageCache(uint64_t frameID)
    2025 {
    2026     MESSAGE_CHECK(m_mainFrame);
    2027 
    2028     WebFrameProxy* subframe = m_process->webFrame(frameID);
    2029     MESSAGE_CHECK(subframe);
    2030 
    2031     if (isDisconnectedFrame(subframe))
    2032         return;
    2033 
    2034     MESSAGE_CHECK(subframe->isDescendantOf(m_mainFrame.get()));
    2035 
    2036     subframe->didRemoveFromHierarchy();
    2037 }
    2038 
    2039 void WebPageProxy::didRestoreFrameFromPageCache(uint64_t frameID, uint64_t parentFrameID)
    2040 {
    2041     MESSAGE_CHECK(m_mainFrame);
    2042 
    2043     WebFrameProxy* subframe = m_process->webFrame(frameID);
    2044     MESSAGE_CHECK(subframe);
    2045     MESSAGE_CHECK(!subframe->parentFrame());
    2046     MESSAGE_CHECK(subframe->page() == m_mainFrame->page());
    2047 
    2048     WebFrameProxy* parentFrame = m_process->webFrame(parentFrameID);
    2049     MESSAGE_CHECK(parentFrame);
    2050     MESSAGE_CHECK(parentFrame->isDescendantOf(m_mainFrame.get()));
    2051 
    2052     // Insert the frame into the frame hierarchy.
    2053     parentFrame->appendChild(subframe);
    2054 }
    2055 
     2009}
    20562010
    20572011// Always start progress at initialProgressValue. This helps provide feedback as
    … …  
    23302284    WebFrameProxy* frame = m_process->webFrame(frameID);
    23312285    MESSAGE_CHECK(frame);
    2332 
    2333     frame->didRemoveFromHierarchy();
    23342286
    23352287    m_loaderClient.didRemoveFrameFromHierarchy(this, frame, userData.get());

  • trunk/Source/WebKit2/UIProcess/WebPageProxy.h

    r141486 r141708  
    766766
    767767    void didCreateMainFrame(uint64_t frameID);
    768     void didCreateSubframe(uint64_t frameID, uint64_t parentFrameID);
    769     void didSaveFrameToPageCache(uint64_t frameID);
    770     void didRestoreFrameFromPageCache(uint64_t frameID, uint64_t parentFrameID);
     768    void didCreateSubframe(uint64_t frameID);
    771769
    772770    void didStartProvisionalLoadForFrame(uint64_t frameID, const String& url, const String& unreachableURL, CoreIPC::MessageDecoder&);

  • trunk/Source/WebKit2/UIProcess/WebPageProxy.messages.in

    r141486 r141708  
    112112    # Frame lifetime messages
    113113    DidCreateMainFrame(uint64_t frameID)
    114     DidCreateSubframe(uint64_t frameID, uint64_t parentFrameID)
    115     DidSaveFrameToPageCache(uint64_t frameID);
    116     DidRestoreFrameFromPageCache(uint64_t frameID, uint64_t parentFrameID);
     114    DidCreateSubframe(uint64_t frameID)
    117115
    118116    # Frame load messages

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

    r141448 r141708  
    12381238void WebFrameLoaderClient::didSaveToPageCache()
    12391239{
    1240     WebPage* webPage = m_frame->page();
    1241     if (!webPage)
    1242         return;
    1243 
    1244     if (m_frame->isMainFrame())
    1245         return;
    1246 
    1247     webPage->send(Messages::WebPageProxy::DidSaveFrameToPageCache(m_frame->frameID()));
    12481240}
    12491241
    12501242void WebFrameLoaderClient::didRestoreFromPageCache()
    12511243{
    1252     WebPage* webPage = m_frame->page();
    1253     if (!webPage)
    1254         return;
    1255 
    1256     if (m_frame->isMainFrame())
    1257         return;
    1258 
    1259     WebFrame* parentFrame = static_cast<WebFrameLoaderClient*>(m_frame->coreFrame()->tree()->parent()->loader()->client())->webFrame();
    1260     webPage->send(Messages::WebPageProxy::DidRestoreFrameFromPageCache(m_frame->frameID(), parentFrame->frameID()));
    12611244}
    12621245

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

    r141656 r141708  
    115115    RefPtr<WebFrame> frame = create();
    116116
    117     WebFrame* parentFrame = static_cast<WebFrameLoaderClient*>(ownerElement->document()->frame()->loader()->client())->webFrame();
    118     page->send(Messages::WebPageProxy::DidCreateSubframe(frame->frameID(), parentFrame->frameID()));
     117    page->send(Messages::WebPageProxy::DidCreateSubframe(frame->frameID()));
    119118
    120119    frame->init(page, frameName, ownerElement);
Note: See TracChangeset for help on using the changeset viewer.