Reformat comments in core/html/parser

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 94 matching lines @@
 HTMLDocumentParser::HTMLDocumentParser(DocumentFragment* fragment,
                                        Element* contextElement,
                                        ParserContentPolicy parserContentPolicy)
     : HTMLDocumentParser(fragment->document(),
                          parserContentPolicy,
                          ForceSynchronousParsing) {
   // No m_scriptRunner in fragment parser.
   m_treeBuilder = HTMLTreeBuilder::create(this, fragment, contextElement,
                                           parserContentPolicy, m_options);
 
-  bool reportErrors =
-      false;  // For now document fragment parsing never reports errors.
+  // For now document fragment parsing never reports errors.
+  bool reportErrors = false;
   m_tokenizer->setState(
       tokenizerStateForContextElement(contextElement, reportErrors, m_options));
   m_xssAuditor.initForFragment();
 }
 
 HTMLDocumentParser::HTMLDocumentParser(Document& document,
                                        ParserContentPolicy contentPolicy,
                                        ParserSynchronizationPolicy syncPolicy)
     : ScriptableDocumentParser(document, contentPolicy),
       m_options(&document),
@@ skipping 26 matching lines @@
   ASSERT(shouldUseThreading() || (m_token && m_tokenizer));
   // Threading is not allowed in prefetch mode.
   DCHECK(!document.isPrefetchOnly() || !shouldUseThreading());
 
   ThreadState::current()->registerPreFinalizer(this);
 }
 
 HTMLDocumentParser::~HTMLDocumentParser() {}
 
 void HTMLDocumentParser::dispose() {
-  // In Oilpan, HTMLDocumentParser can die together with Document, and
-  // detach() is not called in this case.
+  // In Oilpan, HTMLDocumentParser can die together with Document, and detach()
+  // is not called in this case.
   if (m_haveBackgroundParser)
     stopBackgroundParser();
 }
 
 DEFINE_TRACE(HTMLDocumentParser) {
   visitor->trace(m_treeBuilder);
   visitor->trace(m_parserScheduler);
   visitor->trace(m_xssAuditorDelegate);
   visitor->trace(m_scriptRunner);
   visitor->trace(m_preloader);
@@ skipping 13 matching lines @@
     peakPendingTokenHistogram.count(
         m_tokenizedChunkQueue->peakPendingTokenCount());
   }
 
   if (m_haveBackgroundParser)
     stopBackgroundParser();
   DocumentParser::detach();
   if (m_scriptRunner)
     m_scriptRunner->detach();
   m_treeBuilder->detach();
-  // FIXME: It seems wrong that we would have a preload scanner here.
-  // Yet during fast/dom/HTMLScriptElement/script-load-events.html we do.
+  // FIXME: It seems wrong that we would have a preload scanner here. Yet during
+  // fast/dom/HTMLScriptElement/script-load-events.html we do.
   m_preloadScanner.reset();
   m_insertionPreloadScanner.reset();
   if (m_parserScheduler) {
     m_parserScheduler->detach();
     m_parserScheduler.clear();
   }
   // Oilpan: It is important to clear m_token to deallocate backing memory of
   // HTMLToken::m_data and let the allocator reuse the memory for
   // HTMLToken::m_data of a next HTMLDocumentParser. We need to clear
   // m_tokenizer first because m_tokenizer has a raw pointer to m_token.
@@ skipping 26 matching lines @@
 
   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.
+  // 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();
 }
 
