Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT 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 51 matching lines @@
 // https://bugs.webkit.org/show_bug.cgi?id=110408.
 static const size_t defaultPendingTokenLimit = 1000;
 
 using namespace HTMLNames;
 
 #if DCHECK_IS_ON()
 
 static void checkThatTokensAreSafeToSendToAnotherThread(
     const CompactHTMLTokenStream* tokens) {
   for (size_t i = 0; i < tokens->size(); ++i)
-    ASSERT(tokens->at(i).isSafeToSendToAnotherThread());
+    DCHECK(tokens->at(i).isSafeToSendToAnotherThread());
 }
 
 static void checkThatPreloadsAreSafeToSendToAnotherThread(
     const PreloadRequestStream& preloads) {
   for (size_t i = 0; i < preloads.size(); ++i)
-    ASSERT(preloads[i]->isSafeToSendToAnotherThread());
+    DCHECK(preloads[i]->isSafeToSendToAnotherThread());
 }
 
 static void checkThatXSSInfosAreSafeToSendToAnotherThread(
     const XSSInfoStream& infos) {
   for (size_t i = 0; i < infos.size(); ++i)
-    ASSERT(infos[i]->isSafeToSendToAnotherThread());
+    DCHECK(infos[i]->isSafeToSendToAnotherThread());
 }
 
 #endif
 
 WeakPtr<BackgroundHTMLParser> BackgroundHTMLParser::create(
     std::unique_ptr<Configuration> config,
     RefPtr<WebTaskRunner> loadingTaskRunner) {
   auto* backgroundParser =
       new BackgroundHTMLParser(std::move(config), std::move(loadingTaskRunner));
   return backgroundParser->m_weakFactory.createWeakPtr();
@@ skipping 26 matching lines @@
       m_pendingTokenLimit(config->pendingTokenLimit),
       m_xssAuditor(std::move(config->xssAuditor)),
       m_decoder(std::move(config->decoder)),
       m_loadingTaskRunner(std::move(loadingTaskRunner)),
       m_tokenizedChunkQueue(std::move(config->tokenizedChunkQueue)),
       m_pendingCSPMetaTokenIndex(
           HTMLDocumentParser::TokenizedChunk::noPendingToken),
       m_startingScript(false),
       m_lastBytesReceivedTime(0.0),
       m_shouldCoalesceChunks(config->shouldCoalesceChunks) {
-  ASSERT(m_outstandingTokenLimit > 0);
-  ASSERT(m_pendingTokenLimit > 0);
-  ASSERT(m_outstandingTokenLimit >= m_pendingTokenLimit);
+  DCHECK_GT(m_outstandingTokenLimit, 0u);
+  DCHECK_GT(m_pendingTokenLimit, 0u);
+  DCHECK_GE(m_outstandingTokenLimit, m_pendingTokenLimit);
 }
 
 BackgroundHTMLParser::~BackgroundHTMLParser() {}
 
 void BackgroundHTMLParser::appendRawBytesFromMainThread(
     std::unique_ptr<Vector<char>> buffer,
     double bytesReceivedTime) {
-  ASSERT(m_decoder);
+  DCHECK(m_decoder);
   m_lastBytesReceivedTime = bytesReceivedTime;
   DEFINE_STATIC_LOCAL(CustomCountHistogram, queueDelay,
                       ("Parser.AppendBytesDelay", 1, 5000, 50));
   queueDelay.count(monotonicallyIncreasingTimeMS() - bytesReceivedTime);
   updateDocument(m_decoder->decode(buffer->data(), buffer->size()));
 }
 
 void BackgroundHTMLParser::appendDecodedBytes(const String& input) {
-  ASSERT(!m_input.current().isClosed());
+  DCHECK(!m_input.current().isClosed());
   m_input.append(input);
   pumpTokenizer();
 }
 
 void BackgroundHTMLParser::setDecoder(
     std::unique_ptr<TextResourceDecoder> decoder) {
-  ASSERT(decoder);
+  DCHECK(decoder);
   m_decoder = std::move(decoder);
 }
 
 void BackgroundHTMLParser::flush() {
-  ASSERT(m_decoder);
+  DCHECK(m_decoder);
   updateDocument(m_decoder->flush());
 }
 
 void BackgroundHTMLParser::updateDocument(const String& decodedData) {
   DocumentEncodingData encodingData(*m_decoder.get());
 
   if (encodingData != m_lastSeenEncodingData) {
     m_lastSeenEncodingData = encodingData;
 
     m_xssAuditor->setEncoding(encodingData.encoding());
@@ skipping 40 matching lines @@
 
 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.
   m_tokenizer->setState(HTMLTokenizer::PLAINTEXTState);
 }
 
 void BackgroundHTMLParser::markEndOfFile() {
-  ASSERT(!m_input.current().isClosed());
+  DCHECK(!m_input.current().isClosed());
   m_input.append(String(&kEndOfFileMarker, 1));
   m_input.close();
 }
 
 void BackgroundHTMLParser::pumpTokenizer() {
   TRACE_EVENT0("loading", "BackgroundHTMLParser::pumpTokenizer");
   HTMLTreeBuilderSimulator::SimulatedToken simulatedToken =
       HTMLTreeBuilderSimulator::OtherToken;
 
   // No need to start speculating until the main thread has almost caught up.
@@ skipping 145 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