Remove SynchronousMode, as it is always ForceSynchronous.

Source/core/html/parser/HTMLDocumentParser.cpp

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 201 matching lines @@
 void HTMLDocumentParser::prepareToStopParsing()
 {
     // FIXME: It may not be correct to disable this for the background parser.
     // That means hasInsertionPoint() may not be correct in some cases.
     ASSERT(!hasInsertionPoint() || m_haveBackgroundParser);
 
     // pumpTokenizer can cause this parser to be detached from the Document,
     // but we need to ensure it isn't deleted yet.
     RefPtrWillBeRawPtr<HTMLDocumentParser> protect(this);
 
-    // NOTE: This pump should only ever emit buffered character tokens,
-    // so ForceSynchronous vs. AllowYield should be meaningless.
+    // NOTE: This pump should only ever emit buffered character tokens.
     if (m_tokenizer) {
         ASSERT(!m_haveBackgroundParser);
-        pumpTokenizerIfPossible(ForceSynchronous);
+        pumpTokenizerIfPossible();
     }
 
     if (isStopped())
         return;
 
     DocumentParser::prepareToStopParsing();
 
     // We will not have a scriptRunner when parsing a DocumentFragment.
     if (m_scriptRunner)
         document()->setReadyState(Document::Interactive);
 
     // Setting the ready state above can fire mutation event and detach us
     // from underneath. In that case, just bail out.
     if (isDetached())
         return;
 
     attemptToRunDeferredScriptsAndEnd();
 }
 
 bool HTMLDocumentParser::isParsingFragment() const
 {
     return m_treeBuilder->isParsingFragment();
 }
 
 bool HTMLDocumentParser::processingData() const
 {
     return isScheduledForResume() || inPumpSession() || m_haveBackgroundParser;
 }
 
