Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in core/css/

third_party/WebKit/Source/core/css/StyleSheetContents.cpp

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2006, 2007, 2012 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 83 matching lines @@
       m_hasSyntacticallyValidCSSHeader(o.m_hasSyntacticallyValidCSSHeader),
       m_didLoadErrorOccur(false),
       m_isMutable(false),
       m_hasFontFaceRule(o.m_hasFontFaceRule),
       m_hasViewportRule(o.m_hasViewportRule),
       m_hasMediaQueries(o.m_hasMediaQueries),
       m_hasSingleOwnerDocument(true),
       m_isUsedFromTextCache(false),
       m_parserContext(o.m_parserContext) {
   // FIXME: Copy import rules.
-  ASSERT(o.m_importRules.isEmpty());
+  DCHECK(o.m_importRules.isEmpty());
 
   for (unsigned i = 0; i < m_namespaceRules.size(); ++i) {
     m_namespaceRules[i] =
         static_cast<StyleRuleNamespace*>(o.m_namespaceRules[i]->copy());
   }
 
   // LazyParseCSS: Copying child rules is a strict point for lazy parsing, so
   // there is no need to copy lazy parsing state here.
   for (unsigned i = 0; i < m_childRules.size(); ++i)
     m_childRules[i] = o.m_childRules[i]->copy();
@@ skipping 46 matching lines @@
   if (isMutable())
     return false;
   if (!hasSyntacticallyValidCSSHeader())
     return false;
   return true;
 }
 
 void StyleSheetContents::parserAppendRule(StyleRuleBase* rule) {
   if (rule->isImportRule()) {
     // Parser enforces that @import rules come before anything else
-    ASSERT(m_childRules.isEmpty());
+    DCHECK(m_childRules.isEmpty());
     StyleRuleImport* importRule = toStyleRuleImport(rule);
     if (importRule->mediaQueries())
       setHasMediaQueries();
     m_importRules.push_back(importRule);
     m_importRules.back()->setParentStyleSheet(this);
     m_importRules.back()->requestStyleSheet();
     return;
   }
 
   if (rule->isNamespaceRule()) {
     // Parser enforces that @namespace rules come before all rules other than
     // import/charset rules
-    ASSERT(m_childRules.isEmpty());
+    DCHECK(m_childRules.isEmpty());
     StyleRuleNamespace& namespaceRule = toStyleRuleNamespace(*rule);
     parserAddNamespace(namespaceRule.prefix(), namespaceRule.uri());
     m_namespaceRules.push_back(&namespaceRule);
     return;
   }
 
   m_childRules.push_back(rule);
 }
 
 void StyleSheetContents::setHasMediaQueries() {
@@ skipping 17 matching lines @@
 
   return m_childRules[index].get();
 }
 
 unsigned StyleSheetContents::ruleCount() const {
   return m_importRules.size() + m_namespaceRules.size() + m_childRules.size();
 }
 
 void StyleSheetContents::clearRules() {
   for (unsigned i = 0; i < m_importRules.size(); ++i) {
-    ASSERT(m_importRules.at(i)->parentStyleSheet() == this);
+    DCHECK_EQ(m_importRules.at(i)->parentStyleSheet(), this);
     m_importRules[i]->clearParentStyleSheet();
   }
   m_importRules.clear();
   m_namespaceRules.clear();
   m_childRules.clear();
 }
 
 bool StyleSheetContents::wrapperInsertRule(StyleRuleBase* rule,
                                            unsigned index) {
-  ASSERT(m_isMutable);
+  DCHECK(m_isMutable);
   SECURITY_DCHECK(index <= ruleCount());
 
   if (index < m_importRules.size() ||
       (index == m_importRules.size() && rule->isImportRule())) {
     // Inserting non-import rule before @import is not allowed.
     if (!rule->isImportRule())
       return false;
 
     StyleRuleImport* importRule = toStyleRuleImport(rule);
     if (importRule->mediaQueries())
@@ skipping 39 matching lines @@
   if (rule->isNamespaceRule())
     return false;
 
   index -= m_namespaceRules.size();
 
   m_childRules.insert(index, rule);
   return true;
 }
 
 bool StyleSheetContents::wrapperDeleteRule(unsigned index) {
-  ASSERT(m_isMutable);
+  DCHECK(m_isMutable);
   SECURITY_DCHECK(index < ruleCount());
 
   if (index < m_importRules.size()) {
     m_importRules[index]->clearParentStyleSheet();
     if (m_importRules[index]->isFontFaceRule())
       notifyRemoveFontFaceRule(toStyleRuleFontFace(m_importRules[index].get()));
     m_importRules.erase(index);
     return true;
   }
   index -= m_importRules.size();
 
   if (index < m_namespaceRules.size()) {
     if (!m_childRules.isEmpty())
       return false;
     m_namespaceRules.erase(index);
     return true;
   }
   index -= m_namespaceRules.size();
 
   if (m_childRules[index]->isFontFaceRule())
     notifyRemoveFontFaceRule(toStyleRuleFontFace(m_childRules[index].get()));
   m_childRules.erase(index);
   return true;
 }
 
 void StyleSheetContents::parserAddNamespace(const AtomicString& prefix,
                                             const AtomicString& uri) {
-  ASSERT(!uri.isNull());
+  DCHECK(!uri.isNull());
   if (prefix.isNull()) {
     m_defaultNamespace = uri;
     return;
   }
   PrefixNamespaceURIMap::AddResult result = m_namespaces.insert(prefix, uri);
   if (result.isNewEntry)
     return;
   result.storedValue->value = uri;
 }
 
@@ skipping 85 matching lines @@
 void StyleSheetContents::checkLoaded() {
   if (isLoading())
     return;
 
   StyleSheetContents* parentSheet = parentStyleSheet();
   if (parentSheet) {
     parentSheet->checkLoaded();
     return;
   }
 
-  ASSERT(this == rootStyleSheet());
+  DCHECK_EQ(this, rootStyleSheet());
   if (m_loadingClients.isEmpty())
     return;
 
   // Avoid |CSSSStyleSheet| and |ownerNode| being deleted by scripts that run
   // via ScriptableDocumentParser::executeScriptsWaitingForResources(). Also
   // protect the |CSSStyleSheet| from being deleted during iteration via the
   // |sheetLoaded| method.
   //
   // When a sheet is loaded it is moved from the set of loading clients
   // to the set of completed clients. We therefore need the copy in order to
@@ skipping 10 matching lines @@
     if (Node* ownerNode = loadingClients[i]->ownerNode()) {
       if (loadingClients[i]->sheetLoaded())
         ownerNode->notifyLoadedSheetAndAllCriticalSubresources(
             m_didLoadErrorOccur ? Node::ErrorOccurredLoadingSubresource
                                 : Node::NoErrorLoadingSubresource);
     }
   }
 }
 
 void StyleSheetContents::notifyLoadedSheet(const CSSStyleSheetResource* sheet) {
-  ASSERT(sheet);
+  DCHECK(sheet);
   m_didLoadErrorOccur |= sheet->errorOccurred();
   // updateLayoutIgnorePendingStyleSheets can cause us to create the RuleSet on
   // this sheet before its imports have loaded. So clear the RuleSet when the
   // imports load since the import's subrules are flattened into its parent
   // sheet's RuleSet.
   clearRuleSet();
 }
 
 void StyleSheetContents::startLoadingDynamicSheet() {
   StyleSheetContents* root = rootStyleSheet();
@@ skipping 55 matching lines @@
           return true;
         break;
       case StyleRuleBase::Media:
         if (childRulesHaveFailedOrCanceledSubresources(
                 toStyleRuleMedia(rule)->childRules()))
           return true;
         break;
       case StyleRuleBase::Charset:
       case StyleRuleBase::Import:
       case StyleRuleBase::Namespace:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
       case StyleRuleBase::Page:
       case StyleRuleBase::Keyframes:
       case StyleRuleBase::Keyframe:
       case StyleRuleBase::Supports:
       case StyleRuleBase::Viewport:
         break;
     }
   }
   return false;
 }
 
 bool StyleSheetContents::hasFailedOrCanceledSubresources() const {
-  ASSERT(isCacheableForResource());
+  DCHECK(isCacheableForResource());
   return childRulesHaveFailedOrCanceledSubresources(m_childRules);
 }
 
 Document* StyleSheetContents::clientAnyOwnerDocument() const {
   if (clientSize() <= 0)
     return nullptr;
   if (m_loadingClients.size())
     return (*m_loadingClients.begin())->ownerDocument();
   return (*m_completedClients.begin())->ownerDocument();
 }
 
 Document* StyleSheetContents::clientSingleOwnerDocument() const {
   return m_hasSingleOwnerDocument ? clientAnyOwnerDocument() : nullptr;
 }
 
 StyleSheetContents* StyleSheetContents::parentStyleSheet() const {
   return m_ownerRule ? m_ownerRule->parentStyleSheet() : nullptr;
 }
 
 void StyleSheetContents::registerClient(CSSStyleSheet* sheet) {
-  ASSERT(!m_loadingClients.contains(sheet) &&
-         !m_completedClients.contains(sheet));
+  DCHECK(!m_loadingClients.contains(sheet));
+  DCHECK(!m_completedClients.contains(sheet));
 
   // InspectorCSSAgent::buildObjectForRule creates CSSStyleSheet without any
   // owner node.
   if (!sheet->ownerDocument())
     return;
 
   if (Document* document = clientSingleOwnerDocument()) {
     if (sheet->ownerDocument() != document)
       m_hasSingleOwnerDocument = false;
   }
   m_loadingClients.insert(sheet);
 }
 
 void StyleSheetContents::unregisterClient(CSSStyleSheet* sheet) {
   m_loadingClients.erase(sheet);
   m_completedClients.erase(sheet);
 
   if (!sheet->ownerDocument() || !m_loadingClients.isEmpty() ||
       !m_completedClients.isEmpty())
     return;
 
   m_hasSingleOwnerDocument = true;
 }
 
 void StyleSheetContents::clientLoadCompleted(CSSStyleSheet* sheet) {
-  ASSERT(m_loadingClients.contains(sheet) || !sheet->ownerDocument());
+  DCHECK(m_loadingClients.contains(sheet) || !sheet->ownerDocument());
   m_loadingClients.erase(sheet);
   // In m_ownerNode->sheetLoaded, the CSSStyleSheet might be detached.
   // (i.e. clearOwnerNode was invoked.)
   // In this case, we don't need to add the stylesheet to completed clients.
   if (!sheet->ownerDocument())
     return;
   m_completedClients.insert(sheet);
 }
 
 void StyleSheetContents::clientLoadStarted(CSSStyleSheet* sheet) {
-  ASSERT(m_completedClients.contains(sheet));
+  DCHECK(m_completedClients.contains(sheet));
   m_completedClients.erase(sheet);
   m_loadingClients.insert(sheet);
 }
 
 void StyleSheetContents::setReferencedFromResource(
     CSSStyleSheetResource* resource) {
   DCHECK(resource);
   DCHECK(!isReferencedFromResource());
   DCHECK(isCacheableForResource());
   m_referencedFromResource = resource;
@@ skipping 87 matching lines @@
   visitor->trace(m_namespaceRules);
   visitor->trace(m_childRules);
   visitor->trace(m_loadingClients);
   visitor->trace(m_completedClients);
   visitor->trace(m_ruleSet);
   visitor->trace(m_referencedFromResource);
   visitor->trace(m_parserContext);
 }
 
 }  // namespace blink