From cad810f21b803229eb11403f9209855525a25d57 Mon Sep 17 00:00:00 2001
From: Steve Block <steveblock@google.com>
Date: Fri, 6 May 2011 11:45:16 +0100
Subject: Merge WebKit at r75315: Initial merge by git.

Change-Id: I570314b346ce101c935ed22a626b48c2af266b84
---
 Source/WebCore/dom/ScriptElement.cpp | 357 +++++++++++++++++++++++++++++++++++
 1 file changed, 357 insertions(+)
 create mode 100644 Source/WebCore/dom/ScriptElement.cpp

(limited to 'Source/WebCore/dom/ScriptElement.cpp')

diff --git a/Source/WebCore/dom/ScriptElement.cpp b/Source/WebCore/dom/ScriptElement.cpp
new file mode 100644
index 0000000..747f7a1
--- /dev/null
+++ b/Source/WebCore/dom/ScriptElement.cpp
@@ -0,0 +1,357 @@
+/*
+ * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
+ *           (C) 1999 Antti Koivisto (koivisto@kde.org)
+ *           (C) 2001 Dirk Mueller (mueller@kde.org)
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
+ * Copyright (C) 2008 Nikolas Zimmermann <zimmermann@kde.org>
+ *
+ * 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 "ScriptElement.h"
+
+#include "AsyncScriptRunner.h"
+#include "CachedScript.h"
+#include "CachedResourceLoader.h"
+#include "Document.h"
+#include "DocumentParser.h"
+#include "Frame.h"
+#include "FrameLoader.h"
+#include "HTMLNames.h"
+#include "HTMLScriptElement.h"
+#include "IgnoreDestructiveWriteCountIncrementer.h"
+#include "MIMETypeRegistry.h"
+#include "Page.h"
+#include "ScriptController.h"
+#include "ScriptSourceCode.h"
+#include "ScriptValue.h"
+#include "Settings.h"
+#include "Text.h"
+#include <wtf/StdLibExtras.h>
+#include <wtf/text/StringHash.h>
+
+#if ENABLE(SVG)
+#include "SVGNames.h"
+#include "SVGScriptElement.h"
+#endif
+
+namespace WebCore {
+
+ScriptElement::ScriptElement(Element* element, bool wasInsertedByParser, bool wasAlreadyStarted)
+    : m_element(element)
+    , m_cachedScript(0)
+    , m_wasInsertedByParser(wasInsertedByParser)
+    , m_isExternalScript(false)
+    , m_wasAlreadyStarted(wasAlreadyStarted)
+    , m_haveFiredLoad(false)
+{
+    ASSERT(m_element);
+}
+
+ScriptElement::~ScriptElement()
+{
+    stopLoadRequest();
+}
+
+void ScriptElement::insertedIntoDocument(const String& sourceUrl)
+{
+    if (wasInsertedByParser() && !isAsynchronous())
+        return;
+
+    // http://www.whatwg.org/specs/web-apps/current-work/#script
+
+    if (!sourceUrl.isEmpty()) {
+        requestScript(sourceUrl);
+        return;
+    }
+
+    // If there's an empty script node, we shouldn't evaluate the script
+    // because if a script is inserted afterwards (by setting text or innerText)
+    // it should be evaluated, and evaluateScript only evaluates a script once.
+    evaluateScript(ScriptSourceCode(scriptContent(), element()->document()->url())); // FIXME: Provide a real starting line number here.
+}
+
+void ScriptElement::removedFromDocument()
+{
+    // Eventually stop loading any not-yet-finished content
+    stopLoadRequest();
+}
+
+void ScriptElement::childrenChanged()
+{
+    if (wasInsertedByParser())
+        return;
+
+    // If a node is inserted as a child of the script element
+    // and the script element has been inserted in the document
+    // we evaluate the script.
+    if (m_element->inDocument() && m_element->firstChild())
+        evaluateScript(ScriptSourceCode(scriptContent(), m_element->document()->url())); // FIXME: Provide a real starting line number here
+}
+
+void ScriptElement::finishParsingChildren(const String& sourceUrl)
+{
+    // The parser just reached </script>. If we have no src and no text,
+    // allow dynamic loading later.
+    if (sourceUrl.isEmpty() && scriptContent().isEmpty())
+        m_wasInsertedByParser = false;
+}
+
+void ScriptElement::handleSourceAttribute(const String& sourceUrl)
+{
+    if (ignoresLoadRequest() || sourceUrl.isEmpty())
+        return;
+
+    requestScript(sourceUrl);
+}
+
+// Helper function
+static bool isSupportedJavaScriptLanguage(const String& language)
+{
+    typedef HashSet<String, CaseFoldingHash> LanguageSet;
+    DEFINE_STATIC_LOCAL(LanguageSet, languages, ());
+    if (languages.isEmpty()) {
+        languages.add("javascript");
+        languages.add("javascript");
+        languages.add("javascript1.0");
+        languages.add("javascript1.1");
+        languages.add("javascript1.2");
+        languages.add("javascript1.3");
+        languages.add("javascript1.4");
+        languages.add("javascript1.5");
+        languages.add("javascript1.6");
+        languages.add("javascript1.7");
+        languages.add("livescript");
+        languages.add("ecmascript");
+        languages.add("jscript");                
+    }
+
+    return languages.contains(language);
+}
+
+void ScriptElement::requestScript(const String& sourceUrl)
+{
+    // FIXME: Eventually we'd like to evaluate scripts which are inserted into a 
+    // viewless document but this'll do for now.
+    // See http://bugs.webkit.org/show_bug.cgi?id=5727
+    if (!m_element->document()->frame())
+        return;
+
+    RefPtr<Document> originalDocument = m_element->document();
+    if (!m_element->dispatchBeforeLoadEvent(sourceUrl))
+        return;
+    if (!m_element->inDocument() || m_element->document() != originalDocument)
+        return;
+
+    ASSERT(!m_cachedScript);
+    m_cachedScript = m_element->document()->cachedResourceLoader()->requestScript(sourceUrl, scriptCharset());
+    m_isExternalScript = true;
+
+    // m_wasInsertedByParser is never reset - always resied at the initial value set while parsing.
+    // m_wasAlreadyStarted is left untouched as well to avoid script reexecution, if a <script> element
+    // is removed and reappended to the document.
+    m_haveFiredLoad = false;
+
+    if (m_cachedScript) {
+        m_cachedScript->addClient(this);
+        return;
+    }
+
+    dispatchErrorEvent();
+}
+
+void ScriptElement::evaluateScript(const ScriptSourceCode& sourceCode)
+{
+    if (wasAlreadyStarted() || sourceCode.isEmpty() || !shouldExecuteAsJavaScript())
+        return;
+
+    RefPtr<Document> document = m_element->document();
+    ASSERT(document);
+    if (Frame* frame = document->frame()) {
+        if (!frame->script()->canExecuteScripts(AboutToExecuteScript))
+            return;
+
+        m_wasAlreadyStarted = true;
+
+        // http://www.whatwg.org/specs/web-apps/current-work/#script
+
+        {
+            IgnoreDestructiveWriteCountIncrementer ignoreDesctructiveWriteCountIncrementer(m_isExternalScript ? document.get() : 0);
+            // Create a script from the script element node, using the script
+            // block's source and the script block's type.
+            // Note: This is where the script is compiled and actually executed.
+            frame->script()->evaluate(sourceCode);
+        }
+
+        Document::updateStyleForAllDocuments();
+    }
+}
+
+void ScriptElement::executeScript(const ScriptSourceCode& sourceCode)
+{
+    if (wasAlreadyStarted() || sourceCode.isEmpty())
+        return;
+    RefPtr<Document> document = m_element->document();
+    ASSERT(document);
+    Frame* frame = document->frame();
+    if (!frame)
+        return;
+
+    m_wasAlreadyStarted = true;
+
+    frame->script()->executeScript(sourceCode);
+}
+
+void ScriptElement::stopLoadRequest()
+{
+    if (m_cachedScript) {
+        m_cachedScript->removeClient(this);
+        m_cachedScript = 0;
+    }
+}
+
+void ScriptElement::execute(CachedScript* cachedScript)
+{
+    ASSERT(cachedScript);
+    if (cachedScript->errorOccurred())
+        dispatchErrorEvent();
+    else {
+        evaluateScript(ScriptSourceCode(cachedScript));
+        dispatchLoadEvent();
+    }
+    cachedScript->removeClient(this);
+}
+
+void ScriptElement::notifyFinished(CachedResource* o)
+{
+    ASSERT_UNUSED(o, o == m_cachedScript);
+    m_element->document()->asyncScriptRunner()->executeScriptSoon(this, m_cachedScript);
+    m_cachedScript = 0;
+}
+
+bool ScriptElement::ignoresLoadRequest() const
+{
+    return wasAlreadyStarted() || m_isExternalScript || wasInsertedByParser() || !m_element->inDocument();
+}
+
+bool ScriptElement::shouldExecuteAsJavaScript() const
+{
+    /*
+         Mozilla 1.8 accepts javascript1.0 - javascript1.7, but WinIE 7 accepts only javascript1.1 - javascript1.3.
+         Mozilla 1.8 and WinIE 7 both accept javascript and livescript.
+         WinIE 7 accepts ecmascript and jscript, but Mozilla 1.8 doesn't.
+         Neither Mozilla 1.8 nor WinIE 7 accept leading or trailing whitespace.
+         We want to accept all the values that either of these browsers accept, but not other values.
+     
+         FIXME: Is this HTML5 compliant?
+     */
+    String type = typeAttributeValue();
+    if (!type.isEmpty()) {
+        if (!MIMETypeRegistry::isSupportedJavaScriptMIMEType(type.stripWhiteSpace().lower()))
+            return false;
+    } else {
+        String language = languageAttributeValue();
+        if (!language.isEmpty() && !isSupportedJavaScriptLanguage(language))
+            return false;
+    }    
+
+    // No type or language is specified, so we assume the script to be JavaScript.
+
+    String forAttribute = forAttributeValue();
+    String eventAttribute = eventAttributeValue();
+    if (!forAttribute.isEmpty() && !eventAttribute.isEmpty()) {
+        forAttribute = forAttribute.stripWhiteSpace();
+        if (!equalIgnoringCase(forAttribute, "window"))
+            return false;
+            
+        eventAttribute = eventAttribute.stripWhiteSpace();
+        if (!equalIgnoringCase(eventAttribute, "onload") && !equalIgnoringCase(eventAttribute, "onload()"))
+            return false;
+    }
+    
+    return true;
+}
+
+String ScriptElement::scriptCharset() const
+{
+    // First we try to get encoding from charset attribute.
+    String charset = charsetAttributeValue().stripWhiteSpace();
+
+    // If charset has not been declared in script tag, fall back to frame encoding.
+    if (charset.isEmpty()) {
+        if (Frame* frame = m_element->document()->frame())
+            charset = frame->loader()->writer()->encoding();
+    }
+
+    return charset;
+}
+
+String ScriptElement::scriptContent() const
+{
+    Vector<UChar> val;
+    Text* firstTextNode = 0;
+    bool foundMultipleTextNodes = false;
+
+    for (Node* n = m_element->firstChild(); n; n = n->nextSibling()) {
+        if (!n->isTextNode())
+            continue;
+
+        Text* t = static_cast<Text*>(n);
+        if (foundMultipleTextNodes)
+            append(val, t->data());
+        else if (firstTextNode) {
+            append(val, firstTextNode->data());
+            append(val, t->data());
+            foundMultipleTextNodes = true;
+        } else
+            firstTextNode = t;
+    }
+
+    if (firstTextNode && !foundMultipleTextNodes)
+        return firstTextNode->data();
+
+    return String::adopt(val);
+}
+
+bool ScriptElement::isAsynchronous() const
+{
+    // Only external scripts may be asynchronous.
+    // See: http://dev.w3.org/html5/spec/Overview.html#attr-script-async
+    return !sourceAttributeValue().isEmpty() && asyncAttributeValue();
+}
+
+bool ScriptElement::isDeferred() const
+{
+    // Only external scripts may be deferred and async trumps defer to allow for backward compatibility.
+    // See: http://dev.w3.org/html5/spec/Overview.html#attr-script-defer
+    return !sourceAttributeValue().isEmpty() && !asyncAttributeValue() && deferAttributeValue();
+}
+
+ScriptElement* toScriptElement(Element* element)
+{
+    if (element->isHTMLElement() && element->hasTagName(HTMLNames::scriptTag))
+        return static_cast<HTMLScriptElement*>(element);
+
+#if ENABLE(SVG)
+    if (element->isSVGElement() && element->hasTagName(SVGNames::scriptTag))
+        return static_cast<SVGScriptElement*>(element);
+#endif
+
+    return 0;
+}
+
+}
-- 
cgit v1.1