Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in core/html/parser/

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

 /*
  * Copyright (C) 2008 Apple Inc. All Rights Reserved.
  * Copyright (C) 2009 Torch Mobile, Inc. http://www.torchmobile.com/
  * 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.
@@ skipping 68 matching lines @@
 
 }  // namespace
 
 using namespace HTMLNames;
 
 static bool match(const StringImpl* impl, const QualifiedName& qName) {
   return impl == qName.localName().impl();
 }
 
 static bool match(const AtomicString& name, const QualifiedName& qName) {
-  ASSERT(isMainThread());
+  DCHECK(isMainThread());
   return qName.localName() == name;
 }
 
 static bool match(const String& name, const QualifiedName& qName) {
   return threadSafeMatch(name, qName);
 }
 
 static const StringImpl* tagImplFor(const HTMLToken::DataVector& data) {
   AtomicString tagName(data);
   const StringImpl* result = tagName.impl();
   if (result->isStatic())
     return result;
   return nullptr;
 }
 
 static const StringImpl* tagImplFor(const String& tagName) {
   const StringImpl* result = tagName.impl();
   if (result->isStatic())
     return result;
   return nullptr;
 }
 
 static String initiatorFor(const StringImpl* tagImpl) {
-  ASSERT(tagImpl);
+  DCHECK(tagImpl);
   if (match(tagImpl, imgTag))
     return imgTag.localName();
   if (match(tagImpl, inputTag))
     return inputTag.localName();
   if (match(tagImpl, linkTag))
     return linkTag.localName();
   if (match(tagImpl, scriptTag))
     return scriptTag.localName();
   if (match(tagImpl, videoTag))
     return videoTag.localName();
@@ skipping 32 matching lines @@
       return;
     }
     if (!match(m_tagImpl, inputTag) && !match(m_tagImpl, linkTag) &&
         !match(m_tagImpl, scriptTag) && !match(m_tagImpl, videoTag))
       m_tagImpl = 0;
   }
 
   enum URLReplacement { AllowURLReplacement, DisallowURLReplacement };
 
   void processAttributes(const HTMLToken::AttributeList& attributes) {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
     if (!m_tagImpl)
       return;
     for (const HTMLToken::Attribute& htmlTokenAttribute : attributes) {
       AtomicString attributeName(htmlTokenAttribute.name());
       String attributeValue = htmlTokenAttribute.value8BitIfNecessary();
       processAttribute(attributeName, attributeValue);
     }
   }
 
   void processAttributes(
@@ skipping 407 matching lines @@
 TokenPreloadScannerCheckpoint TokenPreloadScanner::createCheckpoint() {
   TokenPreloadScannerCheckpoint checkpoint = m_checkpoints.size();
   m_checkpoints.push_back(Checkpoint(m_predictedBaseElementURL, m_inStyle,
                                      m_inScript, m_templateCount));
   return checkpoint;
 }
 
 void TokenPreloadScanner::rewindTo(
     TokenPreloadScannerCheckpoint checkpointIndex) {
   // If this ASSERT fires, checkpointIndex is invalid.
-  ASSERT(checkpointIndex < m_checkpoints.size());
+  DCHECK_LT(checkpointIndex, m_checkpoints.size());
   const Checkpoint& checkpoint = m_checkpoints[checkpointIndex];
   m_predictedBaseElementURL = checkpoint.predictedBaseElementURL;
   m_inStyle = checkpoint.inStyle;
   m_templateCount = checkpoint.templateCount;
 
   m_didRewind = true;
   m_inScript = checkpoint.inScript;
 
   m_cssScanner.reset();
   m_checkpoints.clear();
@@ skipping 245 matching lines @@
       if (request)
         requests.push_back(std::move(request));
       return;
     }
     default: { return; }
   }
 }
 
 template <typename Token>
 void TokenPreloadScanner::updatePredictedBaseURL(const Token& token) {
-  ASSERT(m_predictedBaseElementURL.isEmpty());
+  DCHECK(m_predictedBaseElementURL.isEmpty());
   if (const typename Token::Attribute* hrefAttribute =
           token.getAttributeItem(hrefAttr)) {
     KURL url(m_documentURL, stripLeadingAndTrailingHTMLSpaces(
                                 hrefAttribute->value8BitIfNecessary()));
     m_predictedBaseElementURL =
         url.isValid() && !url.protocolIsData() ? url.copy() : KURL();
   }
 }
 
 HTMLPreloadScanner::HTMLPreloadScanner(
     const HTMLParserOptions& options,
     const KURL& documentURL,
     std::unique_ptr<CachedDocumentParameters> documentParameters,
     const MediaValuesCached::MediaValuesCachedData& mediaValuesCachedData)
     : m_scanner(documentURL,
                 std::move(documentParameters),
                 mediaValuesCachedData),
       m_tokenizer(HTMLTokenizer::create(options)) {}
 
 HTMLPreloadScanner::~HTMLPreloadScanner() {}
 
 void HTMLPreloadScanner::appendToEnd(const SegmentedString& source) {
   m_source.append(source);
 }
 
 PreloadRequestStream HTMLPreloadScanner::scan(
     const KURL& startingBaseElementURL,
     ViewportDescriptionWrapper* viewport) {
   // HTMLTokenizer::updateStateFor only works on the main thread.
-  ASSERT(isMainThread());
+  DCHECK(isMainThread());
 
   TRACE_EVENT1("blink", "HTMLPreloadScanner::scan", "source_length",
                m_source.length());
 
   // When we start scanning, our best prediction of the baseElementURL is the
   // real one!
   if (!startingBaseElementURL.isEmpty())
     m_scanner.setPredictedBaseElementURL(startingBaseElementURL);
 
   PreloadRequestStream requests;
 
   while (m_tokenizer->nextToken(m_source, m_token)) {
     if (m_token.type() == HTMLToken::StartTag)
       m_tokenizer->updateStateFor(
           attemptStaticStringCreation(m_token.name(), Likely8Bit));
     bool isCSPMetaTag = false;
     m_scanner.scan(m_token, m_source, requests, viewport, &isCSPMetaTag);
     m_token.clear();
     // Don't preload anything if a CSP meta tag is found. We should never really
     // find them here because the HTMLPreloadScanner is only used for
     // dynamically added markup.
     if (isCSPMetaTag)
       return requests;
   }
 
   return requests;
 }
 
 CachedDocumentParameters::CachedDocumentParameters(Document* document) {
-  ASSERT(isMainThread());
-  ASSERT(document);
+  DCHECK(isMainThread());
+  DCHECK(document);
   doHtmlPreloadScanning =
       !document->settings() || document->settings()->getDoHtmlPreloadScanning();
   doDocumentWritePreloadScanning = doHtmlPreloadScanning && document->frame() &&
                                    document->frame()->isMainFrame();
   defaultViewportMinWidth = document->viewportDefaultMinWidth();
   viewportMetaZeroValuesQuirk =
       document->settings() &&
       document->settings()->getViewportMetaZeroValuesQuirk();
   viewportMetaEnabled =
       document->settings() && document->settings()->getViewportMetaEnabled();
   referrerPolicy = document->getReferrerPolicy();
 }
 
 }  // namespace blink