Changeset 66841 in webkit

Timestamp:

Sep 6, 2010 11:32:48 AM (14 years ago)

Author:

tonyg@chromium.org

Message:

2010-09-06 Tony Gentilcore <​tonyg@chromium.org>

Reviewed by Adam Barth.

Implement HTML5 definition of document.readyState
​https://bugs.webkit.org/show_bug.cgi?id=45119

• fast/dom/Document/readystate-expected.txt: Added.
• fast/dom/Document/readystate.html: Added. Reads readyState inline script, external script, deferred script, DOMContentLoaded, onload, and dynamic post-onload script.

2010-09-06 Tony Gentilcore <​tonyg@chromium.org>

Reviewed by Adam Barth.

Implement HTML5 definition of document.readyState
​https://bugs.webkit.org/show_bug.cgi?id=45119

The legacy behavior was "loading" -> "loaded" -> "complete". The new
HTML5 behavior is "loading" -> "interactive" -> "complete". There is
some potential for this to cause compat problems if for instance a
page expects readyState to be "loaded" during the DOMContentLoaded event.

Test: fast/dom/Document/readystate.html

• dom/Document.cpp: (WebCore::Document::Document): Initial value is Complete because according to ​http://www.whatwg.org/specs/web-apps/current-work/#dom-document-readystate, when a Document is created the initial value is "complete" unless it has a parser associated with it, in which case it is "loading". So the ctor starts it Complete, and when the parser is created it is flipped to Loading. (WebCore::Document::readyState): (WebCore::Document::setReadyState): (WebCore::Document::implicitOpen): (WebCore::Document::finishedParsing): Ensure that XML and HTML parser have transition to Stopping state.
• dom/Document.h:
• dom/DocumentParser.cpp: (WebCore::DocumentParser::prepareToStopParsing): Previously this was being called when parsing had stopped. It is better to ensure it is only called while parsing.
• dom/XMLDocumentParser.cpp: (WebCore::XMLDocumentParser::end): Transition to stopping before calling document finishedParsiong().
• html/parser/HTMLDocumentParser.cpp: (WebCore::HTMLDocumentParser::prepareToStopParsing): Set state to interactive before running deferred scripts. This method is also called when parsing fragments, so we need to ensure it isn't done in that case. (WebCore::HTMLDocumentParser::attemptToRunDeferredScriptsAndEnd): Added. Break out this part s that notifyFinished doesn't go through the additional steps of pumping tokenizer, setting the state, etc. (WebCore::HTMLDocumentParser::notifyFinished): Now that prepareToStopParsing is split up, we must protect. It also makes sense to add a couple of ASSERTs.
• loader/FrameLoader.cpp: (WebCore::FrameLoader::stopLoading): It looks like an aborted load should never transition to "complete" according the HTML5. I've left the legacy behavior for now though. (WebCore::FrameLoader::checkCompleted): The FrameLoader now sets the state on the Document instead of the Document polling the FrameLoader.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/fast/dom/Document/readystate-expected.txt (added)
• LayoutTests/fast/dom/Document/readystate.html (added)
• WebCore/ChangeLog (modified) (1 diff)
• WebCore/dom/Document.cpp (modified) (4 diffs)
• WebCore/dom/Document.h (modified) (2 diffs)
• WebCore/dom/DocumentParser.cpp (modified) (1 diff)
• WebCore/dom/XMLDocumentParser.cpp (modified) (1 diff)
• WebCore/html/parser/HTMLDocumentParser.cpp (modified) (4 diffs)
• WebCore/html/parser/HTMLDocumentParser.h (modified) (1 diff)
• WebCore/loader/FrameLoader.cpp (modified) (2 diffs)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2010-09-06  Tony Gentilcore  <tonyg@chromium.org>
+
+        Reviewed by Adam Barth.
+
+        Implement HTML5 definition of document.readyState
+        https://bugs.webkit.org/show_bug.cgi?id=45119
+
+        * fast/dom/Document/readystate-expected.txt: Added.
+        * fast/dom/Document/readystate.html: Added. Reads readyState inline script, external script, deferred script, DOMContentLoaded, onload, and dynamic post-onload script.
+
 2010-09-06  Shane Stephens  <shanestephens@google.com>
 

trunk/WebCore/ChangeLog

