src/third_party/WebKit/Source/core/dom/ScriptLoader.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 "core/dom/ScriptLoader.h"
  26
  27 #include "HTMLNames.h"
  28 #include "SVGNames.h"
  29 #include "bindings/v8/ScriptController.h"
  30 #include "bindings/v8/ScriptSourceCode.h"
  31 #include "core/dom/Document.h"
  32 #include "core/events/Event.h"
  33 #include "core/dom/IgnoreDestructiveWriteCountIncrementer.h"
  34 #include "core/dom/ScriptLoaderClient.h"
  35 #include "core/dom/ScriptRunner.h"
  36 #include "core/dom/ScriptableDocumentParser.h"
  37 #include "core/dom/Text.h"
  38 #include "core/fetch/FetchRequest.h"
  39 #include "core/fetch/ResourceFetcher.h"
  40 #include "core/fetch/ScriptResource.h"
  41 #include "core/html/HTMLImport.h"
  42 #include "core/html/HTMLScriptElement.h"
  43 #include "core/html/parser/HTMLParserIdioms.h"
  44 #include "core/frame/ContentSecurityPolicy.h"
  45 #include "core/frame/Frame.h"
  46 #include "core/svg/SVGScriptElement.h"
  47 #include "platform/MIMETypeRegistry.h"
  48 #include "platform/weborigin/SecurityOrigin.h"
  49 #include "wtf/StdLibExtras.h"
  50 #include "wtf/text/StringBuilder.h"
  51 #include "wtf/text/StringHash.h"
  52
  53 namespace WebCore {
  54
  55 ScriptLoader::ScriptLoader(Element* element, bool parserInserted, bool alreadyStarted)
  56     : m_element(element)
  57     , m_resource(0)
  58     , m_startLineNumber(WTF::OrdinalNumber::beforeFirst())
  59     , m_parserInserted(parserInserted)
  60     , m_isExternalScript(false)
  61     , m_alreadyStarted(alreadyStarted)
  62     , m_haveFiredLoad(false)
  63     , m_willBeParserExecuted(false)
  64     , m_readyToBeParserExecuted(false)
  65     , m_willExecuteWhenDocumentFinishedParsing(false)
  66     , m_forceAsync(!parserInserted)
  67     , m_willExecuteInOrder(false)
  68 {
  69     ASSERT(m_element);
  70     if (parserInserted && element->document().scriptableDocumentParser() && !element->document().isInDocumentWrite())
  71         m_startLineNumber = element->document().scriptableDocumentParser()->lineNumber();
  72 }
  73
  74 ScriptLoader::~ScriptLoader()
  75 {
  76     stopLoadRequest();
  77 }
  78
  79 void ScriptLoader::didNotifySubtreeInsertionsToDocument()
  80 {
  81     if (!m_parserInserted)
  82         prepareScript(); // FIXME: Provide a real starting line number here.
  83 }
  84
  85 void ScriptLoader::childrenChanged()
  86 {
  87     if (!m_parserInserted && m_element->inDocument())
  88         prepareScript(); // FIXME: Provide a real starting line number here.
  89 }
  90
  91 void ScriptLoader::handleSourceAttribute(const String& sourceUrl)
  92 {
  93     if (ignoresLoadRequest() || sourceUrl.isEmpty())
  94         return;
  95
  96     prepareScript(); // FIXME: Provide a real starting line number here.
  97 }
  98
  99 void ScriptLoader::handleAsyncAttribute()
 100 {
 101     m_forceAsync = false;
 102 }
 103
 104 // Helper function
 105 static bool isLegacySupportedJavaScriptLanguage(const String& language)
 106 {
 107     // Mozilla 1.8 accepts javascript1.0 - javascript1.7, but WinIE 7 accepts only javascript1.1 - javascript1.3.
 108     // Mozilla 1.8 and WinIE 7 both accept javascript and livescript.
 109     // WinIE 7 accepts ecmascript and jscript, but Mozilla 1.8 doesn't.
 110     // Neither Mozilla 1.8 nor WinIE 7 accept leading or trailing whitespace.
 111     // We want to accept all the values that either of these browsers accept, but not other values.
 112
 113     // FIXME: This function is not HTML5 compliant. These belong in the MIME registry as "text/javascript<version>" entries.
 114     typedef HashSet<String, CaseFoldingHash> LanguageSet;
 115     DEFINE_STATIC_LOCAL(LanguageSet, languages, ());
 116     if (languages.isEmpty()) {
 117         languages.add("javascript");
 118         languages.add("javascript");
 119         languages.add("javascript1.0");
 120         languages.add("javascript1.1");
 121         languages.add("javascript1.2");
 122         languages.add("javascript1.3");
 123         languages.add("javascript1.4");
 124         languages.add("javascript1.5");
 125         languages.add("javascript1.6");
 126         languages.add("javascript1.7");
 127         languages.add("livescript");
 128         languages.add("ecmascript");
 129         languages.add("jscript");
 130     }
 131
 132     return languages.contains(language);
 133 }
 134
 135 void ScriptLoader::dispatchErrorEvent()
 136 {
 137     m_element->dispatchEvent(Event::create(EventTypeNames::error));
 138 }
 139
 140 void ScriptLoader::dispatchLoadEvent()
 141 {
 142     if (ScriptLoaderClient* client = this->client())
 143         client->dispatchLoadEvent();
 144     setHaveFiredLoadEvent(true);
 145 }
 146
 147 bool ScriptLoader::isScriptTypeSupported(LegacyTypeSupport supportLegacyTypes) const
 148 {
 149     // FIXME: isLegacySupportedJavaScriptLanguage() is not valid HTML5. It is used here to maintain backwards compatibility with existing layout tests. The specific violations are:
 150     // - Allowing type=javascript. type= should only support MIME types, such as text/javascript.
 151     // - Allowing a different set of languages for language= and type=. language= supports Javascript 1.1 and 1.4-1.6, but type= does not.
 152
 153     String type = client()->typeAttributeValue();
 154     String language = client()->languageAttributeValue();
 155     if (type.isEmpty() && language.isEmpty())
 156         return true; // Assume text/javascript.
 157     if (type.isEmpty()) {
 158         type = "text/" + language.lower();
 159         if (MIMETypeRegistry::isSupportedJavaScriptMIMEType(type) || isLegacySupportedJavaScriptLanguage(language))
 160             return true;
 161     } else if (MIMETypeRegistry::isSupportedJavaScriptMIMEType(type.stripWhiteSpace()) || (supportLegacyTypes == AllowLegacyTypeInTypeAttribute && isLegacySupportedJavaScriptLanguage(type))) {
 162         return true;
 163     }
 164
 165     return false;
 166 }
 167
 168 // http://dev.w3.org/html5/spec/Overview.html#prepare-a-script
 169 bool ScriptLoader::prepareScript(const TextPosition& scriptStartPosition, LegacyTypeSupport supportLegacyTypes)
 170 {
 171     if (m_alreadyStarted)
 172         return false;
 173
 174     ScriptLoaderClient* client = this->client();
 175
 176     bool wasParserInserted;
 177     if (m_parserInserted) {
 178         wasParserInserted = true;
 179         m_parserInserted = false;
 180     } else {
 181         wasParserInserted = false;
 182     }
 183
 184     if (wasParserInserted && !client->asyncAttributeValue())
 185         m_forceAsync = true;
 186
 187     // FIXME: HTML5 spec says we should check that all children are either comments or empty text nodes.
 188     if (!client->hasSourceAttribute() && !m_element->firstChild())
 189         return false;
 190
 191     if (!m_element->inDocument())
 192         return false;
 193
 194     if (!isScriptTypeSupported(supportLegacyTypes))
 195         return false;
 196
 197     if (wasParserInserted) {
 198         m_parserInserted = true;
 199         m_forceAsync = false;
 200     }
 201
 202     m_alreadyStarted = true;
 203
 204     // FIXME: If script is parser inserted, verify it's still in the original document.
 205     Document& elementDocument = m_element->document();
 206     Document* contextDocument = elementDocument.contextDocument().get();
 207
 208     if (!contextDocument || !contextDocument->allowExecutingScripts(m_element))
 209         return false;
 210
 211     if (!isScriptForEventSupported())
 212         return false;
 213
 214     if (!client->charsetAttributeValue().isEmpty())
 215         m_characterEncoding = client->charsetAttributeValue();
 216     else
 217         m_characterEncoding = elementDocument.charset();
 218
 219     if (client->hasSourceAttribute()) {
 220         if (!fetchScript(client->sourceAttributeValue()))
 221             return false;
 222     }
 223
 224     if (client->hasSourceAttribute() && client->deferAttributeValue() && m_parserInserted && !client->asyncAttributeValue()) {
 225         m_willExecuteWhenDocumentFinishedParsing = true;
 226         m_willBeParserExecuted = true;
 227     } else if (client->hasSourceAttribute() && m_parserInserted && !client->asyncAttributeValue()) {
 228         m_willBeParserExecuted = true;
 229     } else if (!client->hasSourceAttribute() && m_parserInserted && !elementDocument.haveStylesheetsAndImportsLoaded()) {
 230         m_willBeParserExecuted = true;
 231         m_readyToBeParserExecuted = true;
 232     } else if (client->hasSourceAttribute() && !client->asyncAttributeValue() && !m_forceAsync) {
 233         m_willExecuteInOrder = true;
 234         contextDocument->scriptRunner()->queueScriptForExecution(this, m_resource, ScriptRunner::IN_ORDER_EXECUTION);
 235         m_resource->addClient(this);
 236     } else if (client->hasSourceAttribute()) {
 237         contextDocument->scriptRunner()->queueScriptForExecution(this, m_resource, ScriptRunner::ASYNC_EXECUTION);
 238         m_resource->addClient(this);
 239     } else {
 240         // Reset line numbering for nested writes.
 241         TextPosition position = elementDocument.isInDocumentWrite() ? TextPosition() : scriptStartPosition;
 242         KURL scriptURL = (!elementDocument.isInDocumentWrite() && m_parserInserted) ? elementDocument.url() : KURL();
 243         executeScript(ScriptSourceCode(scriptContent(), scriptURL, position));
 244     }
 245
 246     return true;
 247 }
 248
 249 bool ScriptLoader::fetchScript(const String& sourceUrl)
 250 {
 251     ASSERT(m_element);
 252
 253     RefPtr<Document> elementDocument(m_element->document());
 254     if (!m_element->dispatchBeforeLoadEvent(sourceUrl))
 255         return false;
 256     if (!m_element->inDocument() || m_element->document() != elementDocument)
 257         return false;
 258
 259     ASSERT(!m_resource);
 260     if (!stripLeadingAndTrailingHTMLSpaces(sourceUrl).isEmpty()) {
 261         FetchRequest request(ResourceRequest(elementDocument->completeURL(sourceUrl)), m_element->localName());
 262
 263         AtomicString crossOriginMode = m_element->fastGetAttribute(HTMLNames::crossoriginAttr);
 264         if (!crossOriginMode.isNull())
 265             request.setCrossOriginAccessControl(elementDocument->securityOrigin(), crossOriginMode);
 266         request.setCharset(scriptCharset());
 267
 268         bool isValidScriptNonce = elementDocument->contentSecurityPolicy()->allowScriptNonce(m_element->fastGetAttribute(HTMLNames::nonceAttr));
 269         if (isValidScriptNonce)
 270             request.setContentSecurityCheck(DoNotCheckContentSecurityPolicy);
 271
 272         m_resource = elementDocument->fetcher()->fetchScript(request);
 273         m_isExternalScript = true;
 274     }
 275
 276     if (m_resource)
 277         return true;
 278
 279     dispatchErrorEvent();
 280     return false;
 281 }
 282
 283 bool isHTMLScriptLoader(Element* element)
 284 {
 285     return element->hasTagName(HTMLNames::scriptTag);
 286 }
 287
 288 bool isSVGScriptLoader(Element* element)
 289 {
 290     return element->hasTagName(SVGNames::scriptTag);
 291 }
 292
 293 void ScriptLoader::executeScript(const ScriptSourceCode& sourceCode)
 294 {
 295     ASSERT(m_alreadyStarted);
 296
 297     if (sourceCode.isEmpty())
 298         return;
 299
 300     RefPtr<Document> elementDocument(m_element->document());
 301     RefPtr<Document> contextDocument = elementDocument->contextDocument().get();
 302     if (!contextDocument)
 303         return;
 304
 305     Frame* frame = contextDocument->frame();
 306
 307     bool shouldBypassMainWorldContentSecurityPolicy = (frame && frame->script().shouldBypassMainWorldContentSecurityPolicy()) || elementDocument->contentSecurityPolicy()->allowScriptNonce(m_element->fastGetAttribute(HTMLNames::nonceAttr)) || elementDocument->contentSecurityPolicy()->allowScriptHash(sourceCode.source());
 308
 309     if (!m_isExternalScript && (!shouldBypassMainWorldContentSecurityPolicy && !elementDocument->contentSecurityPolicy()->allowInlineScript(elementDocument->url(), m_startLineNumber)))
 310         return;
 311
 312     if (m_isExternalScript && m_resource && !m_resource->mimeTypeAllowedByNosniff()) {
 313         contextDocument->addConsoleMessage(SecurityMessageSource, ErrorMessageLevel, "Refused to execute script from '" + m_resource->url().elidedString() + "' because its MIME type ('" + m_resource->mimeType() + "') is not executable, and strict MIME type checking is enabled.");
 314         return;
 315     }
 316
 317     if (frame) {
 318         IgnoreDestructiveWriteCountIncrementer ignoreDesctructiveWriteCountIncrementer(m_isExternalScript ? contextDocument.get() : 0);
 319
 320         if (isHTMLScriptLoader(m_element))
 321             contextDocument->pushCurrentScript(toHTMLScriptElement(m_element));
 322
 323         AccessControlStatus corsCheck = NotSharableCrossOrigin;
 324         if (sourceCode.resource() && sourceCode.resource()->passesAccessControlCheck(m_element->document().securityOrigin()))
 325             corsCheck = SharableCrossOrigin;
 326
 327         // Create a script from the script element node, using the script
 328         // block's source and the script block's type.
 329         // Note: This is where the script is compiled and actually executed.
 330         frame->script().executeScriptInMainWorld(sourceCode, corsCheck);
 331
 332         if (isHTMLScriptLoader(m_element)) {
 333             ASSERT(contextDocument->currentScript() == m_element);
 334             contextDocument->popCurrentScript();
 335         }
 336     }
 337 }
 338
 339 void ScriptLoader::stopLoadRequest()
 340 {
 341     if (m_resource) {
 342         if (!m_willBeParserExecuted)
 343             m_resource->removeClient(this);
 344         m_resource = 0;
 345     }
 346 }
 347
 348 void ScriptLoader::execute(ScriptResource* resource)
 349 {
 350     ASSERT(!m_willBeParserExecuted);
 351     ASSERT(resource);
 352     if (resource->errorOccurred()) {
 353         dispatchErrorEvent();
 354     } else if (!resource->wasCanceled()) {
 355         executeScript(ScriptSourceCode(resource));
 356         dispatchLoadEvent();
 357     }
 358     resource->removeClient(this);
 359 }
 360
 361 void ScriptLoader::notifyFinished(Resource* resource)
 362 {
 363     ASSERT(!m_willBeParserExecuted);
 364
 365     RefPtr<Document> elementDocument(m_element->document());
 366     RefPtr<Document> contextDocument = elementDocument->contextDocument().get();
 367     if (!contextDocument)
 368         return;
 369
 370     // Resource possibly invokes this notifyFinished() more than
 371     // once because ScriptLoader doesn't unsubscribe itself from
 372     // Resource here and does it in execute() instead.
 373     // We use m_resource to check if this function is already called.
 374     ASSERT_UNUSED(resource, resource == m_resource);
 375     if (!m_resource)
 376         return;
 377     if (m_resource->errorOccurred()) {
 378         dispatchErrorEvent();
 379         contextDocument->scriptRunner()->notifyScriptLoadError(this, m_willExecuteInOrder ? ScriptRunner::IN_ORDER_EXECUTION : ScriptRunner::ASYNC_EXECUTION);
 380         return;
 381     }
 382     if (m_willExecuteInOrder)
 383         contextDocument->scriptRunner()->notifyScriptReady(this, ScriptRunner::IN_ORDER_EXECUTION);
 384     else
 385         contextDocument->scriptRunner()->notifyScriptReady(this, ScriptRunner::ASYNC_EXECUTION);
 386
 387     m_resource = 0;
 388 }
 389
 390 bool ScriptLoader::ignoresLoadRequest() const
 391 {
 392     return m_alreadyStarted || m_isExternalScript || m_parserInserted || !element() || !element()->inDocument();
 393 }
 394
 395 bool ScriptLoader::isScriptForEventSupported() const
 396 {
 397     String eventAttribute = client()->eventAttributeValue();
 398     String forAttribute = client()->forAttributeValue();
 399     if (!eventAttribute.isEmpty() && !forAttribute.isEmpty()) {
 400         forAttribute = forAttribute.stripWhiteSpace();
 401         if (!equalIgnoringCase(forAttribute, "window"))
 402             return false;
 403
 404         eventAttribute = eventAttribute.stripWhiteSpace();
 405         if (!equalIgnoringCase(eventAttribute, "onload") && !equalIgnoringCase(eventAttribute, "onload()"))
 406             return false;
 407     }
 408     return true;
 409 }
 410
 411 String ScriptLoader::scriptContent() const
 412 {
 413     return m_element->textFromChildren();
 414 }
 415
 416 ScriptLoaderClient* ScriptLoader::client() const
 417 {
 418     if (isHTMLScriptLoader(m_element))
 419         return toHTMLScriptElement(m_element);
 420
 421     if (isSVGScriptLoader(m_element))
 422         return toSVGScriptElement(m_element);
 423
 424     ASSERT_NOT_REACHED();
 425     return 0;
 426 }
 427
 428 ScriptLoader* toScriptLoaderIfPossible(Element* element)
 429 {
 430     if (isHTMLScriptLoader(element))
 431         return toHTMLScriptElement(element)->loader();
 432
 433     if (isSVGScriptLoader(element))
 434         return toSVGScriptElement(element)->loader();
 435
 436     return 0;
 437 }
 438
 439 }