Move the frame tree into the embedder.

Source/core/page/FrameTree.cpp

 /*
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  * Copyright (C) 2006 Apple Computer, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "config.h"
 #include "core/page/FrameTree.h"
 
 #include "core/dom/Document.h"
 #include "core/frame/Frame.h"
 #include "core/frame/FrameView.h"
+#include "core/loader/FrameLoaderClient.h"
 #include "core/page/Page.h"
 #include "core/page/PageGroup.h"
 #include "wtf/Vector.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 
 using std::swap;
 
 namespace WebCore {
 
+namespace {
+
+const unsigned invalidChildCount = ~0;
+
+} // namespace
+
+FrameTree::FrameTree(Frame* thisFrame)
+    : m_thisFrame(thisFrame)
+    , m_scopedChildCount(invalidChildCount)
+{
+}
+
 FrameTree::~FrameTree()
 {
+    // FIXME: Why is this here? Doesn't this parallel what we already do in ~Frame?
     for (Frame* child = firstChild(); child; child = child->tree().nextSibling())
         child->setView(0);
 }
 
 void FrameTree::setName(const AtomicString& name)
 {
     m_name = name;
     if (!parent()) {
         m_uniqueName = name;
         return;
     }
     m_uniqueName = AtomicString(); // Remove our old frame name so it's not considered in uniqueChildName.
     m_uniqueName = parent()->tree().uniqueChildName(name);
 }
 
 Frame* FrameTree::parent() const
 {
-    return m_parent;
+    if (!m_thisFrame->loader().client())
+        return 0;
+    return m_thisFrame->loader().client()->parent();
 }
 
-void FrameTree::appendChild(PassRefPtr<Frame> child)
+Frame* FrameTree::top() const
 {
-    ASSERT(child->page() == m_thisFrame->page());
-    child->tree().m_parent = m_thisFrame;
-    Frame* oldLast = m_lastChild;
-    m_lastChild = child.get();
-
-    if (oldLast) {
-        child->tree().m_previousSibling = oldLast;
-        oldLast->tree().m_nextSibling = child;
-    } else
-        m_firstChild = child;
-
-    m_scopedChildCount = invalidCount;
-
-    ASSERT(!m_lastChild->tree().m_nextSibling);
+    // FIXME: top() should never return null, so here are some hacks to deal
+    // with EmptyFrameLoaderClient and cases where the frame is detached
+    // already...
+    if (!m_thisFrame->loader().client())
+        return m_thisFrame;
+    Frame* candidate = m_thisFrame->loader().client()->top();
+    return candidate ? candidate : m_thisFrame;
 }
 
-void FrameTree::removeChild(Frame* child)
+Frame* FrameTree::previousSibling() const
 {
-    child->tree().m_parent = 0;
+    if (!m_thisFrame->loader().client())
+        return 0;
+    return m_thisFrame->loader().client()->previousSibling();
+}
 
-    // Slightly tricky way to prevent deleting the child until we are done with it, w/o
-    // extra refs. These swaps leave the child in a circular list by itself. Clearing its
-    // previous and next will then finally deref it.
+Frame* FrameTree::nextSibling() const
+{
+    if (!m_thisFrame->loader().client())
+        return 0;
+    return m_thisFrame->loader().client()->nextSibling();
+}
 
-    RefPtr<Frame>& newLocationForNext = m_firstChild == child ? m_firstChild : child->tree().m_previousSibling->tree().m_nextSibling;
-    Frame*& newLocationForPrevious = m_lastChild == child ? m_lastChild : child->tree().m_nextSibling->tree().m_previousSibling;
-    swap(newLocationForNext, child->tree().m_nextSibling);
-    // For some inexplicable reason, the following line does not compile without the explicit std:: namespace
-    std::swap(newLocationForPrevious, child->tree().m_previousSibling);
+Frame* FrameTree::firstChild() const
+{
+    if (!m_thisFrame->loader().client())
+        return 0;
+    return m_thisFrame->loader().client()->firstChild();
+}
 
-    child->tree().m_previousSibling = 0;
-    child->tree().m_nextSibling = 0;
-
-    m_scopedChildCount = invalidCount;
+Frame* FrameTree::lastChild() const
+{
+    if (!m_thisFrame->loader().client())
+        return 0;
+    return m_thisFrame->loader().client()->lastChild();
 }
 
 AtomicString FrameTree::uniqueChildName(const AtomicString& requestedName) const
 {
     if (!requestedName.isEmpty() && !child(requestedName) && requestedName != "_blank")
         return requestedName;
 
     // Create a repeatable name for a child about to be added to us. The name must be
     // unique within the frame tree. The string we generate includes a "path" of names
     // from the root frame down to us. For this path to be unique, each set of siblings must
@@ skipping 19 matching lines @@
         name.append(frame->tree().uniqueName().string().substring(framePathPrefixLength,
             frame->tree().uniqueName().length() - framePathPrefixLength - framePathSuffixLength));
     }
     for (int i = chain.size() - 1; i >= 0; --i) {
         frame = chain[i];
         name.append('/');
         name.append(frame->tree().uniqueName());
     }
 
     name.appendLiteral("/<!--frame");
-    name.appendNumber(childCount());
+    name.appendNumber(childCount() - 1);
     name.appendLiteral("-->-->");
 
     return name.toAtomicString();
 }
 
 Frame* FrameTree::scopedChild(unsigned index) const
 {
     TreeScope* scope = m_thisFrame->document();
     if (!scope)
         return 0;
@@ skipping 31 matching lines @@
     for (Frame* result = firstChild(); result; result = result->tree().nextSibling()) {
         if (result->inScope(scope))
             scopedCount++;
     }
 
     return scopedCount;
 }
 
 unsigned FrameTree::scopedChildCount() const
 {
-    if (m_scopedChildCount == invalidCount)
+    if (m_scopedChildCount == invalidChildCount)
         m_scopedChildCount = scopedChildCount(m_thisFrame->document());
     return m_scopedChildCount;
 }
 
+void FrameTree::invalidateScopedChildCount()
+{
+    m_scopedChildCount = invalidChildCount;
+}
+
 unsigned FrameTree::childCount() const
 {
     unsigned count = 0;
     for (Frame* result = firstChild(); result; result = result->tree().nextSibling())
         ++count;
     return count;
 }
 
 Frame* FrameTree::child(const AtomicString& name) const
 {
@@ skipping 128 matching lines @@
 
 Frame* FrameTree::deepLastChild() const
 {
     Frame* result = m_thisFrame;
     for (Frame* last = lastChild(); last; last = last->tree().lastChild())
         result = last;
 
     return result;
 }
 
-Frame* FrameTree::top() const
-{
-    Frame* frame = m_thisFrame;
-    for (Frame* parent = m_thisFrame; parent; parent = parent->tree().parent())
-        frame = parent;
-    return frame;
-}
-
 } // namespace WebCore
 
 #ifndef NDEBUG
 
 static void printIndent(int indent)
 {
     for (int i = 0; i < indent; ++i)
         printf("    ");
 }
 
@@ skipping 24 matching lines @@
 {
     if (!frame) {
         printf("Null input frame\n");
         return;
     }
 
     printFrames(frame->tree().top(), frame, 0);
 }
 
 #endif