@@ +1 @@
+2010-09-06  Tony Gentilcore  <tonyg@chromium.org>
+
+        Reviewed by Adam Barth.
+
+        Implement HTML5 definition of document.readyState
+        https://bugs.webkit.org/show_bug.cgi?id=45119
+
+        The legacy behavior was "loading" -> "loaded" -> "complete". The new
+        HTML5 behavior is "loading" -> "interactive" -> "complete". There is
+        some potential for this to cause compat problems if for instance a
+        page expects readyState to be "loaded" during the DOMContentLoaded event.
+
+        Test: fast/dom/Document/readystate.html
+
+        * dom/Document.cpp:
+        (WebCore::Document::Document): Initial value is Complete because according to http://www.whatwg.org/specs/web-apps/current-work/#dom-document-readystate,
+        when a Document is created the initial value is "complete" unless it has a parser associated with it, in which case it is "loading".
+        So the ctor starts it Complete, and when the parser is created it is flipped to Loading.
+        (WebCore::Document::readyState):
+        (WebCore::Document::setReadyState):
+        (WebCore::Document::implicitOpen):
+        (WebCore::Document::finishedParsing): Ensure that XML and HTML parser have transition to Stopping state.
+        * dom/Document.h:
+        * dom/DocumentParser.cpp:
+        (WebCore::DocumentParser::prepareToStopParsing): Previously this was being called when parsing had stopped.
+        It is better to ensure it is only called while parsing.
+        * dom/XMLDocumentParser.cpp:
+        (WebCore::XMLDocumentParser::end): Transition to stopping before calling document finishedParsiong().
+        * html/parser/HTMLDocumentParser.cpp:
+        (WebCore::HTMLDocumentParser::prepareToStopParsing): Set state to interactive before running deferred scripts.
+        This method is also called when parsing fragments, so we need to ensure it isn't done in that case.
+        (WebCore::HTMLDocumentParser::attemptToRunDeferredScriptsAndEnd): Added. Break out this part s that notifyFinished doesn't go through
+        the additional steps of pumping tokenizer, setting the state, etc.
+        (WebCore::HTMLDocumentParser::notifyFinished): Now that prepareToStopParsing is split up, we must protect. It also makes sense to add a couple of ASSERTs.
+        * loader/FrameLoader.cpp:
+        (WebCore::FrameLoader::stopLoading): It looks like an aborted load should never transition to "complete" according the HTML5. I've left the legacy behavior for now though.
+        (WebCore::FrameLoader::checkCompleted): The FrameLoader now sets the state on the Document instead of the Document polling the FrameLoader.
+
 2010-09-06  Anton Muhin  <antonm@chromium.org>
 

trunk/WebCore/dom/Document.cpp

@@ -358 +358 @@
     , m_domTreeVersion(0)
     , m_styleSheets(StyleSheetList::create(this))
+    , m_readyState(Complete)
     , m_styleRecalcTimer(this, &Document::styleRecalcTimerFired)
     , m_pendingStyleRecalcShouldForce(false)
@@ -953 +954 @@
 String Document::readyState() const
 {
-    if (Frame* f = frame()) {
-        if (f->loader()->isComplete()) 
-            return "complete";
-        if (parsing()) 
-            return "loading";
-        return "loaded";
-        // FIXME: What does "interactive" mean?
-        // FIXME: Missing support for "uninitialized".
-    }
+    DEFINE_STATIC_LOCAL(const String, loading, ("loading"));
+    DEFINE_STATIC_LOCAL(const String, interactive, ("interactive"));
+    DEFINE_STATIC_LOCAL(const String, complete, ("complete"));
+
+    switch (m_readyState) {
+    case Loading:
+        return loading;
+    case Interactive:
+        return interactive;
+    case Complete:
+        return complete;
+    }
+
+    ASSERT_NOT_REACHED();
     return String();
+}
+
+void Document::setReadyState(ReadyState readyState)
+{
+    // FIXME: Fire the readystatechange event on this Document.
+    m_readyState = readyState;
 }
 
@@ -1870 +1882 @@
     m_parser = createParser();
     setParsing(true);
+    setReadyState(Loading);
 
     ScriptableDocumentParser* parser = scriptableDocumentParser();
