--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/webengine/osswebengine/WebCore/html/HTMLFrameElementBase.cpp	Mon Mar 30 12:54:55 2009 +0300
@@ -0,0 +1,343 @@
+/**
+ * This file is part of the DOM implementation for KDE.
+ *
+ * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
+ *           (C) 1999 Antti Koivisto (koivisto@kde.org)
+ *           (C) 2000 Simon Hausmann (hausmann@kde.org)
+ *           (C) 2001 Dirk Mueller (mueller@kde.org)
+ * Copyright (C) 2004, 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 "HTMLFrameElementBase.h"
+
+#include "CSSHelper.h"
+#include "Document.h"
+#include "EventNames.h"
+#include "FocusController.h"
+#include "Frame.h"
+#include "FrameLoader.h"
+#include "FrameTree.h"
+#include "FrameView.h"
+#include "HTMLFrameSetElement.h"
+#include "HTMLNames.h"
+#include "KURL.h"
+#include "Page.h"
+#include "RenderFrame.h"
+#include "Settings.h"
+
+namespace WebCore {
+
+using namespace EventNames;
+using namespace HTMLNames;
+
+HTMLFrameElementBase::HTMLFrameElementBase(const QualifiedName& tagName, Document *doc)
+    : HTMLFrameOwnerElement(tagName, doc)
+    , m_scrolling(ScrollbarAuto)
+    , m_marginWidth(-1)
+    , m_marginHeight(-1)
+    , m_noResize(false)
+    , m_viewSource(false)
+    , m_shouldOpenURLAfterAttach(false)
+{
+}
+
+bool HTMLFrameElementBase::isURLAllowed(const AtomicString& URLString) const
+{
+    if (URLString.isEmpty())
+        return true;
+
+    KURL completeURL(document()->completeURL(URLString.deprecatedString()));
+    completeURL.setRef(DeprecatedString::null);
+
+    // Don't allow more than 200 total frames in a set. This seems
+    // like a reasonable upper bound, and otherwise mutually recursive
+    // frameset pages can quickly bring the program to its knees with
+    // exponential growth in the number of frames.
+
+    // FIXME: This limit could be higher, but WebKit has some
+    // algorithms that happen while loading which appear to be N^2 or
+    // worse in the number of frames
+    if (Frame* parentFrame = document()->frame())
+        if (parentFrame->page()->frameCount() > 200)
+            return false;
+
+    // We allow one level of self-reference because some sites depend on that.
+    // But we don't allow more than one.
+    bool foundSelfReference = false;
+    for (Frame* frame = document()->frame(); frame; frame = frame->tree()->parent()) {
+        KURL frameURL = frame->loader()->url();
+        frameURL.setRef(DeprecatedString::null);
+        if (frameURL == completeURL) {
+            if (foundSelfReference)
+                return false;
+            foundSelfReference = true;
+        }
+    }
+    
+    return true;
+}
+
+void HTMLFrameElementBase::openURL()
+{
+    ASSERT(!m_name.isEmpty());
+
+    if (!isURLAllowed(m_URL))
+        return;
+
+    if (m_URL.isEmpty())
+        m_URL = "about:blank";
+
+    Frame* parentFrame = document()->frame();
+    if (!parentFrame)
+        return;
+
+    parentFrame->loader()->requestFrame(this, m_URL, m_name);
+    if (contentFrame())
+        contentFrame()->setInViewSourceMode(viewSourceMode());
+}
+
+void HTMLFrameElementBase::parseMappedAttribute(MappedAttribute *attr)
+{
+    if (attr->name() == srcAttr)
+        setLocation(parseURL(attr->value()));
+    else if (attr->name() == idAttr) {
+        // Important to call through to base for the id attribute so the hasID bit gets set.
+        HTMLFrameOwnerElement::parseMappedAttribute(attr);
+        m_name = attr->value();
+    } else if (attr->name() == nameAttr) {
+        m_name = attr->value();
+        // FIXME: If we are already attached, this doesn't actually change the frame's name.
+        // FIXME: If we are already attached, this doesn't check for frame name
+        // conflicts and generate a unique frame name.
+    } else if (attr->name() == marginwidthAttr) {
+        m_marginWidth = attr->value().toInt();
+        // FIXME: If we are already attached, this has no effect.
+    } else if (attr->name() == marginheightAttr) {
+        m_marginHeight = attr->value().toInt();
+        // FIXME: If we are already attached, this has no effect.
+    } else if (attr->name() == noresizeAttr) {
+        m_noResize = true;
+        // FIXME: If we are already attached, this has no effect.
+    } else if (attr->name() == scrollingAttr) {
+        // Auto and yes both simply mean "allow scrolling." No means "don't allow scrolling."
+        if (equalIgnoringCase(attr->value(), "auto") || equalIgnoringCase(attr->value(), "yes"))
+            m_scrolling = ScrollbarAuto;
+        else if (equalIgnoringCase(attr->value(), "no"))
+            m_scrolling = ScrollbarAlwaysOff;
+        // FIXME: If we are already attached, this has no effect.
+    } else if (attr->name() == viewsourceAttr) {
+        m_viewSource = !attr->isNull();
+        if (contentFrame())
+            contentFrame()->setInViewSourceMode(viewSourceMode());
+    } else if (attr->name() == onloadAttr) {
+        setHTMLEventListener(loadEvent, attr);
+    } else if (attr->name() == onbeforeunloadAttr) {
+        // FIXME: should <frame> elements have beforeunload handlers?
+        setHTMLEventListener(beforeunloadEvent, attr);
+    } else if (attr->name() == onunloadAttr) {
+        setHTMLEventListener(unloadEvent, attr);
+    } else
+        HTMLFrameOwnerElement::parseMappedAttribute(attr);
+}
+
+void HTMLFrameElementBase::setNameAndOpenURL()
+{
+    m_name = getAttribute(nameAttr);
+    if (m_name.isNull())
+        m_name = getAttribute(idAttr);
+    
+    if (Frame* parentFrame = document()->frame())
+        m_name = parentFrame->tree()->uniqueChildName(m_name);
+    
+    openURL();
+}
+
+void HTMLFrameElementBase::setNameAndOpenURLCallback(Node* n)
+{
+    static_cast<HTMLFrameElementBase*>(n)->setNameAndOpenURL();
+}
+
+void HTMLFrameElementBase::insertedIntoDocument()
+{
+    HTMLFrameOwnerElement::insertedIntoDocument();
+    
+    // We delay frame loading until after the render tree is fully constructed.
+    // Othewise, a synchronous load that executed JavaScript would see incorrect 
+    // (0) values for the frame's renderer-dependent properties, like width.
+    m_shouldOpenURLAfterAttach = true;
+}
+
+void HTMLFrameElementBase::removedFromDocument()
+{
+    m_shouldOpenURLAfterAttach = false;
+
+    HTMLFrameOwnerElement::removedFromDocument();
+}
+
+void HTMLFrameElementBase::attach()
+{
+    if (m_shouldOpenURLAfterAttach) {
+        m_shouldOpenURLAfterAttach = false;
+        queuePostAttachCallback(&HTMLFrameElementBase::setNameAndOpenURLCallback, this);
+    }
+
+    HTMLFrameOwnerElement::attach();
+    
+    if (RenderPart* renderPart = static_cast<RenderPart*>(renderer()))
+        if (Frame* frame = contentFrame())
+            renderPart->setWidget(frame->view());
+}
+
+void HTMLFrameElementBase::willRemove()
+{
+    if (Frame* frame = contentFrame()) {
+        frame->disconnectOwnerElement();
+        frame->loader()->frameDetached();
+    }
+
+    HTMLFrameOwnerElement::willRemove();
+}
+
+String HTMLFrameElementBase::location() const
+{
+    return src();
+}
+
+void HTMLFrameElementBase::setLocation(const String& str)
+{
+    Settings* settings = document()->settings();
+    if (settings && settings->needsAcrobatFrameReloadingQuirk() && m_URL == str)
+        return;
+
+    m_URL = AtomicString(str);
+
+    if (inDocument())
+        openURL();
+}
+
+bool HTMLFrameElementBase::isFocusable() const
+{
+    return renderer();
+}
+
+void HTMLFrameElementBase::setFocus(bool received)
+{
+    HTMLFrameOwnerElement::setFocus(received);
+    if (Page* page = document()->page())
+        page->focusController()->setFocusedFrame(received ? contentFrame() : 0);
+}
+
+bool HTMLFrameElementBase::isURLAttribute(Attribute *attr) const
+{
+    return attr->name() == srcAttr;
+}
+
+String HTMLFrameElementBase::frameBorder() const
+{
+    return getAttribute(frameborderAttr);
+}
+
+void HTMLFrameElementBase::setFrameBorder(const String &value)
+{
+    setAttribute(frameborderAttr, value);
+}
+
+String HTMLFrameElementBase::longDesc() const
+{
+    return getAttribute(longdescAttr);
+}
+
+void HTMLFrameElementBase::setLongDesc(const String &value)
+{
+    setAttribute(longdescAttr, value);
+}
+
+String HTMLFrameElementBase::marginHeight() const
+{
+    return getAttribute(marginheightAttr);
+}
+
+void HTMLFrameElementBase::setMarginHeight(const String &value)
+{
+    setAttribute(marginheightAttr, value);
+}
+
+String HTMLFrameElementBase::marginWidth() const
+{
+    return getAttribute(marginwidthAttr);
+}
+
+void HTMLFrameElementBase::setMarginWidth(const String &value)
+{
+    setAttribute(marginwidthAttr, value);
+}
+
+String HTMLFrameElementBase::name() const
+{
+    return getAttribute(nameAttr);
+}
+
+void HTMLFrameElementBase::setName(const String &value)
+{
+    setAttribute(nameAttr, value);
+}
+
+void HTMLFrameElementBase::setNoResize(bool noResize)
+{
+    setAttribute(noresizeAttr, noResize ? "" : 0);
+}
+
+String HTMLFrameElementBase::scrolling() const
+{
+    return getAttribute(scrollingAttr);
+}
+
+void HTMLFrameElementBase::setScrolling(const String &value)
+{
+    setAttribute(scrollingAttr, value);
+}
+
+String HTMLFrameElementBase::src() const
+{
+    return document()->completeURL(getAttribute(srcAttr));
+}
+
+void HTMLFrameElementBase::setSrc(const String &value)
+{
+    setAttribute(srcAttr, value);
+}
+
+int HTMLFrameElementBase::width() const
+{
+    if (!renderer())
+        return 0;
+    
+    document()->updateLayoutIgnorePendingStylesheets();
+    return renderer()->width();
+}
+
+int HTMLFrameElementBase::height() const
+{
+    if (!renderer())
+        return 0;
+    
+    document()->updateLayoutIgnorePendingStylesheets();
+    return renderer()->height();
+}
+
+} // namespace WebCore