ASSERT -> DCHECK in core/editing.

third_party/WebKit/Source/core/editing/EditingStyle.cpp

 /*
  * Copyright (C) 2007, 2008, 2009 Apple Computer, Inc.
  * Copyright (C) 2010, 2011 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
@@ skipping 186 matching lines @@
     : m_propertyID(id)
     , m_tagName(&tagName)
 {
 }
 
 HTMLElementEquivalent::HTMLElementEquivalent(CSSPropertyID id, CSSValueID primitiveValue, const HTMLQualifiedName& tagName)
     : m_propertyID(id)
     , m_primitiveValue(CSSPrimitiveValue::createIdentifier(primitiveValue))
     , m_tagName(&tagName)
 {
-    ASSERT(primitiveValue != CSSValueInvalid);
+    DCHECK_NE(primitiveValue, CSSValueInvalid);
 }
 
 bool HTMLElementEquivalent::valueIsPresentInStyle(HTMLElement* element, StylePropertySet* style) const
 {
     CSSValue* value = style->getPropertyCSSValue(m_propertyID);
     return matches(element) && value && value->isPrimitiveValue() && toCSSPrimitiveValue(value)->getValueID() == m_primitiveValue->getValueID();
 }
 
 void HTMLElementEquivalent::addToStyle(Element*, EditingStyle* style) const
 {
@@ skipping 82 matching lines @@
 }
 
 void HTMLAttributeEquivalent::addToStyle(Element* element, EditingStyle* style) const
 {
     if (CSSValue* value = attributeValueAsCSSValue(element))
         style->setProperty(m_propertyID, value->cssText());
 }
 
 CSSValue* HTMLAttributeEquivalent::attributeValueAsCSSValue(Element* element) const
 {
-    ASSERT(element);
+    DCHECK(element);
     const AtomicString& value = element->getAttribute(m_attrName);
     if (value.isNull())
         return nullptr;
 
     MutableStylePropertySet* dummyStyle = nullptr;
     dummyStyle = MutableStylePropertySet::create(HTMLQuirksMode);
     dummyStyle->setProperty(m_propertyID, value);
     return dummyStyle->getPropertyCSSValue(m_propertyID);
 }
 
@@ skipping 11 matching lines @@
     HTMLFontSizeEquivalent();
 };
 
 HTMLFontSizeEquivalent::HTMLFontSizeEquivalent()
     : HTMLAttributeEquivalent(CSSPropertyFontSize, HTMLNames::fontTag, HTMLNames::sizeAttr)
 {
 }
 
 CSSValue* HTMLFontSizeEquivalent::attributeValueAsCSSValue(Element* element) const
 {
-    ASSERT(element);
+    DCHECK(element);
     const AtomicString& value = element->getAttribute(m_attrName);
     if (value.isNull())
         return nullptr;
     CSSValueID size;
     if (!HTMLFontElement::cssValueFromFontSizeNumber(value, size))
         return nullptr;
     return CSSPrimitiveValue::createIdentifier(size);
 }
 
 float EditingStyle::NoFontDelta = 0.0f;
@@ skipping 146 matching lines @@
 void EditingStyle::setProperty(CSSPropertyID propertyID, const String& value, bool important)
 {
     if (!m_mutableStyle)
         m_mutableStyle = MutableStylePropertySet::create(HTMLQuirksMode);
 
     m_mutableStyle->setProperty(propertyID, value, important);
 }
 
 void EditingStyle::replaceFontSizeByKeywordIfPossible(const ComputedStyle* computedStyle, CSSComputedStyleDeclaration* cssComputedStyle)
 {
-    ASSERT(computedStyle);
+    DCHECK(computedStyle);
     if (computedStyle->getFontDescription().keywordSize())
         m_mutableStyle->setProperty(CSSPropertyFontSize, cssComputedStyle->getFontSizeCSSValuePreferringKeyword()->cssText());
 }
 
 void EditingStyle::extractFontSizeDelta()
 {
     if (!m_mutableStyle)
         return;
 
     if (m_mutableStyle->getPropertyCSSValue(CSSPropertyFontSize)) {
@@ skipping 246 matching lines @@
         }
         if (&node == selection.end().anchorNode())
             break;
     }
 
     return state;
 }
 
 bool EditingStyle::conflictsWithInlineStyleOfElement(HTMLElement* element, EditingStyle* extractedStyle, Vector<CSSPropertyID>* conflictingProperties) const
 {
-    ASSERT(element);
-    ASSERT(!conflictingProperties || conflictingProperties->isEmpty());
+    DCHECK(element);
+    DCHECK(!conflictingProperties || conflictingProperties->isEmpty());
 
     const StylePropertySet* inlineStyle = element->inlineStyle();
     if (!m_mutableStyle || !inlineStyle)
         return false;
 
     unsigned propertyCount = m_mutableStyle->propertyCount();
     for (unsigned i = 0; i < propertyCount; ++i) {
         CSSPropertyID propertyID = m_mutableStyle->propertyAt(i).id();
 
         // We don't override whitespace property of a tab span because that would collapse the tab into a space.
@@ skipping 86 matching lines @@
 
         HTMLAttributeEquivalents.append(HTMLAttributeEquivalent::create(CSSPropertyDirection, HTMLNames::dirAttr));
         HTMLAttributeEquivalents.append(HTMLAttributeEquivalent::create(CSSPropertyUnicodeBidi, HTMLNames::dirAttr));
     }
 
     return HTMLAttributeEquivalents;
 }
 
 bool EditingStyle::conflictsWithImplicitStyleOfAttributes(HTMLElement* element) const
 {
-    ASSERT(element);
+    DCHECK(element);
     if (!m_mutableStyle)
         return false;
 
     const HeapVector<Member<HTMLAttributeEquivalent>>& HTMLAttributeEquivalents = htmlAttributeEquivalents();
     for (const auto& equivalent : HTMLAttributeEquivalents) {
         if (equivalent->matches(element) && equivalent->propertyExistsInStyle(m_mutableStyle.get())
             && !equivalent->valueIsPresentInStyle(element, m_mutableStyle.get()))
             return true;
     }
 
     return false;
 }
 
 bool EditingStyle::extractConflictingImplicitStyleOfAttributes(HTMLElement* element, ShouldPreserveWritingDirection shouldPreserveWritingDirection,
     EditingStyle* extractedStyle, Vector<QualifiedName>& conflictingAttributes, ShouldExtractMatchingStyle shouldExtractMatchingStyle) const
 {
-    ASSERT(element);
+    DCHECK(element);
     // HTMLAttributeEquivalent::addToStyle doesn't support unicode-bidi and direction properties
-    ASSERT(!extractedStyle || shouldPreserveWritingDirection == PreserveWritingDirection);
+    DCHECK(!extractedStyle || shouldPreserveWritingDirection == PreserveWritingDirection);

[yosin_UTC9, 2016/04/14 04:35:00]

How about rewriting to:

if (extractStyle)
   DCHECK_EQ(shouldPreserveWritingDirection, PreserveWritingDirection);

     if (!m_mutableStyle)
         return false;
 
     const HeapVector<Member<HTMLAttributeEquivalent>>& HTMLAttributeEquivalents = htmlAttributeEquivalents();
     bool removed = false;
     for (const auto& attribute : HTMLAttributeEquivalents) {
         const HTMLAttributeEquivalent* equivalent = attribute.get();
 
         // unicode-bidi and direction are pushed down separately so don't push down with other styles.
         if (shouldPreserveWritingDirection == PreserveWritingDirection && equivalent->attributeName() == HTMLNames::dirAttr)
@@ skipping 12 matching lines @@
     return removed;
 }
 
 bool EditingStyle::styleIsPresentInComputedStyleOfNode(Node* node) const
 {
     return !m_mutableStyle || getPropertiesNotIn(m_mutableStyle.get(), CSSComputedStyleDeclaration::create(node))->isEmpty();
 }
 
 bool EditingStyle::elementIsStyledSpanOrHTMLEquivalent(const HTMLElement* element)
 {
-    ASSERT(element);
+    DCHECK(element);
     bool elementIsSpanOrElementEquivalent = false;
     if (isHTMLSpanElement(*element)) {
         elementIsSpanOrElementEquivalent = true;
     } else {
         const HeapVector<Member<HTMLElementEquivalent>>& HTMLElementEquivalents = htmlElementEquivalents();
         size_t i;
         for (i = 0; i < HTMLElementEquivalents.size(); ++i) {
             if (HTMLElementEquivalents[i]->matches(element)) {
                 elementIsSpanOrElementEquivalent = true;
                 break;
@@ skipping 23 matching lines @@
             unsigned propertyCount = style->propertyCount();
             for (unsigned i = 0; i < propertyCount; ++i) {
                 if (!isEditingProperty(style->propertyAt(i).id()))
                     return false;
             }
         }
         matchedAttributes++;
     }
 
     // font with color attribute, span with style attribute, etc...
-    ASSERT(matchedAttributes <= attributes.size());
+    DCHECK_LE(matchedAttributes, attributes.size());
     return matchedAttributes >= attributes.size();
 }
 
 void EditingStyle::prepareToApplyAt(const Position& position, ShouldPreserveWritingDirection shouldPreserveWritingDirection)
 {
     if (!m_mutableStyle)
         return;
 
     // ReplaceSelectionCommand::handleStyleSpans() requires that this function only removes the editing style.
     // If this function was modified in the future to delete all redundant properties, then add a boolean value to indicate
@@ skipping 22 matching lines @@
 
     if (unicodeBidi && unicodeBidi->isPrimitiveValue()) {
         m_mutableStyle->setProperty(CSSPropertyUnicodeBidi, toCSSPrimitiveValue(unicodeBidi)->getValueID());
         if (direction && direction->isPrimitiveValue())
             m_mutableStyle->setProperty(CSSPropertyDirection, toCSSPrimitiveValue(direction)->getValueID());
     }
 }
 
 void EditingStyle::mergeTypingStyle(Document* document)
 {
-    ASSERT(document);
+    DCHECK(document);
 
     EditingStyle* typingStyle = document->frame()->selection().typingStyle();
     if (!typingStyle || typingStyle == this)
         return;
 
     mergeStyle(typingStyle->style(), OverrideValues);
 }
 
 void EditingStyle::mergeInlineStyleOfElement(HTMLElement* element, CSSPropertyOverrideMode mode, PropertiesToInclude propertiesToInclude)
 {
-    ASSERT(element);
+    DCHECK(element);
     if (!element->inlineStyle())
         return;
 
     switch (propertiesToInclude) {
     case AllProperties:
         mergeStyle(element->inlineStyle(), mode);
         return;
     case OnlyEditingInheritableProperties:
         mergeStyle(copyEditingProperties(element->inlineStyle(), OnlyInheritableEditingProperties), mode);
         return;
@@ skipping 178 matching lines @@
     unsigned propertyCount = style->propertyCount();
     Vector<CSSPropertyID> propertiesToRemove(propertyCount);
     for (unsigned i = 0; i < propertyCount; ++i)
         propertiesToRemove[i] = style->propertyAt(i).id();
 
     styleToRemovePropertiesFrom->removePropertiesInSet(propertiesToRemove.data(), propertiesToRemove.size());
 }
 
 void EditingStyle::removeStyleFromRulesAndContext(Element* element, ContainerNode* context)
 {
-    ASSERT(element);
+    DCHECK(element);
     if (!m_mutableStyle)
         return;
 
     // 1. Remove style from matched rules because style remain without repeating it in inline style declaration
     MutableStylePropertySet* styleFromMatchedRules = styleFromMatchedRulesForElement(element, StyleResolver::AllButEmptyCSSRules);
     if (styleFromMatchedRules && !styleFromMatchedRules->isEmpty())
         m_mutableStyle = getPropertiesNotIn(m_mutableStyle.get(), styleFromMatchedRules->ensureCSSStyleDeclaration());
 
     // 2. Remove style present in context and not overriden by matched rules.
     EditingStyle* computedStyle = EditingStyle::create(context, EditingPropertiesInEffect);
@@ skipping 118 matching lines @@
     Position position = mostForwardCaretPosition(selection.start());
 
     Node* node = position.anchorNode();
     if (!node)
         return NaturalWritingDirection;
 
     Position end;
     if (selection.isRange()) {
         end = mostBackwardCaretPosition(selection.end());
 
-        ASSERT(end.document());
+        DCHECK(end.document());
         Node* pastLast = Range::create(*end.document(), position.parentAnchoredEquivalent(), end.parentAnchoredEquivalent())->pastLastNode();
         for (Node* n = node; n && n != pastLast; n = NodeTraversal::next(*n)) {
             if (!n->isStyledElement())
                 continue;
 
             CSSComputedStyleDeclaration* style = CSSComputedStyleDeclaration::create(n);
             CSSValue* unicodeBidi = style->getPropertyCSSValue(CSSPropertyUnicodeBidi);
             if (!unicodeBidi || !unicodeBidi->isPrimitiveValue())
                 continue;
 
@@ skipping 27 matching lines @@
         if (!unicodeBidi || !unicodeBidi->isPrimitiveValue())
             continue;
 
         CSSValueID unicodeBidiValue = toCSSPrimitiveValue(unicodeBidi)->getValueID();
         if (unicodeBidiValue == CSSValueNormal)
             continue;
 
         if (unicodeBidiValue == CSSValueBidiOverride)
             return NaturalWritingDirection;
 
-        ASSERT(isEmbedOrIsolate(unicodeBidiValue));
+        DCHECK(isEmbedOrIsolate(unicodeBidiValue));

[yosin_UTC9, 2016/04/14 04:34:59]

How about adding |<< unicodeBidiValue|?

         CSSValue* direction = style->getPropertyCSSValue(CSSPropertyDirection);
         if (!direction || !direction->isPrimitiveValue())
             continue;
 
         int directionValue = toCSSPrimitiveValue(direction)->getValueID();
         if (directionValue != CSSValueLtr && directionValue != CSSValueRtl)
             continue;
 
         if (foundDirection != NaturalWritingDirection)
             return NaturalWritingDirection;
@@ skipping 11 matching lines @@
 DEFINE_TRACE(EditingStyle)
 {
     visitor->trace(m_mutableStyle);
 }
 
 static void reconcileTextDecorationProperties(MutableStylePropertySet* style)
 {
     CSSValue* textDecorationsInEffect = style->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);
     CSSValue* textDecoration = style->getPropertyCSSValue(textDecorationPropertyForEditing());
     // We shouldn't have both text-decoration and -webkit-text-decorations-in-effect because that wouldn't make sense.
-    ASSERT(!textDecorationsInEffect || !textDecoration);
+    DCHECK(!textDecorationsInEffect || !textDecoration);
     if (textDecorationsInEffect) {
         style->setProperty(textDecorationPropertyForEditing(), textDecorationsInEffect->cssText());
         style->removeProperty(CSSPropertyWebkitTextDecorationsInEffect);
         textDecoration = textDecorationsInEffect;
     }
 
     // If text-decoration is set to "none", remove the property because we don't want to add redundant "text-decoration: none".
     if (textDecoration && !textDecoration->isValueList())
         style->removeProperty(textDecorationPropertyForEditing());
 }
 
 StyleChange::StyleChange(EditingStyle* style, const Position& position)
     : m_applyBold(false)
     , m_applyItalic(false)
     , m_applyUnderline(false)
     , m_applyLineThrough(false)
     , m_applySubscript(false)
     , m_applySuperscript(false)
 {
     Document* document = position.document();
     if (!style || !style->style() || !document || !document->frame() || !associatedElementOf(position))
         return;
 
     CSSComputedStyleDeclaration* computedStyle = ensureComputedStyle(position);
     // FIXME: take care of background-color in effect
     MutableStylePropertySet* mutableStyle = getPropertiesNotIn(style->style(), computedStyle);
-    ASSERT(mutableStyle);
+    DCHECK(mutableStyle);
 
     reconcileTextDecorationProperties(mutableStyle);
     if (!document->frame()->editor().shouldStyleWithCSS())
         extractTextStyles(document, mutableStyle, computedStyle->isMonospaceFont());
 
     // Changing the whitespace style in a tab span would collapse the tab into a space.
     if (isTabHTMLSpanElementTextNode(position.anchorNode()) || isTabHTMLSpanElement((position.anchorNode())))
         mutableStyle->removeProperty(CSSPropertyWhiteSpace);
 
     // If unicode-bidi is present in mutableStyle and direction is not, then add direction to mutableStyle.
@@ skipping 11 matching lines @@
         style->setProperty(propertyID, newTextDecoration->cssText(), style->propertyIsImportant(propertyID));
     } else {
         // text-decoration: none is redundant since it does not remove any text
         // decorations.
         style->removeProperty(propertyID);
     }
 }
 
 void StyleChange::extractTextStyles(Document* document, MutableStylePropertySet* style, bool isMonospaceFont)
 {
-    ASSERT(style);
+    DCHECK(style);
 
     if (getIdentifierValue(style, CSSPropertyFontWeight) == CSSValueBold) {
         style->removeProperty(CSSPropertyFontWeight);
         m_applyBold = true;
     }
 
     int fontStyle = getIdentifierValue(style, CSSPropertyFontStyle);
     if (fontStyle == CSSValueItalic || fontStyle == CSSValueOblique) {
         style->removeProperty(CSSPropertyFontStyle);
         m_applyItalic = true;
@@ skipping 95 matching lines @@
 {
     if (!fontWeight->isPrimitiveValue())
         return true;
 
     CSSValueID value = toCSSPrimitiveValue(fontWeight)->getValueID();
     return value == CSSValueLighter || value == CSSValueBolder;
 }
 
 MutableStylePropertySet* getPropertiesNotIn(StylePropertySet* styleWithRedundantProperties, CSSStyleDeclaration* baseStyle)
 {
-    ASSERT(styleWithRedundantProperties);
-    ASSERT(baseStyle);
+    DCHECK(styleWithRedundantProperties);
+    DCHECK(baseStyle);
     MutableStylePropertySet* result = styleWithRedundantProperties->mutableCopy();
 
     result->removeEquivalentProperties(baseStyle);
 
     CSSValue* baseTextDecorationsInEffect = baseStyle->getPropertyCSSValueInternal(CSSPropertyWebkitTextDecorationsInEffect);
     diffTextDecorations(result, textDecorationPropertyForEditing(), baseTextDecorationsInEffect);
     diffTextDecorations(result, CSSPropertyWebkitTextDecorationsInEffect, baseTextDecorationsInEffect);
 
     if (CSSValue* baseFontWeight = baseStyle->getPropertyCSSValueInternal(CSSPropertyFontWeight)) {
         if (CSSValue* fontWeight = result->getPropertyCSSValue(CSSPropertyFontWeight)) {
@@ skipping 85 matching lines @@
 {
     for (Node* ancestor = node; ancestor; ancestor = ancestor->parentNode()) {
         CSSComputedStyleDeclaration* ancestorStyle = CSSComputedStyleDeclaration::create(ancestor);
         if (!hasTransparentBackgroundColor(ancestorStyle))
             return ancestorStyle->getPropertyCSSValue(CSSPropertyBackgroundColor);
     }
     return nullptr;
 }
 
 } // namespace blink