@@ -4104 +4117 @@
 void Document::finishedParsing()
 {
+    ASSERT(!scriptableDocumentParser() || !m_parser->isParsing());
+    ASSERT(!scriptableDocumentParser() || m_readyState != Loading);
     setParsing(false);
     dispatchEvent(Event::create(eventNames().DOMContentLoadedEvent, true, false));

trunk/WebCore/dom/Document.h

@@ -583 +583 @@
     bool inLimitedQuirksMode() const { return m_compatibilityMode == LimitedQuirksMode; }
     bool inNoQuirksMode() const { return m_compatibilityMode == NoQuirksMode; }
-    
+
+    enum ReadyState {
+        Loading,
+        Interactive,
+        Complete
+    };
+    void setReadyState(ReadyState);
     void setParsing(bool);
     bool parsing() const { return m_bParsing; }
@@ -1155 +1161 @@
     bool m_loadingSheet;
     bool m_visuallyOrdered;
+    ReadyState m_readyState;
     bool m_bParsing;
     

trunk/WebCore/dom/DocumentParser.cpp

@@ -53 +53 @@
 void DocumentParser::prepareToStopParsing()
 {
-    if (m_state == ParsingState)
-        m_state = StoppingState;
+    ASSERT(m_state == ParsingState);
+    m_state = StoppingState;
 }
 

trunk/WebCore/dom/XMLDocumentParser.cpp

@@ -235 +235 @@
     }
 
+    if (isParsing())
+        prepareToStopParsing();
+    document()->setReadyState(Document::Interactive);
     clearCurrentNodeStack();
     document()->finishedParsing();

trunk/WebCore/html/parser/HTMLDocumentParser.cpp

@@ -153 +153 @@
     RefPtr<HTMLDocumentParser> protect(this);
 
-    // FIXME: Set the current document readiness to "interactive".
-
     // NOTE: This pump should only ever emit buffered character tokens,
     // so ForceSynchronous vs. AllowYield should be meaningless.
     pumpTokenizerIfPossible(ForceSynchronous);
+    
+    if (isStopped())
+        return;
 
     DocumentParser::prepareToStopParsing();
-    if (m_scriptRunner && !m_scriptRunner->executeScriptsWaitingForParsing())
-        return;
-    end();
+
+    // We will not have a scriptRunner when parsing a DocumentFragment.
+    if (m_scriptRunner)
+        document()->setReadyState(Document::Interactive);
+
+    attemptToRunDeferredScriptsAndEnd();
 }
 
@@ -354 +358 @@
 }
 
+void HTMLDocumentParser::attemptToRunDeferredScriptsAndEnd()
+{
+    ASSERT(isStopping());
+    ASSERT(!hasInsertionPoint());
+    if (m_scriptRunner && !m_scriptRunner->executeScriptsWaitingForParsing())
+        return;
+    end();
+}
+
 void HTMLDocumentParser::attemptToEnd()
 {
@@ -461 +474 @@
 void HTMLDocumentParser::notifyFinished(CachedResource* cachedResource)
 {
-    if (isStopping()) {
-        prepareToStopParsing();
-        return;
-    }
-
     // pumpTokenizer can cause this parser to be detached from the Document,
     // but we need to ensure it isn't deleted yet.
@@ -472 +480 @@
     ASSERT(m_scriptRunner);
     ASSERT(!inScriptExecution());
+    if (isStopping()) {
+        attemptToRunDeferredScriptsAndEnd();
+        return;
+    }
+
     ASSERT(m_treeBuilder->isPaused());
     // Note: We only ever wait on one script at a time, so we always know this

trunk/WebCore/html/parser/HTMLDocumentParser.h

@@ -115 +115 @@
     void attemptToEnd();
     void endIfDelayed();
+    void attemptToRunDeferredScriptsAndEnd();
     void end();
 

trunk/WebCore/loader/FrameLoader.cpp

@@ -426 +426 @@
 
     if (Document* doc = m_frame->document()) {
+        // FIXME: HTML5 doesn't tell us to set the state to complete when aborting, but we do anyway to match legacy behavior.
+        // http://www.w3.org/Bugs/Public/show_bug.cgi?id=10537
+        doc->setReadyState(Document::Complete);
+
         if (DocLoader* docLoader = doc->docLoader())
             cache()->loader()->cancelRequests(docLoader);
@@ -839 +843 @@
     // OK, completed.
     m_isComplete = true;
+    m_frame->document()->setReadyState(Document::Complete);
 
     RefPtr<Frame> protect(m_frame);