-void HTMLDocumentParser::pumpTokenizerIfPossible(SynchronousMode mode)
+void HTMLDocumentParser::pumpTokenizerIfPossible()
 {
-    ASSERT(mode == ForceSynchronous);
-
     if (isStopped())
         return;
     if (isWaitingForScripts())
         return;
 
     // Once a resume is scheduled, HTMLParserScheduler controls when we next pump.
     if (isScheduledForResume()) {
         return;
     }
 
-    pumpTokenizer(mode);
+    pumpTokenizer();
 }
 
 bool HTMLDocumentParser::isScheduledForResume() const
 {
     return m_parserScheduler && m_parserScheduler->isScheduledForResume();
 }
 
 // Used by HTMLParserScheduler
 void HTMLDocumentParser::resumeParsingAfterYield()
 {
@@ skipping 10 matching lines @@
 {
     ASSERT(scriptingContentIsAllowed(parserContentPolicy()));
 
     TextPosition scriptStartPosition = TextPosition::belowRangePosition();
     RefPtrWillBeRawPtr<Element> scriptElement = m_treeBuilder->takeScriptToProcess(scriptStartPosition);
     // We will not have a scriptRunner when parsing a DocumentFragment.
     if (m_scriptRunner)
         m_scriptRunner->execute(scriptElement.release(), scriptStartPosition);
 }
 
-bool HTMLDocumentParser::canTakeNextToken(SynchronousMode mode, PumpSession& session)
+bool HTMLDocumentParser::canTakeNextToken(PumpSession& session)
 {
     if (isStopped())
         return false;
 
-    ASSERT(!m_haveBackgroundParser || mode == ForceSynchronous);
-
     if (isWaitingForScripts()) {
-        if (mode == AllowYield)
-            session.didSeeScript = true;
-
         // If we don't run the script, we cannot allow the next token to be taken.
         if (session.needsYield)
             return false;
 
         // If we're paused waiting for a script, we try to execute scripts before continuing.
         runScriptsForPausedTreeBuilder();
         if (isStopped())
             return false;
         if (isWaitingForScripts())
             return false;
     }
 
     // FIXME: It's wrong for the HTMLDocumentParser to reach back to the
     //        LocalFrame, but this approach is how the old parser handled
     //        stopping when the page assigns window.location.  What really
     //        should happen is that assigning window.location causes the
     //        parser to stop parsing cleanly.  The problem is we're not
     //        perpared to do that at every point where we run JavaScript.
     if (!isParsingFragment()
         && document()->frame() && document()->frame()->navigationScheduler().locationChangePending())
         return false;
 
-    if (mode == AllowYield)
-        m_parserScheduler->checkForYieldBeforeToken(session);
-
     return true;
 }
 
 void HTMLDocumentParser::didReceiveParsedChunkFromBackgroundParser(PassOwnPtr<ParsedChunk> chunk)
 {
     TRACE_EVENT0("blink", "HTMLDocumentParser::didReceiveParsedChunkFromBackgroundParser");
 
     // alert(), runModalDialog, and the JavaScript Debugger all run nested event loops
     // which can cause this method to be re-entered. We detect re-entry using
     // hasActiveParser(), save the chunk as a speculation, and return.
@@ skipping 219 matching lines @@
 }
 
 static PassRefPtr<MediaValues> createMediaValues(Document* document)
 {
     ASSERT(document);
     RefPtr<MediaValues> mediaValues = MediaValuesCached::create(*document);
     ASSERT(mediaValues->isSafeToSendToAnotherThread());
     return mediaValues;
 }
 
-void HTMLDocumentParser::pumpTokenizer(SynchronousMode mode)
+void HTMLDocumentParser::pumpTokenizer()
 {
     ASSERT(!isStopped());
     ASSERT(!isScheduledForResume());
 #if !ENABLE(OILPAN)
     // ASSERT that this object is both attached to the Document and protected.
     ASSERT(refCount() >= 2);
 #endif
     ASSERT(m_tokenizer);
     ASSERT(m_token);
-    ASSERT(mode == ForceSynchronous);
 
     PumpSession session(m_pumpSessionNestingLevel, contextForParsingSession());
 
     // We tell the InspectorInstrumentation about every pump, even if we
     // end up pumping nothing.  It can filter out empty pumps itself.
     // FIXME: m_input.current().length() is only accurate if we
     // end up parsing the whole buffer in this pump.  We should pass how
     // much we parsed as part of didWriteHTML instead of willWriteHTML.
     TRACE_EVENT_BEGIN1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "ParseHTML", "beginData", InspectorParseHtmlEvent::beginData(document(), m_input.current().currentLine().zeroBasedInt()));
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline.stack"), "CallStack", "stack", InspectorCallStackEvent::currentCallStack());
     // FIXME(361045): remove InspectorInstrumentation calls once DevTools Timeline migrates to tracing.
     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willWriteHTML(document(), m_input.current().currentLine().zeroBasedInt());
 
     m_xssAuditor.init(document(), &m_xssAuditorDelegate);
 
-    while (canTakeNextToken(mode, session) && !session.needsYield) {
+    while (canTakeNextToken(session) && !session.needsYield) {
         if (!isParsingFragment())
             m_sourceTracker.start(m_input.current(), m_tokenizer.get(), token());
 
         if (!m_tokenizer->nextToken(m_input.current(), token()))
             break;
 
         if (!isParsingFragment()) {
             m_sourceTracker.end(m_input.current(), m_tokenizer.get(), token());
 
             // We do not XSS filter innerHTML, which means we (intentionally) fail
@@ skipping 10 matching lines @@
     // Ensure we haven't been totally deref'ed after pumping. Any caller of this
     // function should be holding a RefPtr to this to ensure we weren't deleted.
     ASSERT(refCount() >= 1);
 #endif
 
     if (isStopped())
         return;
 
     // There should only be PendingText left since the tree-builder always flushes
     // the task queue before returning. In case that ever changes, crash.
-    if (mode == ForceSynchronous)
-        m_treeBuilder->flush(FlushAlways);
+    m_treeBuilder->flush(FlushAlways);
     RELEASE_ASSERT(!isStopped());
 
     if (session.needsYield)
         m_parserScheduler->scheduleForResume();
 
     if (isWaitingForScripts()) {
         ASSERT(m_tokenizer->state() == HTMLTokenizer::DataState);
         if (!m_preloadScanner) {
             m_preloadScanner = adoptPtr(new HTMLPreloadScanner(m_options, document()->url(), createMediaValues(document())));
             m_preloadScanner->appendToEnd(m_input.current());
@@ skipping 61 matching lines @@
     if (!m_tokenizer) {
         ASSERT(!inPumpSession());
         ASSERT(m_haveBackgroundParser || wasCreatedByScript());
         m_token = adoptPtr(new HTMLToken);
         m_tokenizer = HTMLTokenizer::create(m_options);
     }
 
     SegmentedString excludedLineNumberSource(source);
     excludedLineNumberSource.setExcludeLineNumbers();
     m_input.insertAtCurrentInsertionPoint(excludedLineNumberSource);
-    pumpTokenizerIfPossible(ForceSynchronous);
+    pumpTokenizerIfPossible();
 
     if (isWaitingForScripts()) {
         // Check the document.write() output with a separate preload scanner as
         // the main scanner can't deal with insertions.
         if (!m_insertionPreloadScanner)
             m_insertionPreloadScanner = adoptPtr(new HTMLPreloadScanner(m_options, document()->url(), createMediaValues(document())));
 
         m_insertionPreloadScanner->appendToEnd(source);
         m_insertionPreloadScanner->scan(m_preloader.get(), document()->baseElementURL());
     }
@@ skipping 75 matching lines @@
         // not worry.  We'll consume this data in a less-nested write().
         return;
     }
 
     // A couple pinToMainThread() callers require synchronous parsing, but can't
     // easily use the insert() method, so we hack append() for them to be synchronous.
     // javascript: url handling is one such caller.
     // FIXME: This is gross, and we should separate the concept of synchronous parsing
     // from insert() so that only document.write() uses insert.
     ASSERT(m_isPinnedToMainThread);
-    pumpTokenizerIfPossible(ForceSynchronous);
+    pumpTokenizerIfPossible();
 
     endIfDelayed();
 }
 
 void HTMLDocumentParser::end()
 {
     ASSERT(!isDetached());
     ASSERT(!isScheduledForResume());
 
     if (m_haveBackgroundParser)
@@ skipping 133 matching lines @@
         validateSpeculations(m_lastChunkBeforeScript.release());
         ASSERT(!m_lastChunkBeforeScript);
         // processParsedChunkFromBackgroundParser can cause this parser to be detached from the Document,
         // but we need to ensure it isn't deleted yet.
         RefPtrWillBeRawPtr<HTMLDocumentParser> protect(this);
         pumpPendingSpeculations();
         return;
     }
 
     m_insertionPreloadScanner.clear();
-    pumpTokenizerIfPossible(ForceSynchronous);
+    pumpTokenizerIfPossible();
     endIfDelayed();
 }
 
 void HTMLDocumentParser::appendCurrentInputStreamToPreloadScannerAndScan()
 {
     ASSERT(m_preloadScanner);
     m_preloadScanner->appendToEnd(m_input.current());
     m_preloadScanner->scan(m_preloader.get(), document()->baseElementURL());
 }
 
@@ skipping 90 matching lines @@
 void HTMLDocumentParser::setDecoder(PassOwnPtr<TextResourceDecoder> decoder)
 {
     ASSERT(decoder);
     DecodedDataDocumentParser::setDecoder(decoder);
 
     if (m_haveBackgroundParser)
         HTMLParserThread::shared()->postTask(bind(&BackgroundHTMLParser::setDecoder, m_backgroundParser, takeDecoder()));
 }
 
 }