WebCore/dom/ScriptElement.cpp

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
   5  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   6  * Copyright (C) 2008 Nikolas Zimmermann <zimmermann@kde.org>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public License
  19  * along with this library; see the file COPYING.LIB.  If not, write to
  20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21  * Boston, MA 02110-1301, USA.
  22  */
  23
  24 #include "config.h"
  25 #include "ScriptElement.h"
  26
  27 #include "CachedScript.h"
  28 #include "DocLoader.h"
  29 #include "Document.h"
  30 #include "Frame.h"
  31 #include "FrameLoader.h"
  32 #include "MIMETypeRegistry.h"
  33 #include "ScriptController.h"
  34 #include "StringHash.h"
  35 #include "Text.h"
  36
  37 namespace WebCore {
  38
  39 void ScriptElement::insertedIntoDocument(ScriptElementData& data, const String& sourceUrl)
  40 {
  41     if (data.createdByParser())
  42         return;
  43
  44     if (!sourceUrl.isEmpty()) {
  45         data.requestScript(sourceUrl);
  46         return;
  47     }
  48
  49     // If there's an empty script node, we shouldn't evaluate the script
  50     // because if a script is inserted afterwards (by setting text or innerText)
  51     // it should be evaluated, and evaluateScript only evaluates a script once.
  52     data.evaluateScript(data.element()->document()->url().string(), data.scriptContent());
  53 }
  54
  55 void ScriptElement::removedFromDocument(ScriptElementData& data)
  56 {
  57     // Eventually stop loading any not-yet-finished content
  58     data.stopLoadRequest();
  59 }
  60
  61 void ScriptElement::childrenChanged(ScriptElementData& data)
  62 {
  63     if (data.createdByParser())
  64         return;
  65
  66     Element* element = data.element();
  67
  68     // If a node is inserted as a child of the script element
  69     // and the script element has been inserted in the document
  70     // we evaluate the script.
  71     if (element->inDocument() && element->firstChild())
  72         data.evaluateScript(element->document()->url().string(), data.scriptContent());
  73 }
  74
  75 void ScriptElement::finishParsingChildren(ScriptElementData& data, const String& sourceUrl)
  76 {
  77     // The parser just reached </script>. If we have no src and no text,
  78     // allow dynamic loading later.
  79     if (sourceUrl.isEmpty() && data.scriptContent().isEmpty())
  80         data.setCreatedByParser(false);
  81 }
  82
  83 void ScriptElement::handleSourceAttribute(ScriptElementData& data, const String& sourceUrl)
  84 {
  85     if (data.ignoresLoadRequest() || sourceUrl.isEmpty())
  86         return;
  87
  88     data.requestScript(sourceUrl);
  89 }
  90
  91 // Helper function
  92 static bool isSupportedJavaScriptLanguage(const String& language)
  93 {
  94     static HashSet<String, CaseFoldingHash> languages;
  95     if (languages.isEmpty()) {
  96         languages.add("javascript");
  97         languages.add("javascript");
  98         languages.add("javascript1.0");
  99         languages.add("javascript1.1");
 100         languages.add("javascript1.2");
 101         languages.add("javascript1.3");
 102         languages.add("javascript1.4");
 103         languages.add("javascript1.5");
 104         languages.add("javascript1.6");
 105         languages.add("javascript1.7");
 106         languages.add("livescript");
 107         languages.add("ecmascript");
 108         languages.add("jscript");
 109     }
 110
 111     return languages.contains(language);
 112 }
 113
 114 // ScriptElementData
 115 ScriptElementData::ScriptElementData(ScriptElement* scriptElement, Element* element)
 116     : m_scriptElement(scriptElement)
 117     , m_element(element)
 118     , m_cachedScript(0)
 119     , m_createdByParser(false)
 120     , m_evaluated(false)
 121     , m_firedLoad(false)
 122 {
 123     ASSERT(m_scriptElement);
 124     ASSERT(m_element);
 125 }
 126
 127 ScriptElementData::~ScriptElementData()
 128 {
 129     stopLoadRequest();
 130 }
 131
 132 void ScriptElementData::requestScript(const String& sourceUrl)
 133 {
 134     Document* document = m_element->document();
 135
 136     // FIXME: Eventually we'd like to evaluate scripts which are inserted into a
 137     // viewless document but this'll do for now.
 138     // See http://bugs.webkit.org/show_bug.cgi?id=5727
 139     if (!document->frame())
 140         return;
 141
 142     ASSERT(!m_cachedScript);
 143     m_cachedScript = document->docLoader()->requestScript(sourceUrl, scriptCharset());
 144
 145     // m_createdByParser is never reset - always resied at the initial value set while parsing.
 146     // m_evaluated is left untouched as well to avoid script reexecution, if a <script> element
 147     // is removed and reappended to the document.
 148     m_firedLoad = false;
 149
 150     if (m_cachedScript) {
 151         m_cachedScript->addClient(this);
 152         return;
 153     }
 154
 155     m_scriptElement->dispatchErrorEvent();
 156 }
 157
 158 void ScriptElementData::evaluateScript(const String& sourceUrl, const String& content)
 159 {
 160     if (m_evaluated || content.isEmpty() || !shouldExecuteAsJavaScript())
 161         return;
 162
 163     if (Frame* frame = m_element->document()->frame()) {
 164         if (!frame->script()->isEnabled())
 165             return;
 166
 167         m_evaluated = true;
 168
 169         // FIXME: This starting line number will be incorrect for evaluation triggered
 170         // from insertedIntoDocument or childrenChanged.
 171         frame->script()->evaluate(sourceUrl, 1, content);
 172         Document::updateDocumentsRendering();
 173     }
 174 }
 175
 176 void ScriptElementData::stopLoadRequest()
 177 {
 178     if (m_cachedScript) {
 179         m_cachedScript->removeClient(this);
 180         m_cachedScript = 0;
 181     }
 182 }
 183
 184 void ScriptElementData::notifyFinished(CachedResource* o)
 185 {
 186     CachedScript* cs = static_cast<CachedScript*>(o);
 187     ASSERT(cs == m_cachedScript);
 188
 189     if (cs->errorOccurred())
 190         m_scriptElement->dispatchErrorEvent();
 191     else {
 192         RefPtr<Element> protector(m_element);
 193         evaluateScript(cs->url(), cs->script());
 194         m_scriptElement->dispatchLoadEvent();
 195     }
 196
 197     stopLoadRequest();
 198 }
 199
 200 bool ScriptElementData::ignoresLoadRequest() const
 201 {
 202     return m_evaluated || m_cachedScript || m_createdByParser || !m_element->inDocument();
 203 }
 204
 205 bool ScriptElementData::shouldExecuteAsJavaScript() const
 206 {
 207     /*
 208          Mozilla 1.8 accepts javascript1.0 - javascript1.7, but WinIE 7 accepts only javascript1.1 - javascript1.3.
 209          Mozilla 1.8 and WinIE 7 both accept javascript and livescript.
 210          WinIE 7 accepts ecmascript and jscript, but Mozilla 1.8 doesn't.
 211          Neither Mozilla 1.8 nor WinIE 7 accept leading or trailing whitespace.
 212          We want to accept all the values that either of these browsers accept, but not other values.
 213      */
 214     String type = m_scriptElement->typeAttributeValue();
 215     if (!type.isEmpty())
 216         return MIMETypeRegistry::isSupportedJavaScriptMIMEType(type.stripWhiteSpace().lower());
 217
 218     String language = m_scriptElement->languageAttributeValue();
 219     if (!language.isEmpty())
 220         return isSupportedJavaScriptLanguage(language);
 221
 222     // No type or language is specified, so we assume the script to be JavaScript
 223     return true;
 224 }
 225
 226 String ScriptElementData::scriptCharset() const
 227 {
 228     // First we try to get encoding from charset attribute.
 229     String charset = m_scriptElement->charsetAttributeValue().stripWhiteSpace();
 230
 231     // If charset has not been declared in script tag, fall back to frame encoding.
 232     if (charset.isEmpty()) {
 233         if (Frame* frame = m_element->document()->frame())
 234             charset = frame->loader()->encoding();
 235     }
 236
 237     return charset;
 238 }
 239
 240 String ScriptElementData::scriptContent() const
 241 {
 242     Vector<UChar> val;
 243     Text* firstTextNode = 0;
 244     bool foundMultipleTextNodes = false;
 245
 246     for (Node* n = m_element->firstChild(); n; n = n->nextSibling()) {
 247         if (!n->isTextNode())
 248             continue;
 249
 250         Text* t = static_cast<Text*>(n);
 251         if (foundMultipleTextNodes)
 252             append(val, t->data());
 253         else if (firstTextNode) {
 254             append(val, firstTextNode->data());
 255             append(val, t->data());
 256             foundMultipleTextNodes = true;
 257         } else
 258             firstTextNode = t;
 259     }
 260
 261     if (firstTextNode && !foundMultipleTextNodes)
 262         return firstTextNode->data();
 263
 264     return String::adopt(val);
 265 }
 266
 267 }