Changeset 205653 in webkit


Ignore:
Timestamp:
Sep 8, 2016 11:48:15 AM (8 years ago)
Author:
commit-queue@webkit.org
Message:

Unreviewed, rolling out r205652.
https://bugs.webkit.org/show_bug.cgi?id=161748

Crashing under ASan (Requested by yusukesuzuki on #webkit).

Reverted changeset:

"ScriptRunner should be driven by PendingScript rather than
ScriptElement"
https://bugs.webkit.org/show_bug.cgi?id=161726
http://trac.webkit.org/changeset/205652

Location:
trunk
Files:
5 deleted
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r205652 r205653  
     12016-09-08  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r205652.
     4        https://bugs.webkit.org/show_bug.cgi?id=161748
     5
     6        Crashing under ASan (Requested by yusukesuzuki on #webkit).
     7
     8        Reverted changeset:
     9
     10        "ScriptRunner should be driven by PendingScript rather than
     11        ScriptElement"
     12        https://bugs.webkit.org/show_bug.cgi?id=161726
     13        http://trac.webkit.org/changeset/205652
     14
    1152016-09-08  Yusuke Suzuki  <utatane.tea@gmail.com>
    216
  • trunk/Source/WebCore/ChangeLog

    r205652 r205653  
     12016-09-08  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r205652.
     4        https://bugs.webkit.org/show_bug.cgi?id=161748
     5
     6        Crashing under ASan (Requested by yusukesuzuki on #webkit).
     7
     8        Reverted changeset:
     9
     10        "ScriptRunner should be driven by PendingScript rather than
     11        ScriptElement"
     12        https://bugs.webkit.org/show_bug.cgi?id=161726
     13        http://trac.webkit.org/changeset/205652
     14
    1152016-09-08  Yusuke Suzuki  <utatane.tea@gmail.com>
    216
  • trunk/Source/WebCore/dom/ScriptElement.cpp

    r205652 r205653  
    7676}
    7777
     78ScriptElement::~ScriptElement()
     79{
     80    stopLoadRequest();
     81}
     82
    7883bool ScriptElement::shouldCallFinishedInsertingSubtree(ContainerNode& insertionPoint)
    7984{
     
    241246        m_willExecuteInOrder = true;
    242247        document.scriptRunner()->queueScriptForExecution(this, *m_loadableScript, ScriptRunner::IN_ORDER_EXECUTION);
     248        m_loadableScript->addClient(*this);
    243249    } else if (hasSourceAttribute()) {
    244250        ASSERT(m_loadableScript);
    245251        m_element.document().scriptRunner()->queueScriptForExecution(this, *m_loadableScript, ScriptRunner::ASYNC_EXECUTION);
     252        m_loadableScript->addClient(*this);
    246253    } else {
    247254        // Reset line numbering for nested writes.
     
    330337}
    331338
     339void ScriptElement::stopLoadRequest()
     340{
     341    if (m_loadableScript) {
     342        if (!m_willBeParserExecuted)
     343            m_loadableScript->removeClient(*this);
     344        m_loadableScript = nullptr;
     345    }
     346}
     347
    332348void ScriptElement::executeScriptAndDispatchEvent(LoadableScript& loadableScript)
    333349{
     
    343359}
    344360
    345 void ScriptElement::executeScriptForScriptRunner(PendingScript& pendingScript)
    346 {
     361void ScriptElement::executeScriptForScriptRunner(LoadableScript& loadableScript)
     362{
     363    ASSERT(!m_willBeParserExecuted);
     364    executeScriptAndDispatchEvent(loadableScript);
     365    loadableScript.removeClient(*this);
     366}
     367
     368void ScriptElement::executeScriptForHTMLScriptRunner(PendingScript& pendingScript)
     369{
     370    IgnoreDestructiveWriteCountIncrementer ignoreDestructiveWriteCountIncrementer(&m_element.document());
    347371    if (auto* loadableScript = pendingScript.loadableScript())
    348372        executeScriptAndDispatchEvent(*loadableScript);
     
    354378}
    355379
     380void ScriptElement::notifyFinished(LoadableScript&)
     381{
     382    ASSERT(!m_willBeParserExecuted);
     383
     384    // LoadableScript possibly invokes this notifyFinished() more than
     385    // once because ScriptElement doesn't unsubscribe itself from
     386    // LoadableScript here and does it in execute() instead.
     387    // We use m_loadableScript to check if this function is already called.
     388    if (!m_loadableScript)
     389        return;
     390
     391    if (m_willExecuteInOrder)
     392        m_element.document().scriptRunner()->notifyScriptReady(this, ScriptRunner::IN_ORDER_EXECUTION);
     393    else
     394        m_element.document().scriptRunner()->notifyScriptReady(this, ScriptRunner::ASYNC_EXECUTION);
     395
     396    m_loadableScript = nullptr;
     397}
     398
    356399bool ScriptElement::ignoresLoadRequest() const
    357400{
  • trunk/Source/WebCore/dom/ScriptElement.h

    r205652 r205653  
    3939class ScriptSourceCode;
    4040
    41 class ScriptElement {
     41class ScriptElement : private LoadableScriptClient {
    4242public:
    43     virtual ~ScriptElement() { }
     43    virtual ~ScriptElement();
    4444
    4545    Element& element() { return m_element; }
     
    5353    void executeScript(const ScriptSourceCode&);
    5454
    55     void executeScriptForScriptRunner(PendingScript&);
     55    void executeScriptForScriptRunner(LoadableScript&);
     56    void executeScriptForHTMLScriptRunner(PendingScript&);
    5657
    5758    // XML parser calls these
     
    6364    bool readyToBeParserExecuted() const { return m_readyToBeParserExecuted; }
    6465    bool willExecuteWhenDocumentFinishedParsing() const { return m_willExecuteWhenDocumentFinishedParsing; }
    65     bool willExecuteInOrder() const { return m_willExecuteInOrder; }
    6666    LoadableScript* loadableScript() { return m_loadableScript.get(); }
    6767
     
    9393
    9494    bool requestClassicScript(const String& sourceURL);
     95    void stopLoadRequest();
     96
     97    void notifyFinished(LoadableScript&) override;
    9598
    9699    virtual String sourceAttributeValue() const = 0;
  • trunk/Source/WebCore/dom/ScriptRunner.cpp

    r205652 r205653  
    4141ScriptRunner::~ScriptRunner()
    4242{
    43     for (auto& pendingScript : m_scriptsToExecuteSoon) {
    44         UNUSED_PARAM(pendingScript);
     43    for (size_t i = 0; i < m_scriptsToExecuteSoon.size(); ++i)
    4544        m_document.decrementLoadEventDelayCount();
    46     }
    47     for (auto& pendingScript : m_scriptsToExecuteInOrder) {
    48         if (pendingScript->watchingForLoad())
    49             pendingScript->clearClient();
     45    for (size_t i = 0; i < m_scriptsToExecuteInOrder.size(); ++i)
    5046        m_document.decrementLoadEventDelayCount();
    51     }
    52     for (auto& pendingScript : m_pendingAsyncScripts) {
    53         if (pendingScript->watchingForLoad())
    54             const_cast<PendingScript&>(pendingScript.get()).clearClient();
     47    for (unsigned i = 0; i < m_pendingAsyncScripts.size(); ++i)
    5548        m_document.decrementLoadEventDelayCount();
    56     }
    5749}
    5850
     
    6658    m_document.incrementLoadEventDelayCount();
    6759
    68     Ref<PendingScript> pendingScript = PendingScript::create(element, loadableScript);
    6960    switch (executionType) {
    7061    case ASYNC_EXECUTION:
    71         m_pendingAsyncScripts.add(pendingScript.copyRef());
     62        m_pendingAsyncScripts.add(scriptElement, PendingScript::create(element, loadableScript));
    7263        break;
    7364
    7465    case IN_ORDER_EXECUTION:
    75         m_scriptsToExecuteInOrder.append(pendingScript.copyRef());
     66        m_scriptsToExecuteInOrder.append(PendingScript::create(element, loadableScript));
    7667        break;
    7768    }
    78     pendingScript->setClient(this);
    7969}
    8070
     
    9080}
    9181
    92 void ScriptRunner::notifyFinished(PendingScript& pendingScript)
     82void ScriptRunner::notifyScriptReady(ScriptElement* scriptElement, ExecutionType executionType)
    9383{
    94     auto* scriptElement = toScriptElementIfPossible(&pendingScript.element());
    95     ASSERT(scriptElement);
    96     if (scriptElement->willExecuteInOrder())
     84    switch (executionType) {
     85    case ASYNC_EXECUTION:
     86        ASSERT(m_pendingAsyncScripts.contains(scriptElement));
     87        m_scriptsToExecuteSoon.append(m_pendingAsyncScripts.take(scriptElement)->ptr());
     88        break;
     89
     90    case IN_ORDER_EXECUTION:
    9791        ASSERT(!m_scriptsToExecuteInOrder.isEmpty());
    98     else {
    99         ASSERT(m_pendingAsyncScripts.contains(pendingScript));
    100         m_scriptsToExecuteSoon.append(m_pendingAsyncScripts.take(pendingScript)->ptr());
     92        break;
    10193    }
    102     pendingScript.clearClient();
    10394    m_timer.startOneShot(0);
    10495}
     
    126117        ASSERT(scriptElement);
    127118        ASSERT(script->needsLoading());
    128         scriptElement->executeScriptForScriptRunner(*script);
     119        scriptElement->executeScriptForScriptRunner(*script->loadableScript());
    129120        m_document.decrementLoadEventDelayCount();
    130121    }
  • trunk/Source/WebCore/dom/ScriptRunner.h

    r205652 r205653  
    2626#pragma once
    2727
    28 #include "PendingScriptClient.h"
    2928#include "Timer.h"
    30 #include <wtf/HashSet.h>
     29#include <wtf/HashMap.h>
    3130#include <wtf/Noncopyable.h>
    3231#include <wtf/Vector.h>
     
    3938class LoadableScript;
    4039
    41 class ScriptRunner : private PendingScriptClient {
     40class ScriptRunner {
    4241    WTF_MAKE_NONCOPYABLE(ScriptRunner); WTF_MAKE_FAST_ALLOCATED;
    4342public:
     
    5554    void timerFired();
    5655
    57     void notifyFinished(PendingScript&) override;
    58 
    5956    Document& m_document;
    6057    Vector<Ref<PendingScript>> m_scriptsToExecuteInOrder;
    6158    Vector<RefPtr<PendingScript>> m_scriptsToExecuteSoon; // http://www.whatwg.org/specs/web-apps/current-work/#set-of-scripts-that-will-execute-as-soon-as-possible
    62     HashSet<Ref<PendingScript>> m_pendingAsyncScripts;
     59    HashMap<ScriptElement*, Ref<PendingScript>> m_pendingAsyncScripts;
    6360    Timer m_timer;
    6461};
  • trunk/Source/WebCore/html/parser/HTMLScriptRunner.cpp

    r205652 r205653  
    122122    if (auto* scriptElement = toScriptElementIfPossible(&pendingScript->element())) {
    123123        NestingLevelIncrementer nestingLevelIncrementer(m_scriptNestingLevel);
    124         scriptElement->executeScriptForScriptRunner(*pendingScript);
     124        scriptElement->executeScriptForHTMLScriptRunner(*pendingScript);
    125125    }
    126126    ASSERT(!isExecutingScript());
Note: See TracChangeset for help on using the changeset viewer.