Reformat comments in core/html/parser

third_party/WebKit/Source/core/html/parser/BackgroundHTMLParser.cpp

 /*
  * Copyright (C) 2013 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 24 matching lines @@
 #include "public/platform/Platform.h"
 #include "public/platform/WebTaskRunner.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/Functional.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/TextPosition.h"
 #include <memory>
 
 namespace blink {
 
-// On a network with high latency and high bandwidth, using a device
-// with a fast CPU, we could end up speculatively tokenizing
-// the whole document, well ahead of when the main-thread actually needs it.
-// This is a waste of memory (and potentially time if the speculation fails).
-// So we limit our outstanding tokens arbitrarily to 10,000.
-// Our maximal memory spent speculating will be approximately:
+// On a network with high latency and high bandwidth, using a device with a fast
+// CPU, we could end up speculatively tokenizing the whole document, well ahead
+// of when the main-thread actually needs it. This is a waste of memory (and
+// potentially time if the speculation fails). So we limit our outstanding
+// tokens arbitrarily to 10,000. Our maximal memory spent speculating will be
+// approximately:
 // (defaultOutstandingTokenLimit + defaultPendingTokenLimit) *
-//     sizeof(CompactToken)
-// We use a separate low and high water mark to avoid constantly topping
-// off the main thread's token buffer.
-// At time of writing, this is (10000 + 1000) * 28 bytes = ~308kb of memory.
-// These numbers have not been tuned.
+// sizeof(CompactToken)
+//
+// We use a separate low and high water mark to avoid
+// constantly topping off the main thread's token buffer. At time of writing,
+// this is (10000 + 1000) * 28 bytes = ~308kb of memory. These numbers have not
+// been tuned.
 static const size_t defaultOutstandingTokenLimit = 10000;
 
-// We limit our chucks to 1000 tokens, to make sure the main
-// thread is never waiting on the parser thread for tokens.
-// This was tuned in https://bugs.webkit.org/show_bug.cgi?id=110408.
+// We limit our chucks to 1000 tokens, to make sure the main thread is never
+// waiting on the parser thread for tokens. This was tuned in
+// https://bugs.webkit.org/show_bug.cgi?id=110408.
 static const size_t defaultPendingTokenLimit = 1000;
 
 using namespace HTMLNames;
 
 #if ENABLE(ASSERT)
 
 static void checkThatTokensAreSafeToSendToAnotherThread(
     const CompactHTMLTokenStream* tokens) {
   for (size_t i = 0; i < tokens->size(); ++i)
     ASSERT(tokens->at(i).isSafeToSendToAnotherThread());
@@ skipping 116 matching lines @@
   m_input.rewindTo(checkpoint->inputCheckpoint, checkpoint->unparsedInput);
   m_preloadScanner->rewindTo(checkpoint->preloadScannerCheckpoint);
   m_startingScript = false;
   m_tokenizedChunkQueue->clear();
   m_lastBytesReceivedTime = monotonicallyIncreasingTimeMS();
   pumpTokenizer();
 }
 
 void BackgroundHTMLParser::startedChunkWithCheckpoint(
     HTMLInputCheckpoint inputCheckpoint) {
-  // Note, we should not have to worry about the index being invalid
-  // as messages from the main thread will be processed in FIFO order.
+  // Note, we should not have to worry about the index being invalid as messages
+  // from the main thread will be processed in FIFO order.
   m_input.invalidateCheckpointsBefore(inputCheckpoint);
   pumpTokenizer();
 }
 
 void BackgroundHTMLParser::finish() {
   markEndOfFile();
   pumpTokenizer();
 }
 
 void BackgroundHTMLParser::stop() {
   delete this;
 }
 
 void BackgroundHTMLParser::forcePlaintextForTextDocument() {
-  // This is only used by the TextDocumentParser (a subclass of HTMLDocumentParser)
-  // to force us into the PLAINTEXT state w/o using a <plaintext> tag.
-  // The TextDocumentParser uses a <pre> tag for historical/compatibility reasons.
+  // This is only used by the TextDocumentParser (a subclass of
+  // HTMLDocumentParser) to force us into the PLAINTEXT state w/o using a
+  // <plaintext> tag. The TextDocumentParser uses a <pre> tag for historical /
+  // compatibility reasons.
   m_tokenizer->setState(HTMLTokenizer::PLAINTEXTState);
 }
 
 void BackgroundHTMLParser::markEndOfFile() {
   ASSERT(!m_input.current().isClosed());
   m_input.append(String(&kEndOfFileMarker, 1));
   m_input.close();
 }
 
 void BackgroundHTMLParser::pumpTokenizer() {
@@ skipping 34 matching lines @@
 
       bool shouldEvaluateForDocumentWrite = false;
       bool isCSPMetaTag = false;
       m_preloadScanner->scan(token, m_input.current(), m_pendingPreloads,
                              &m_viewportDescription, &isCSPMetaTag,
                              &shouldEvaluateForDocumentWrite);
 
       simulatedToken =
           m_treeBuilderSimulator.simulate(token, m_tokenizer.get());
 
-      // Break chunks before a script tag is inserted and flag the chunk as starting a script
-      // so the main parser can decide if it should yield before processing the chunk.
+      // Break chunks before a script tag is inserted and flag the chunk as
+      // starting a script so the main parser can decide if it should yield
+      // before processing the chunk.
       if (simulatedToken == HTMLTreeBuilderSimulator::ScriptStart) {
         shouldNotifyMainThread |= queueChunkForMainThread();
         m_startingScript = true;
       }
 
       m_pendingTokens->append(token);
       if (isCSPMetaTag) {
         m_pendingCSPMetaTokenIndex = m_pendingTokens->size() - 1;
       }
       if (shouldEvaluateForDocumentWrite) {
         m_likelyDocumentWriteScriptIndices.append(m_pendingTokens->size() - 1);
       }
     }
 
     m_token->clear();
 
     if (simulatedToken == HTMLTreeBuilderSimulator::ScriptEnd ||
         m_pendingTokens->size() >= m_pendingTokenLimit) {
       shouldNotifyMainThread |= queueChunkForMainThread();
-      // If we're far ahead of the main thread, yield for a bit to avoid consuming too much memory.
+      // If we're far ahead of the main thread, yield for a bit to avoid
+      // consuming too much memory.
       if (m_input.totalCheckpointTokenCount() > m_outstandingTokenLimit)
         break;
     }
 
     if (!m_shouldCoalesceChunks && shouldNotifyMainThread) {
       runOnMainThread(&HTMLDocumentParser::notifyPendingTokenizedChunks,
                       m_parser);
       shouldNotifyMainThread = false;
     }
   }
-  // Wait to notify the main thread about the chunks until we're at the
-  // limit. This lets the background parser generate lots of valuable
-  // preloads before anything expensive (extensions, scripts) take up time
-  // on the main thread. A busy main thread can cause preload delays.
+  // Wait to notify the main thread about the chunks until we're at the limit.
+  // This lets the background parser generate lots of valuable preloads before
+  // anything expensive (extensions, scripts) take up time on the main thread. A
+  // busy main thread can cause preload delays.
   if (shouldNotifyMainThread) {
     runOnMainThread(&HTMLDocumentParser::notifyPendingTokenizedChunks,
                     m_parser);
   }
 }
 
 bool BackgroundHTMLParser::queueChunkForMainThread() {
   if (m_pendingTokens->isEmpty())
     return false;
 
@@ skipping 55 matching lines @@
   if (isMainThread()) {
     (*WTF::bind(function, std::forward<Ps>(parameters)...))();
   } else {
     m_loadingTaskRunner->postTask(
         BLINK_FROM_HERE,
         crossThreadBind(function, std::forward<Ps>(parameters)...));
   }
 }
 
 }  // namespace blink