Move the frame tree into the embedder.

Source/web/WebFrameImpl.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 629 matching lines @@
     return fromFrame(frame()->loader().opener());
 }
 
 void WebFrameImpl::setOpener(const WebFrame* webFrame)
 {
     frame()->loader().setOpener(webFrame ? toWebFrameImpl(webFrame)->frame() : 0);
 }
 
 void WebFrameImpl::appendChild(WebFrame* child)
 {
-    // FIXME: Implement after this revision rolls into Chrome.
+    // FIXME: Original code asserts that the frames have the same Page. We
+    // should add an equivalent check... figure out what.
+    WebFrameImpl* childImpl = toWebFrameImpl(child);
+    childImpl->m_parent = this;
+    WebFrameImpl* oldLast = m_lastChild;
+    m_lastChild = childImpl;
+
+    if (oldLast) {
+        childImpl->m_previousSibling = oldLast;
+        oldLast->m_nextSibling = childImpl;
+    } else {
+        m_firstChild = childImpl;
+    }
+    // FIXME: Not sure if this is a legitimate assert.
+    ASSERT(frame());
+    frame()->tree().invalidateScopedChildCount();
 }
 
 void WebFrameImpl::removeChild(WebFrame* child)
 {
-    // FIXME: Implement after this revision rolls into Chrome.
+    WebFrameImpl* childImpl = toWebFrameImpl(child);
+    childImpl->m_parent = 0;
+
+    if (m_firstChild == childImpl)
+        m_firstChild = childImpl->m_nextSibling;
+    else
+        childImpl->m_previousSibling->m_nextSibling = childImpl->m_nextSibling;
+
+    if (m_lastChild == childImpl)
+        m_lastChild = childImpl->m_previousSibling;
+    else
+        childImpl->m_nextSibling->m_previousSibling = childImpl->m_previousSibling;
+
+    childImpl->m_previousSibling = childImpl->m_nextSibling = 0;
+    // FIXME: Not sure if this is a legitimate assert.
+    ASSERT(frame());
+    frame()->tree().invalidateScopedChildCount();
 }
 
 WebFrame* WebFrameImpl::parent() const
 {
-    if (!frame())
-        return 0;
-    return fromFrame(frame()->tree().parent());
+    return m_parent;
 }
 
 WebFrame* WebFrameImpl::top() const
 {
-    if (!frame())
-        return 0;
-    return fromFrame(frame()->tree().top());
+    // FIXME: I am a bad person.

[eseidel, 2014/02/13 23:49:40]

This is not particularly helpful. :)  It's not clear that these should be const
in the first place.

[dcheng, 2014/02/14 20:29:28]

The original versions were const. Making these non-const would have ripple
effects elsewhere. I've removed the comment for now.

+    WebFrameImpl* frame = const_cast<WebFrameImpl*>(this);
+    for (WebFrameImpl* parent = frame; parent; parent = parent->m_parent)
+        frame = parent;
+    return frame;
+}
+
+WebFrame* WebFrameImpl::previousSibling() const
+{
+    return m_previousSibling;
+}
+
+WebFrame* WebFrameImpl::nextSibling() const
+{
+    return m_nextSibling;
 }
 
 WebFrame* WebFrameImpl::firstChild() const
 {
-    if (!frame())
-        return 0;
-    return fromFrame(frame()->tree().firstChild());
+    return m_firstChild;
 }
 
 WebFrame* WebFrameImpl::lastChild() const
 {
-    if (!frame())
-        return 0;
-    return fromFrame(frame()->tree().lastChild());
+    return m_lastChild;
 }
 
-WebFrame* WebFrameImpl::nextSibling() const
+WebFrame* WebFrameImpl::traversePrevious(bool wrap) const
 {
     if (!frame())
         return 0;
-    return fromFrame(frame()->tree().nextSibling());
-}
-
-WebFrame* WebFrameImpl::previousSibling() const
-{
-    if (!frame())
-        return 0;
-    return fromFrame(frame()->tree().previousSibling());
+    return fromFrame(frame()->tree().traversePreviousWithWrap(wrap));
 }
 
 WebFrame* WebFrameImpl::traverseNext(bool wrap) const
 {
     if (!frame())
         return 0;
     return fromFrame(frame()->tree().traverseNextWithWrap(wrap));
 }
 
-WebFrame* WebFrameImpl::traversePrevious(bool wrap) const
-{
-    if (!frame())
-        return 0;
-    return fromFrame(frame()->tree().traversePreviousWithWrap(wrap));
-}
-
 WebFrame* WebFrameImpl::findChildByName(const WebString& name) const
 {
     if (!frame())
         return 0;
     return fromFrame(frame()->tree().child(name));
 }
 
 WebFrame* WebFrameImpl::findChildByExpression(const WebString& xpath) const
 {
     if (xpath.isEmpty())
@@ skipping 1362 matching lines @@
     return WebFrameImpl::create(client, generateEmbedderIdentifier());
 }
 
 WebFrameImpl* WebFrameImpl::create(WebFrameClient* client, long long embedderIdentifier)
 {
     return adoptRef(new WebFrameImpl(client, embedderIdentifier)).leakRef();
 }
 
 WebFrameImpl::WebFrameImpl(WebFrameClient* client, long long embedderIdentifier)
     : m_frameInit(WebFrameInit::create(this, embedderIdentifier))
+    , m_parent(0)
+    , m_previousSibling(0)
+    , m_nextSibling(0)
+    , m_firstChild(0)
+    , m_lastChild(0)
     , m_client(client)
     , m_permissionClient(0)
     , m_currentActiveMatchFrame(0)
     , m_activeMatchIndexInCurrentFrame(-1)
     , m_locatingActiveRect(false)
     , m_resumeScopingFromRange(0)
     , m_lastMatchCount(-1)
     , m_totalMatchCount(-1)
     , m_framesScopingCount(-1)
     , m_findRequestIdentifier(-1)
@@ skipping 38 matching lines @@
     if (!webframe)
         return 0;
 
     webframe->m_frameInit->setFrameHost(frame()->host());
     webframe->m_frameInit->setOwnerElement(ownerElement);
     RefPtr<Frame> childFrame = Frame::create(webframe->m_frameInit);
     webframe->setWebCoreFrame(childFrame);
 
     childFrame->tree().setName(request.frameName());
 
-    frame()->tree().appendChild(childFrame);
-
+    // FIXME: This comment is not quite accurate anymore.
     // Frame::init() can trigger onload event in the parent frame,
     // which may detach this frame and trigger a null-pointer access
     // in FrameTree::removeChild. Move init() after appendChild call
     // so that webframe->mFrame is in the tree before triggering
     // onload event handler.
     // Because the event handler may set webframe->mFrame to null,
     // it is necessary to check the value after calling init() and
     // return without loading URL.
     // NOTE: m_client will be null if this frame has been detached.
     // (b:791612)
@@ skipping 320 matching lines @@
 
         // There is a possibility that the frame being detached was the only
         // pending one. We need to make sure final replies can be sent.
         flushCurrentScopingEffort(m_findRequestIdentifier);
 
         cancelPendingScopingEffort();
     }
 }
 
 } // namespace blink