@@ skipping 24 matching lines @@
       m_treeBuilder->takeScriptToProcess(scriptStartPosition);
   // We will not have a scriptRunner when parsing a DocumentFragment.
   if (m_scriptRunner)
     m_scriptRunner->execute(scriptElement, scriptStartPosition);
 }
 
 bool HTMLDocumentParser::canTakeNextToken() {
   if (isStopped())
     return false;
 
-  // If we're paused waiting for a script, we try to execute scripts before continuing.
+  // If we're paused waiting for a script, we try to execute scripts before
+  // continuing.
   if (m_treeBuilder->hasParserBlockingScript())
     runScriptsForPausedTreeBuilder();
   if (isStopped() || 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.
+  // 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;
 
   return true;
 }
 
 void HTMLDocumentParser::notifyPendingTokenizedChunks() {
   TRACE_EVENT0("blink", "HTMLDocumentParser::notifyPendingTokenizedChunks");
   DCHECK(m_tokenizedChunkQueue);
 
   Vector<std::unique_ptr<TokenizedChunk>> pendingChunks;
   m_tokenizedChunkQueue->takeAll(pendingChunks);
 
   if (!isParsing())
     return;
 
-  // ApplicationCache needs to be initialized before issuing preloads.
-  // We suspend preload until HTMLHTMLElement is inserted and
-  // ApplicationCache is initialized. Note: link rel preloads don't follow
-  // this policy per the spec. These directives should initiate a fetch as
-  // fast as possible.
+  // ApplicationCache needs to be initialized before issuing preloads. We
+  // suspend preload until HTMLHTMLElement is inserted and ApplicationCache is
+  // initialized. Note: link rel preloads don't follow this policy per the spec.
+  // These directives should initiate a fetch as fast as possible.
   if (!m_triedLoadingLinkHeaders && document()->loader() &&
       !pendingChunks.isEmpty()) {
-    // Note that on commit, the loader dispatched preloads for all the
-    // non-media links.
+    // Note that on commit, the loader dispatched preloads for all the non-media
+    // links.
     document()->loader()->dispatchLinkHeaderPreloads(
         &pendingChunks.first()->viewport, LinkLoader::OnlyLoadMedia);
     m_triedLoadingLinkHeaders = true;
   }
 
   // Defer preloads if any of the chunks contains a <meta> csp tag.
   for (auto& chunk : pendingChunks) {
     if (chunk->pendingCSPMetaTokenIndex != TokenizedChunk::noPendingToken) {
       m_pendingCSPMetaToken =
           &chunk->tokens->at(chunk->pendingCSPMetaTokenIndex);
@@ skipping 12 matching lines @@
           m_queuedPreloads.append(std::move(request));
       }
       for (auto& index : chunk->likelyDocumentWriteScriptIndices) {
         const CompactHTMLToken& token = chunk->tokens->at(index);
         ASSERT(token.type() == HTMLToken::TokenType::Character);
         m_queuedDocumentWriteScripts.append(token.data());
       }
     }
     m_preloader->takeAndPreload(linkRelPreloads);
   } else {
-    // We can safely assume that there are no queued preloads request after
-    // the document element is available, as we empty the queue immediately
-    // after the document element is created in documentElementAvailable().
+    // We can safely assume that there are no queued preloads request after the
+    // document element is available, as we empty the queue immediately after
+    // the document element is created in documentElementAvailable().
     ASSERT(m_queuedPreloads.isEmpty());
     ASSERT(m_queuedDocumentWriteScripts.isEmpty());
-    // Loop through the chunks to generate preloads before any
-    // document.write script evaluation takes place. Preloading these
-    // scripts is valuable and comparably cheap, while evaluating JS can be
-    // expensive.
+    // Loop through the chunks to generate preloads before any document.write
+    // script evaluation takes place. Preloading these scripts is valuable and
+    // comparably cheap, while evaluating JS can be expensive.
     for (auto& chunk : pendingChunks) {
       m_preloader->takeAndPreload(chunk->preloads);
     }
     for (auto& chunk : pendingChunks) {
       for (auto& index : chunk->likelyDocumentWriteScriptIndices) {
         const CompactHTMLToken& token = chunk->tokens->at(index);
         ASSERT(token.type() == HTMLToken::TokenType::Character);
         evaluateAndPreloadScriptForDocumentWrite(token.data());
       }
     }
@@ skipping 12 matching lines @@
 
 void HTMLDocumentParser::didReceiveEncodingDataFromBackgroundParser(
     const DocumentEncodingData& data) {
   document()->setEncodingData(data);
 }
 
 void HTMLDocumentParser::validateSpeculations(
     std::unique_ptr<TokenizedChunk> chunk) {
   ASSERT(chunk);
   if (isWaitingForScripts()) {
-    // We're waiting on a network script, just save the chunk, we'll get
-    // a second validateSpeculations call after the script completes.
-    // This call should have been made immediately after runScriptsForPausedTreeBuilder
+    // We're waiting on a network script, just save the chunk, we'll get a
+    // second validateSpeculations call after the script completes. This call
+    // should have been made immediately after runScriptsForPausedTreeBuilder
     // which may have started a network load and left us waiting.
     ASSERT(!m_lastChunkBeforeScript);
     m_lastChunkBeforeScript = std::move(chunk);
     return;
   }
 
   ASSERT(!m_lastChunkBeforeScript);
   std::unique_ptr<HTMLTokenizer> tokenizer = std::move(m_tokenizer);
   std::unique_ptr<HTMLToken> token = std::move(m_token);
 
   if (!tokenizer) {
-    // There must not have been any changes to the HTMLTokenizer state on
-    // the main thread, which means the speculation buffer is correct.
+    // There must not have been any changes to the HTMLTokenizer state on the
+    // main thread, which means the speculation buffer is correct.
     return;
   }
 
-  // Currently we're only smart enough to reuse the speculation buffer if the tokenizer
-  // both starts and ends in the DataState. That state is simplest because the HTMLToken
-  // is always in the Uninitialized state. We should consider whether we can reuse the
-  // speculation buffer in other states, but we'd likely need to do something more
-  // sophisticated with the HTMLToken.
+  // Currently we're only smart enough to reuse the speculation buffer if the
+  // tokenizer both starts and ends in the DataState. That state is simplest
+  // because the HTMLToken is always in the Uninitialized state. We should
+  // consider whether we can reuse the speculation buffer in other states, but
+  // we'd likely need to do something more sophisticated with the HTMLToken.
   if (chunk->tokenizerState == HTMLTokenizer::DataState &&
       tokenizer->getState() == HTMLTokenizer::DataState &&
       m_input.current().isEmpty() &&
       chunk->treeBuilderState ==
           HTMLTreeBuilderSimulator::stateFor(m_treeBuilder.get())) {
     ASSERT(token->isUninitialized());
     return;
   }
 
   discardSpeculationsAndResumeFrom(std::move(chunk), std::move(token),
@@ skipping 22 matching lines @@
       wrapUnique(new BackgroundHTMLParser::Checkpoint);
   checkpoint->parser = m_weakFactory.createWeakPtr();
   checkpoint->token = std::move(token);
   checkpoint->tokenizer = std::move(tokenizer);
   checkpoint->treeBuilderState =
       HTMLTreeBuilderSimulator::stateFor(m_treeBuilder.get());
   checkpoint->inputCheckpoint = lastChunkBeforeScript->inputCheckpoint;
   checkpoint->preloadScannerCheckpoint =
       lastChunkBeforeScript->preloadScannerCheckpoint;
   checkpoint->unparsedInput = m_input.current().toString().isolatedCopy();
-  m_input.current()
-      .clear();  // FIXME: This should be passed in instead of cleared.
+  // FIXME: This should be passed in instead of cleared.
+  m_input.current().clear();
 
   ASSERT(checkpoint->unparsedInput.isSafeToSendToAnotherThread());
   postTaskToLookaheadParser(Asynchronous, &BackgroundHTMLParser::resumeFrom,
                             m_backgroundParser, passed(std::move(checkpoint)));
 }
 
 size_t HTMLDocumentParser::processTokenizedChunkFromBackgroundParser(
     std::unique_ptr<TokenizedChunk> popChunk) {
   TRACE_EVENT_WITH_FLOW0(
       "blink,loading",
@@ skipping 18 matching lines @@
   postTaskToLookaheadParser(Asynchronous,
                             &BackgroundHTMLParser::startedChunkWithCheckpoint,
                             m_backgroundParser, chunk->inputCheckpoint);
 
   for (const auto& xssInfo : chunk->xssInfos) {
     m_textPosition = xssInfo->m_textPosition;
     m_xssAuditorDelegate.didBlockScript(*xssInfo);
     if (isStopped())
       break;
   }
-  // XSSAuditorDelegate can detach the parser if it decides to block the entire current document.
+  // XSSAuditorDelegate can detach the parser if it decides to block the entire
+  // current document.
   if (isDetached())
     return elementTokenCount;
 
   for (Vector<CompactHTMLToken>::const_iterator it = tokens->begin();
        it != tokens->end(); ++it) {
     ASSERT(!isWaitingForScripts());
 
     if (!chunk->startingScript &&
         (it->type() == HTMLToken::StartTag || it->type() == HTMLToken::EndTag))
       elementTokenCount++;
 
     if (document()->frame() &&
         document()->frame()->navigationScheduler().locationChangePending()) {
-      // To match main-thread parser behavior (which never checks locationChangePending on the EOF path)
-      // we peek to see if this chunk has an EOF and process it anyway.
+      // To match main-thread parser behavior (which never checks
+      // locationChangePending on the EOF path) we peek to see if this chunk has
+      // an EOF and process it anyway.
       if (tokens->last().type() == HTMLToken::EndOfFile) {
         ASSERT(
             m_speculations
                 .isEmpty());  // There should never be any chunks after the EOF.
         prepareToStopParsing();
       }
       break;
     }
 
     m_textPosition = it->textPosition();
 
     constructTreeFromCompactHTMLToken(*it);
 
     if (isStopped())
       break;
 
     // Preloads were queued if there was a <meta> csp token in a tokenized
     // chunk.
     if (m_pendingCSPMetaToken && it == m_pendingCSPMetaToken) {
       m_pendingCSPMetaToken = nullptr;
       fetchQueuedPreloads();
     }
 
     if (isWaitingForScripts()) {
-      ASSERT(
-          it + 1 ==
-          tokens
-              ->end());  // The </script> is assumed to be the last token of this bunch.
+      // The </script> is assumed to be the last token of this bunch.
+      ASSERT(it + 1 == tokens->end());
       runScriptsForPausedTreeBuilder();
       validateSpeculations(std::move(chunk));
       break;
     }
 
     if (it->type() == HTMLToken::EndOfFile) {
-      ASSERT(
-          it + 1 ==
-          tokens
-              ->end());  // The EOF is assumed to be the last token of this bunch.
-      ASSERT(
-          m_speculations
-              .isEmpty());  // There should never be any chunks after the EOF.
+      // The EOF is assumed to be the last token of this bunch.
+      ASSERT(it + 1 == tokens->end());
+      // There should never be any chunks after the EOF.
+      ASSERT(m_speculations.isEmpty());
       prepareToStopParsing();
       break;
     }
 
     ASSERT(!m_tokenizer);
     ASSERT(!m_token);
   }
 
   // Make sure all required pending text nodes are emitted before returning.
   // This leaves "script", "style" and "svg" nodes text nodes intact.
@@ skipping 34 matching lines @@
                      InspectorParseHtmlEvent::beginData(
                          document(), lineNumber().zeroBasedInt()));
 
   SpeculationsPumpSession session(m_pumpSpeculationsSessionNestingLevel);
   while (!m_speculations.isEmpty()) {
     ASSERT(!isScheduledForResume());
     size_t elementTokenCount =
         processTokenizedChunkFromBackgroundParser(m_speculations.takeFirst());
     session.addedElementTokens(elementTokenCount);
 
-    // Always check isParsing first as m_document may be null.
-    // Surprisingly, isScheduledForResume() may be set here as a result of
+    // Always check isParsing first as m_document may be null. Surprisingly,
+    // isScheduledForResume() may be set here as a result of
     // processTokenizedChunkFromBackgroundParser running arbitrary javascript
     // which invokes nested event loops. (e.g. inspector breakpoints)
     if (!isParsing() || isWaitingForScripts() || isScheduledForResume())
       break;
 
     if (m_speculations.isEmpty() ||
         m_parserScheduler->yieldIfNeeded(
             session, m_speculations.first()->startingScript))
       break;
   }
@@ skipping 22 matching lines @@
     m_tokenizer->setState(HTMLTokenizer::PLAINTEXTState);
 }
 
 void HTMLDocumentParser::pumpTokenizer() {
   ASSERT(!isStopped());
   ASSERT(m_tokenizer);
   ASSERT(m_token);
 
   PumpSession session(m_pumpSessionNestingLevel);
 
-  // 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.
+  // 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(
       "devtools.timeline", "ParseHTML", "beginData",
       InspectorParseHtmlEvent::beginData(
           document(), m_input.current().currentLine().zeroBasedInt()));
 
   if (!isParsingFragment())
     m_xssAuditor.init(document(), &m_xssAuditorDelegate);
 
   while (canTakeNextToken()) {
     if (m_xssAuditor.isEnabled())
@@ skipping 22 matching lines @@
 
   // There should only be PendingText left since the tree-builder always flushes
   // the task queue before returning. In case that ever changes, crash.
   m_treeBuilder->flush(FlushAlways);
   RELEASE_ASSERT(!isStopped());
 
   if (isWaitingForScripts()) {
     ASSERT(m_tokenizer->getState() == HTMLTokenizer::DataState);
 
     ASSERT(m_preloader);
-    // TODO(kouhei): m_preloader should be always available for synchronous parsing case,
-    // adding paranoia if for speculative crash fix for crbug.com/465478
+    // TODO(kouhei): m_preloader should be always available for synchronous
+    // parsing case, adding paranoia if for speculative crash fix for
+    // crbug.com/465478
     if (m_preloader) {
       if (!m_preloadScanner) {
         m_preloadScanner = createPreloadScanner();
         m_preloadScanner->appendToEnd(m_input.current());
       }
       m_preloadScanner->scanAndPreload(
           m_preloader.get(), document()->validBaseElementURL(), nullptr);
     }
   }
 
@@ skipping 30 matching lines @@
   }
 }
 
 void HTMLDocumentParser::constructTreeFromCompactHTMLToken(
     const CompactHTMLToken& compactToken) {
   AtomicHTMLToken token(compactToken);
   m_treeBuilder->constructTree(&token);
 }
 
 bool HTMLDocumentParser::hasInsertionPoint() {
-  // FIXME: The wasCreatedByScript() branch here might not be fully correct.
-  //        Our model of the EOF character differs slightly from the one in
-  //        the spec because our treatment is uniform between network-sourced
-  //        and script-sourced input streams whereas the spec treats them
-  //        differently.
+  // FIXME: The wasCreatedByScript() branch here might not be fully correct. Our
+  // model of the EOF character differs slightly from the one in the spec
+  // because our treatment is uniform between network-sourced and script-sourced
+  // input streams whereas the spec treats them differently.
   return m_input.hasInsertionPoint() ||
          (wasCreatedByScript() && !m_input.haveSeenEndOfFile());
 }
 
 void HTMLDocumentParser::insert(const SegmentedString& source) {
   if (isStopped())
     return;
 
   TRACE_EVENT1("blink", "HTMLDocumentParser::insert", "source_length",
                source.length());
@@ skipping 23 matching lines @@
   endIfDelayed();
 }
 
 void HTMLDocumentParser::startBackgroundParser() {
   ASSERT(!isStopped());
   ASSERT(shouldUseThreading());
   ASSERT(!m_haveBackgroundParser);
   ASSERT(document());
   m_haveBackgroundParser = true;
 
-  // TODO(alexclarke): Remove WebFrameScheduler::setDocumentParsingInBackground when background parser goes away.
+  // TODO(alexclarke): Remove WebFrameScheduler::setDocumentParsingInBackground
+  // when background parser goes away.
   if (document()->frame() && document()->frame()->frameScheduler())
     document()->frame()->frameScheduler()->setDocumentParsingInBackground(true);
 
-  // Make sure that a resolver is set up, so that the correct viewport dimensions will be fed to the background parser and preload scanner.
+  // Make sure that a resolver is set up, so that the correct viewport
+  // dimensions will be fed to the background parser and preload scanner.
   if (document()->loader())
     document()->ensureStyleResolver();
 
   std::unique_ptr<BackgroundHTMLParser::Configuration> config =
       wrapUnique(new BackgroundHTMLParser::Configuration);
   config->options = m_options;
   config->parser = m_weakFactory.createWeakPtr();
   config->xssAuditor = wrapUnique(new XSSAuditor);
   config->xssAuditor->init(document(), &m_xssAuditorDelegate);
 
@@ skipping 40 matching lines @@
   // ParseHTMLOnMainThread lands (the lookahead parser will be a member).
   postTaskToLookaheadParser(Synchronous, &BackgroundHTMLParser::stop,
                             m_backgroundParser);
   m_weakFactory.revokeAll();
 }
 
 void HTMLDocumentParser::append(const String& inputSource) {
   if (isStopped())
     return;
 
-  // We should never reach this point if we're using a parser thread,
-  // as appendBytes() will directly ship the data to the thread.
+  // We should never reach this point if we're using a parser thread, as
+  // appendBytes() will directly ship the data to the thread.
   ASSERT(!shouldUseThreading());
 
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.debug"),
                "HTMLDocumentParser::append", "size", inputSource.length());
   const SegmentedString source(inputSource);
 
   if (document()->isPrefetchOnly()) {
     if (!m_preloadScanner)
       m_preloadScanner = createPreloadScanner();
 
     m_preloadScanner->appendToEnd(source);
     m_preloadScanner->scanAndPreload(
         m_preloader.get(), document()->validBaseElementURL(), nullptr);
 
     // Return after the preload scanner, do not actually parse the document.
     return;
   }
 
   if (m_preloadScanner) {
     if (m_input.current().isEmpty() && !isWaitingForScripts()) {
-      // We have parsed until the end of the current input and so are now moving ahead of the preload scanner.
-      // Clear the scanner so we know to scan starting from the current input point if we block again.
+      // We have parsed until the end of the current input and so are now moving
+      // ahead of the preload scanner. Clear the scanner so we know to scan
+      // starting from the current input point if we block again.
       m_preloadScanner.reset();
     } else {
       m_preloadScanner->appendToEnd(source);
       if (isWaitingForScripts())
         m_preloadScanner->scanAndPreload(
             m_preloader.get(), document()->validBaseElementURL(), nullptr);
     }
   }
 
   m_input.appendToEnd(source);
 
   if (inPumpSession()) {
-    // We've gotten data off the network in a nested write.
-    // We don't want to consume any more of the input stream now.  Do
-    // not worry.  We'll consume this data in a less-nested write().
+    // We've gotten data off the network in a nested write. We don't want to
+    // consume any more of the input stream now.  Do not worry.  We'll consume
+    // this data in a less-nested write().
     return;
   }
 
   pumpTokenizerIfPossible();
 
   endIfDelayed();
 }
 
 void HTMLDocumentParser::end() {
   ASSERT(!isDetached());
   ASSERT(!isScheduledForResume());
 
   if (m_haveBackgroundParser)
     stopBackgroundParser();
 
-  // Informs the the rest of WebCore that parsing is really finished (and deletes this).
+  // Informs the the rest of WebCore that parsing is really finished (and
+  // deletes this).
   m_treeBuilder->finished();
 
   DocumentParser::stopParsing();
 }
 
 void HTMLDocumentParser::attemptToRunDeferredScriptsAndEnd() {
   ASSERT(isStopping());
   // 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);
@@ skipping 19 matching lines @@
     return;
 
   if (!m_endWasDelayed || shouldDelayEnd())
     return;
 
   m_endWasDelayed = false;
   prepareToStopParsing();
 }
 
 void HTMLDocumentParser::finish() {
-  // FIXME: We should ASSERT(!m_parserStopped) here, since it does not
-  // makes sense to call any methods on DocumentParser once it's been stopped.
+  // FIXME: We should ASSERT(!m_parserStopped) here, since it does not makes
+  // sense to call any methods on DocumentParser once it's been stopped.
   // However, FrameLoader::stop calls DocumentParser::finish unconditionally.
 
   flush();
   if (isDetached())
     return;
 
-  // Empty documents never got an append() call, and thus have never started
-  // a background parser. In those cases, we ignore shouldUseThreading()
-  // and fall through to the non-threading case.
+  // Empty documents never got an append() call, and thus have never started a
+  // background parser. In those cases, we ignore shouldUseThreading() and fall
+  // through to the non-threading case.
   if (m_haveBackgroundParser) {
     if (!m_input.haveSeenEndOfFile())
       m_input.closeWithoutMarkingEndOfFile();
     postTaskToLookaheadParser(Asynchronous, &BackgroundHTMLParser::finish,
                               m_backgroundParser);
     return;
   }
 
   if (!m_tokenizer) {
     ASSERT(!m_token);
-    // We're finishing before receiving any data. Rather than booting up
-    // the background parser just to spin it down, we finish parsing
-    // synchronously.
+    // We're finishing before receiving any data. Rather than booting up the
+    // background parser just to spin it down, we finish parsing synchronously.
     m_token = wrapUnique(new HTMLToken);
     m_tokenizer = HTMLTokenizer::create(m_options);
   }
 
-  // We're not going to get any more data off the network, so we tell the
-  // input stream we've reached the end of file. finish() can be called more
-  // than once, if the first time does not call end().
+  // We're not going to get any more data off the network, so we tell the input
+  // stream we've reached the end of file. finish() can be called more than
+  // once, if the first time does not call end().
   if (!m_input.haveSeenEndOfFile())
     m_input.markEndOfFile();
 
   attemptToEnd();
 }
 
 bool HTMLDocumentParser::isExecutingScript() const {
   if (!m_scriptRunner)
     return false;
   return m_scriptRunner->isExecutingScript();
@@ skipping 16 matching lines @@
     return m_textPosition;
 
   const SegmentedString& currentString = m_input.current();
   OrdinalNumber line = currentString.currentLine();
   OrdinalNumber column = currentString.currentColumn();
 
   return TextPosition(line, column);
 }
 
 bool HTMLDocumentParser::isWaitingForScripts() const {
-  // When the TreeBuilder encounters a </script> tag, it returns to the HTMLDocumentParser
-  // where the script is transfered from the treebuilder to the script runner.
-  // The script runner will hold the script until its loaded and run. During
-  // any of this time, we want to count ourselves as "waiting for a script" and thus
-  // run the preload scanner, as well as delay completion of parsing.
+  // When the TreeBuilder encounters a </script> tag, it returns to the
+  // HTMLDocumentParser where the script is transfered from the treebuilder to
+  // the script runner. The script runner will hold the script until its loaded
+  // and run. During any of this time, we want to count ourselves as "waiting
+  // for a script" and thus run the preload scanner, as well as delay completion
+  // of parsing.
   bool treeBuilderHasBlockingScript = m_treeBuilder->hasParserBlockingScript();
   bool scriptRunnerHasBlockingScript =
       m_scriptRunner && m_scriptRunner->hasParserBlockingScript();
-  // Since the parser is paused while a script runner has a blocking script, it should
-  // never be possible to end up with both objects holding a blocking script.
+  // Since the parser is paused while a script runner has a blocking script, it
+  // should never be possible to end up with both objects holding a blocking
+  // script.
   ASSERT(!(treeBuilderHasBlockingScript && scriptRunnerHasBlockingScript));
   // If either object has a blocking script, the parser should be paused.
   return treeBuilderHasBlockingScript || scriptRunnerHasBlockingScript ||
          m_reentryPermit->parserPauseFlag();
 }
 
 void HTMLDocumentParser::resumeParsingAfterScriptExecution() {
   ASSERT(!isExecutingScript());
   ASSERT(!isWaitingForScripts());
 
@@ skipping 28 matching lines @@
     attemptToRunDeferredScriptsAndEnd();
     return;
   }
 
   m_scriptRunner->executeScriptsWaitingForLoad(cachedResource);
   if (!isWaitingForScripts())
     resumeParsingAfterScriptExecution();
 }
 
 void HTMLDocumentParser::executeScriptsWaitingForResources() {
-  // Document only calls this when the Document owns the DocumentParser
-  // so this will not be called in the DocumentFragment case.
+  // Document only calls this when the Document owns the DocumentParser so this
+  // will not be called in the DocumentFragment case.
   ASSERT(m_scriptRunner);
   // Ignore calls unless we have a script blocking the parser waiting on a
-  // stylesheet load.  Otherwise we are currently parsing and this
-  // is a re-entrant call from encountering a </ style> tag.
+  // stylesheet load.  Otherwise we are currently parsing and this is a
+  // re-entrant call from encountering a </ style> tag.
   if (!m_scriptRunner->hasScriptsWaitingForResources())
     return;
   m_scriptRunner->executeScriptsWaitingForResources();
   if (!isWaitingForScripts())
     resumeParsingAfterScriptExecution();
 }
 
 void HTMLDocumentParser::parseDocumentFragment(
     const String& source,
     DocumentFragment* fragment,
     Element* contextElement,
     ParserContentPolicy parserContentPolicy) {
   HTMLDocumentParser* parser =
       HTMLDocumentParser::create(fragment, contextElement, parserContentPolicy);
   parser->append(source);
   parser->finish();
-  parser
-      ->detach();  // Allows ~DocumentParser to assert it was detached before destruction.
+  // 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() {
@@ skipping 30 matching lines @@
 
   DecodedDataDocumentParser::appendBytes(data, length);
 }
 
 void HTMLDocumentParser::flush() {
   // If we've got no decoder, we never received any data.
   if (isDetached() || needsDecoder())
     return;
 
   if (shouldUseThreading()) {
-    // In some cases, flush() is called without any invocation of
-    // appendBytes. Fallback to synchronous parsing in that case.
+    // In some cases, flush() is called without any invocation of appendBytes.
+    // Fallback to synchronous parsing in that case.
     if (!m_haveBackgroundParser) {
       m_shouldUseThreading = false;
       m_token = wrapUnique(new HTMLToken);
       m_tokenizer = HTMLTokenizer::create(m_options);
       DecodedDataDocumentParser::flush();
       return;
     }
 
     postTaskToLookaheadParser(Asynchronous, &BackgroundHTMLParser::flush,
                               m_backgroundParser);
@@ skipping 113 matching lines @@
     case Asynchronous:
       m_loadingTaskRunner->postTask(
           BLINK_FROM_HERE,
           WTF::bind(function, std::forward<Ps>(parameters)...));
       return;
   }
   NOTREACHED();
 }
 
 }  // namespace blink