Home | History | Annotate | Download | only in parser 
      1 /*
      2  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions
      6  * are met:
      7  * 1. Redistributions of source code must retain the above copyright
      8  *    notice, this list of conditions and the following disclaimer.
      9  * 2. Redistributions in binary form must reproduce the above copyright
     10  *    notice, this list of conditions and the following disclaimer in the
     11  *    documentation and/or other materials provided with the distribution.
     12  *
     13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
     14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
     17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     24  */
     25 
     26 #include "config.h"
     27 #include "core/html/parser/HTMLScriptRunner.h"
     28 
     29 #include "bindings/core/v8/ScriptSourceCode.h"
     30 #include "core/dom/Element.h"
     31 #include "core/events/Event.h"
     32 #include "core/dom/IgnoreDestructiveWriteCountIncrementer.h"
     33 #include "core/dom/Microtask.h"
     34 #include "core/dom/ScriptLoader.h"
     35 #include "core/fetch/ScriptResource.h"
     36 #include "core/frame/LocalFrame.h"
     37 #include "core/html/parser/HTMLInputStream.h"
     38 #include "core/html/parser/HTMLScriptRunnerHost.h"
     39 #include "core/html/parser/NestingLevelIncrementer.h"
     40 #include "platform/NotImplemented.h"
     41 #include "public/platform/Platform.h"
     42 
     43 namespace blink {
     44 
     45 using namespace HTMLNames;
     46 
     47 HTMLScriptRunner::HTMLScriptRunner(Document* document, HTMLScriptRunnerHost* host)
     48     : m_document(document)
     49     , m_host(host)
     50     , m_scriptNestingLevel(0)
     51     , m_hasScriptsWaitingForResources(false)
     52     , m_parserBlockingScriptAlreadyLoaded(false)
     53 {
     54     ASSERT(m_host);
     55 }
     56 
     57 HTMLScriptRunner::~HTMLScriptRunner()
     58 {
     59 #if ENABLE(OILPAN)
     60     // If the document is destructed without having explicitly
     61     // detached the parser (and this script runner object), perform
     62     // detach steps now. This will happen if the Document, the parser
     63     // and this script runner object are swept out in the same GC.
     64     detach();
     65 #else
     66     // Verify that detach() has been called.
     67     ASSERT(!m_document);
     68 #endif
     69 }
     70 
     71 void HTMLScriptRunner::detach()
     72 {
     73     if (!m_document)
     74         return;
     75 
     76     m_parserBlockingScript.stopWatchingForLoad(this);
     77 
     78     while (!m_scriptsToExecuteAfterParsing.isEmpty()) {
     79         PendingScript pendingScript = m_scriptsToExecuteAfterParsing.takeFirst();
     80         pendingScript.stopWatchingForLoad(this);
     81     }
     82     m_document = nullptr;
     83 }
     84 
     85 static KURL documentURLForScriptExecution(Document* document)
     86 {
     87     if (!document)
     88         return KURL();
     89 
     90     if (!document->frame()) {
     91         if (document->importsController())
     92             return document->url();
     93         return KURL();
     94     }
     95 
     96     // Use the URL of the currently active document for this frame.
     97     return document->frame()->document()->url();
     98 }
     99 
    100 inline PassRefPtrWillBeRawPtr<Event> createScriptLoadEvent()
    101 {
    102     return Event::create(EventTypeNames::load);
    103 }
    104 
    105 bool HTMLScriptRunner::isPendingScriptReady(const PendingScript& script)
    106 {
    107     m_hasScriptsWaitingForResources = !m_document->isScriptExecutionReady();
    108     if (m_hasScriptsWaitingForResources)
    109         return false;
    110     return script.isReady();
    111 }
    112 
    113 void HTMLScriptRunner::executeParsingBlockingScript()
    114 {
    115     ASSERT(m_document);
    116     ASSERT(!isExecutingScript());
    117     ASSERT(m_document->isScriptExecutionReady());
    118     ASSERT(isPendingScriptReady(m_parserBlockingScript));
    119 
    120     InsertionPointRecord insertionPointRecord(m_host->inputStream());
    121     executePendingScriptAndDispatchEvent(m_parserBlockingScript, PendingScript::ParsingBlocking);
    122 }
    123 
    124 void HTMLScriptRunner::executePendingScriptAndDispatchEvent(PendingScript& pendingScript, PendingScript::Type pendingScriptType)
    125 {
    126     bool errorOccurred = false;
    127     double loadFinishTime = pendingScript.resource() && pendingScript.resource()->url().protocolIsInHTTPFamily() ? pendingScript.resource()->loadFinishTime() : 0;
    128     ScriptSourceCode sourceCode = pendingScript.getSource(documentURLForScriptExecution(m_document), errorOccurred);
    129 
    130     // Stop watching loads before executeScript to prevent recursion if the script reloads itself.
    131     pendingScript.stopWatchingForLoad(this);
    132 
    133     if (!isExecutingScript()) {
    134         Microtask::performCheckpoint();
    135         if (pendingScriptType == PendingScript::ParsingBlocking) {
    136             m_hasScriptsWaitingForResources = !m_document->isScriptExecutionReady();
    137             // The parser cannot be unblocked as a microtask requested another resource
    138             if (m_hasScriptsWaitingForResources)
    139                 return;
    140         }
    141     }
    142 
    143     // Clear the pending script before possible rentrancy from executeScript()
    144     RefPtrWillBeRawPtr<Element> element = pendingScript.releaseElementAndClear();
    145     double compilationFinishTime = 0;
    146     if (ScriptLoader* scriptLoader = toScriptLoaderIfPossible(element.get())) {
    147         NestingLevelIncrementer nestingLevelIncrementer(m_scriptNestingLevel);
    148         IgnoreDestructiveWriteCountIncrementer ignoreDestructiveWriteCountIncrementer(m_document);
    149         if (errorOccurred)
    150             scriptLoader->dispatchErrorEvent();
    151         else {
    152             ASSERT(isExecutingScript());
    153             scriptLoader->executeScript(sourceCode, &compilationFinishTime);
    154             element->dispatchEvent(createScriptLoadEvent());
    155         }
    156     }
    157     // The exact value doesn't matter; valid time stamps are much bigger than this value.
    158     const double epsilon = 1;
    159     if (pendingScriptType == PendingScript::ParsingBlocking && !m_parserBlockingScriptAlreadyLoaded && compilationFinishTime > epsilon && loadFinishTime > epsilon) {
    160         blink::Platform::current()->histogramCustomCounts("WebCore.Scripts.ParsingBlocking.TimeBetweenLoadedAndCompiled", (compilationFinishTime - loadFinishTime) * 1000, 0, 10000, 50);
    161     }
    162 
    163     ASSERT(!isExecutingScript());
    164 }
    165 
    166 void HTMLScriptRunner::notifyFinished(Resource* cachedResource)
    167 {
    168     m_host->notifyScriptLoaded(cachedResource);
    169 }
    170 
    171 // Implements the steps for 'An end tag whose tag name is "script"'
    172 // http://whatwg.org/html#scriptEndTag
    173 // Script handling lives outside the tree builder to keep each class simple.
    174 void HTMLScriptRunner::execute(PassRefPtrWillBeRawPtr<Element> scriptElement, const TextPosition& scriptStartPosition)
    175 {
    176     ASSERT(scriptElement);
    177     // FIXME: If scripting is disabled, always just return.
    178 
    179     bool hadPreloadScanner = m_host->hasPreloadScanner();
    180 
    181     // Try to execute the script given to us.
    182     runScript(scriptElement.get(), scriptStartPosition);
    183 
    184     if (hasParserBlockingScript()) {
    185         if (isExecutingScript())
    186             return; // Unwind to the outermost HTMLScriptRunner::execute before continuing parsing.
    187         // If preload scanner got created, it is missing the source after the current insertion point. Append it and scan.
    188         if (!hadPreloadScanner && m_host->hasPreloadScanner())
    189             m_host->appendCurrentInputStreamToPreloadScannerAndScan();
    190         executeParsingBlockingScripts();
    191     }
    192 }
    193 
    194 bool HTMLScriptRunner::hasParserBlockingScript() const
    195 {
    196     return !!m_parserBlockingScript.element();
    197 }
    198 
    199 void HTMLScriptRunner::executeParsingBlockingScripts()
    200 {
    201     while (hasParserBlockingScript() && isPendingScriptReady(m_parserBlockingScript))
    202         executeParsingBlockingScript();
    203 }
    204 
    205 void HTMLScriptRunner::executeScriptsWaitingForLoad(Resource* resource)
    206 {
    207     ASSERT(!isExecutingScript());
    208     ASSERT(hasParserBlockingScript());
    209     ASSERT_UNUSED(resource, m_parserBlockingScript.resource() == resource);
    210     ASSERT(m_parserBlockingScript.isReady());
    211     executeParsingBlockingScripts();
    212 }
    213 
    214 void HTMLScriptRunner::executeScriptsWaitingForResources()
    215 {
    216     ASSERT(m_document);
    217     // Callers should check hasScriptsWaitingForResources() before calling
    218     // to prevent parser or script re-entry during </style> parsing.
    219     ASSERT(hasScriptsWaitingForResources());
    220     ASSERT(!isExecutingScript());
    221     ASSERT(m_document->isScriptExecutionReady());
    222     executeParsingBlockingScripts();
    223 }
    224 
    225 bool HTMLScriptRunner::executeScriptsWaitingForParsing()
    226 {
    227     while (!m_scriptsToExecuteAfterParsing.isEmpty()) {
    228         ASSERT(!isExecutingScript());
    229         ASSERT(!hasParserBlockingScript());
    230         ASSERT(m_scriptsToExecuteAfterParsing.first().resource());
    231         if (!m_scriptsToExecuteAfterParsing.first().isReady()) {
    232             m_scriptsToExecuteAfterParsing.first().watchForLoad(this);
    233             return false;
    234         }
    235         PendingScript first = m_scriptsToExecuteAfterParsing.takeFirst();
    236         executePendingScriptAndDispatchEvent(first, PendingScript::Deferred);
    237         // FIXME: What is this m_document check for?
    238         if (!m_document)
    239             return false;
    240     }
    241     return true;
    242 }
    243 
    244 void HTMLScriptRunner::requestParsingBlockingScript(Element* element)
    245 {
    246     if (!requestPendingScript(m_parserBlockingScript, element))
    247         return;
    248 
    249     ASSERT(m_parserBlockingScript.resource());
    250 
    251     // Exclude already loaded resources (from memory cache) and reloads from the
    252     // computation of
    253     // WebCore.Scripts.ParsingBlocking.TimeBetweenLoadedAndCompiled (done after
    254     // the script is compiled).
    255     m_parserBlockingScriptAlreadyLoaded = m_parserBlockingScript.resource()->isLoaded() || m_parserBlockingScript.resource()->resourceToRevalidate();
    256     blink::Platform::current()->histogramEnumeration("WebCore.Scripts.ParsingBlocking.AlreadyLoaded", m_parserBlockingScriptAlreadyLoaded ? 1 : 0, 2);
    257 
    258     // We only care about a load callback if resource is not already
    259     // in the cache. Callers will attempt to run the m_parserBlockingScript
    260     // if possible before returning control to the parser.
    261     if (!m_parserBlockingScript.isReady()) {
    262         if (m_document->frame())
    263             ScriptStreamer::startStreaming(m_parserBlockingScript, m_document->frame()->settings(), ScriptState::forMainWorld(m_document->frame()), PendingScript::ParsingBlocking);
    264         m_parserBlockingScript.watchForLoad(this);
    265     }
    266 }
    267 
    268 void HTMLScriptRunner::requestDeferredScript(Element* element)
    269 {
    270     PendingScript pendingScript;
    271     if (!requestPendingScript(pendingScript, element))
    272         return;
    273 
    274     ASSERT(pendingScript.resource());
    275     if (m_document->frame() && !pendingScript.isReady())
    276         ScriptStreamer::startStreaming(pendingScript, m_document->frame()->settings(), ScriptState::forMainWorld(m_document->frame()), PendingScript::Deferred);
    277 
    278     m_scriptsToExecuteAfterParsing.append(pendingScript);
    279 }
    280 
    281 bool HTMLScriptRunner::requestPendingScript(PendingScript& pendingScript, Element* script) const
    282 {
    283     ASSERT(!pendingScript.element());
    284     pendingScript.setElement(script);
    285     // This should correctly return 0 for empty or invalid srcValues.
    286     ScriptResource* resource = toScriptLoaderIfPossible(script)->resource().get();
    287     if (!resource) {
    288         notImplemented(); // Dispatch error event.
    289         return false;
    290     }
    291     pendingScript.setScriptResource(resource);
    292     return true;
    293 }
    294 
    295 // Implements the initial steps for 'An end tag whose tag name is "script"'
    296 // http://whatwg.org/html#scriptEndTag
    297 void HTMLScriptRunner::runScript(Element* script, const TextPosition& scriptStartPosition)
    298 {
    299     ASSERT(m_document);
    300     ASSERT(!hasParserBlockingScript());
    301     {
    302         ScriptLoader* scriptLoader = toScriptLoaderIfPossible(script);
    303 
    304         // This contains both and ASSERTION and a null check since we should not
    305         // be getting into the case of a null script element, but seem to be from
    306         // time to time. The assertion is left in to help find those cases and
    307         // is being tracked by <https://bugs.webkit.org/show_bug.cgi?id=60559>.
    308         ASSERT(scriptLoader);
    309         if (!scriptLoader)
    310             return;
    311 
    312         ASSERT(scriptLoader->isParserInserted());
    313 
    314         if (!isExecutingScript())
    315             Microtask::performCheckpoint();
    316 
    317         InsertionPointRecord insertionPointRecord(m_host->inputStream());
    318         NestingLevelIncrementer nestingLevelIncrementer(m_scriptNestingLevel);
    319 
    320         scriptLoader->prepareScript(scriptStartPosition);
    321 
    322         if (!scriptLoader->willBeParserExecuted())
    323             return;
    324 
    325         if (scriptLoader->willExecuteWhenDocumentFinishedParsing()) {
    326             requestDeferredScript(script);
    327         } else if (scriptLoader->readyToBeParserExecuted()) {
    328             if (m_scriptNestingLevel == 1) {
    329                 m_parserBlockingScript.setElement(script);
    330                 m_parserBlockingScript.setStartingPosition(scriptStartPosition);
    331             } else {
    332                 ScriptSourceCode sourceCode(script->textContent(), documentURLForScriptExecution(m_document), scriptStartPosition);
    333                 scriptLoader->executeScript(sourceCode);
    334             }
    335         } else {
    336             requestParsingBlockingScript(script);
    337         }
    338     }
    339 }
    340 
    341 void HTMLScriptRunner::trace(Visitor* visitor)
    342 {
    343     visitor->trace(m_document);
    344     visitor->trace(m_host);
    345     visitor->trace(m_parserBlockingScript);
    346     visitor->trace(m_scriptsToExecuteAfterParsing);
    347 }
    348 
    349 }
    350