Make HTMLParserScheduler inherit from ActiveDOMObject

third_party/WebKit/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 116 matching lines @@
       m_reentryPermit(HTMLParserReentryPermit::create()),
       m_token(syncPolicy == ForceSynchronousParsing ? wrapUnique(new HTMLToken)
                                                     : nullptr),
       m_tokenizer(syncPolicy == ForceSynchronousParsing
                       ? HTMLTokenizer::create(m_options)
                       : nullptr),
       m_loadingTaskRunner(
           TaskRunnerHelper::get(TaskType::Networking, &document)->clone()),
       m_parserScheduler(
           syncPolicy == AllowAsynchronousParsing
-              ? HTMLParserScheduler::create(this, m_loadingTaskRunner.get())
+              ? HTMLParserScheduler::create(document,
+                                            this,
+                                            m_loadingTaskRunner.get())
               : nullptr),
       m_xssAuditorDelegate(&document),
       m_weakFactory(this),
       m_preloader(HTMLResourcePreloader::create(document)),
       m_tokenizedChunkQueue(TokenizedChunkQueue::create()),
       m_evaluator(DocumentWriteEvaluator::create(document)),
       m_pendingCSPMetaToken(nullptr),
       m_shouldUseThreading(syncPolicy == AllowAsynchronousParsing),
       m_endWasDelayed(false),
       m_haveBackgroundParser(false),
-      m_tasksWereSuspended(false),
       m_pumpSessionNestingLevel(0),
       m_pumpSpeculationsSessionNestingLevel(0),
       m_isParsingAtLineNumber(false),
       m_triedLoadingLinkHeaders(false) {
   ASSERT(shouldUseThreading() || (m_token && m_tokenizer));
   // Threading is not allowed in prefetch mode.
   DCHECK(!document.isPrefetchOnly() || !shouldUseThreading());
 
   ThreadState::current()->registerPreFinalizer(this);
 }
@@ skipping 215 matching lines @@
         const CompactHTMLToken& token = chunk->tokens->at(index);
         ASSERT(token.type() == HTMLToken::TokenType::Character);
         evaluateAndPreloadScriptForDocumentWrite(token.data());
       }
     }
   }
 
   for (auto& chunk : pendingChunks)
     m_speculations.append(std::move(chunk));
 
-  if (!isWaitingForScripts() && !isScheduledForResume()) {
-    if (m_tasksWereSuspended)
-      m_parserScheduler->forceResumeAfterYield();
-    else
-      m_parserScheduler->scheduleForResume();
-  }
+  if (!isWaitingForScripts() && !isScheduledForResume())
+    m_parserScheduler->scheduleForResume();
 }
 
 void HTMLDocumentParser::didReceiveEncodingDataFromBackgroundParser(
     const DocumentEncodingData& data) {
   document()->setEncodingData(data);
 }
 
 void HTMLDocumentParser::validateSpeculations(
     std::unique_ptr<TokenizedChunk> chunk) {
   ASSERT(chunk);
@@ skipping 716 matching lines @@
     Element* contextElement,
     ParserContentPolicy parserContentPolicy) {
   HTMLDocumentParser* parser =
       HTMLDocumentParser::create(fragment, contextElement, parserContentPolicy);
   parser->append(source);
   parser->finish();
   // Allows ~DocumentParser to assert it was detached before destruction.
   parser->detach();
 }
 
-void HTMLDocumentParser::suspendScheduledTasks() {
-  ASSERT(!m_tasksWereSuspended);
-  m_tasksWereSuspended = true;
-  if (m_parserScheduler)
-    m_parserScheduler->suspend();
-}
-
-void HTMLDocumentParser::resumeScheduledTasks() {
-  ASSERT(m_tasksWereSuspended);
-  m_tasksWereSuspended = false;
-  if (m_parserScheduler)
-    m_parserScheduler->resume();
-}
-
 void HTMLDocumentParser::appendBytes(const char* data, size_t length) {
   if (!length || isStopped())
     return;
 
   if (shouldUseThreading()) {
     double bytesReceivedTime = monotonicallyIncreasingTimeMS();
     if (!m_haveBackgroundParser)
       startBackgroundParser();
 
     std::unique_ptr<Vector<char>> buffer = makeUnique<Vector<char>>(length);
@@ skipping 156 matching lines @@
     case Asynchronous:
       m_loadingTaskRunner->postTask(
           BLINK_FROM_HERE,
           WTF::bind(function, std::forward<Ps>(parameters)...));
       return;
   }
   NOTREACHED();
 }
 
 }  // namespace blink