Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(306)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: third_party/WebKit/Source/core/editing/EditingStyle.cpp

Issue 2346193002: Split CSSPrimitiveValue into CSSPrimitiveValue and CSSIdentifierValue (Closed)
Patch Set: Rebase please work Created 4 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « third_party/WebKit/Source/core/dom/TextLinkColors.cpp ('k') | third_party/WebKit/Source/core/editing/commands/EditorCommand.cpp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: third_party/WebKit/Source/core/editing/EditingStyle.cpp
diff --git a/third_party/WebKit/Source/core/editing/EditingStyle.cpp b/third_party/WebKit/Source/core/editing/EditingStyle.cpp
index 37c6177d142e6b33411b727cccb8dfc9a7f6e54c..0d2b4277b583517bbc8169105456167c1f6a22e7 100644
--- a/third_party/WebKit/Source/core/editing/EditingStyle.cpp
+++ b/third_party/WebKit/Source/core/editing/EditingStyle.cpp
@@ -30,6 +30,7 @@
#include "core/HTMLNames.h"
#include "core/css/CSSColorValue.h"
#include "core/css/CSSComputedStyleDeclaration.h"
+#include "core/css/CSSIdentifierValue.h"
#include "core/css/CSSPrimitiveValue.h"
#include "core/css/CSSPrimitiveValueMappings.h"
#include "core/css/CSSPropertyMetadata.h"
@@ -159,7 +160,7 @@ static CSSComputedStyleDeclaration* ensureComputedStyle(const Position& position
static MutableStylePropertySet* getPropertiesNotIn(StylePropertySet* styleWithRedundantProperties, CSSStyleDeclaration* baseStyle);
enum LegacyFontSizeMode { AlwaysUseLegacyFontSize, UseLegacyFontSizeOnlyIfPixelValuesMatch };
-static int legacyFontSizeFromCSSValue(Document*, const CSSPrimitiveValue*, bool, LegacyFontSizeMode);
+static int legacyFontSizeFromCSSValue(Document*, const CSSValue*, bool, LegacyFontSizeMode);
static bool isTransparentColorValue(const CSSValue*);
static bool hasTransparentBackgroundColor(CSSStyleDeclaration*);
static bool hasTransparentBackgroundColor(StylePropertySet*);
@@ -179,14 +180,14 @@ public:
virtual bool valueIsPresentInStyle(HTMLElement*, StylePropertySet*) const;
virtual void addToStyle(Element*, EditingStyle*) const;
- DEFINE_INLINE_VIRTUAL_TRACE() { visitor->trace(m_primitiveValue); }
+ DEFINE_INLINE_VIRTUAL_TRACE() { visitor->trace(m_identifierValue); }
protected:
HTMLElementEquivalent(CSSPropertyID);
HTMLElementEquivalent(CSSPropertyID, const HTMLQualifiedName& tagName);
HTMLElementEquivalent(CSSPropertyID, CSSValueID primitiveValue, const HTMLQualifiedName& tagName);
const CSSPropertyID m_propertyID;
- const Member<CSSPrimitiveValue> m_primitiveValue;
+ const Member<CSSIdentifierValue> m_identifierValue;
const HTMLQualifiedName* m_tagName; // We can store a pointer because HTML tag names are const global.
};
@@ -202,23 +203,23 @@ HTMLElementEquivalent::HTMLElementEquivalent(CSSPropertyID id, const HTMLQualifi
{
}
-HTMLElementEquivalent::HTMLElementEquivalent(CSSPropertyID id, CSSValueID primitiveValue, const HTMLQualifiedName& tagName)
+HTMLElementEquivalent::HTMLElementEquivalent(CSSPropertyID id, CSSValueID valueID, const HTMLQualifiedName& tagName)
: m_propertyID(id)
- , m_primitiveValue(CSSPrimitiveValue::createIdentifier(primitiveValue))
+ , m_identifierValue(CSSIdentifierValue::create(valueID))
, m_tagName(&tagName)
{
- DCHECK_NE(primitiveValue, CSSValueInvalid);
+ DCHECK_NE(valueID, CSSValueInvalid);
}
bool HTMLElementEquivalent::valueIsPresentInStyle(HTMLElement* element, StylePropertySet* style) const
{
const CSSValue* value = style->getPropertyCSSValue(m_propertyID);
- return matches(element) && value && value->isPrimitiveValue() && toCSSPrimitiveValue(value)->getValueID() == m_primitiveValue->getValueID();
+ return matches(element) && value && value->isIdentifierValue() && toCSSIdentifierValue(value)->getValueID() == m_identifierValue->getValueID();
}
void HTMLElementEquivalent::addToStyle(Element*, EditingStyle* style) const
{
- style->setProperty(m_propertyID, m_primitiveValue->cssText());
+ style->setProperty(m_propertyID, m_identifierValue->cssText());
}
class HTMLTextDecorationEquivalent final : public HTMLElementEquivalent {
@@ -253,7 +254,7 @@ bool HTMLTextDecorationEquivalent::valueIsPresentInStyle(HTMLElement* element, S
const CSSValue* styleValue = style->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);
if (!styleValue)
styleValue = style->getPropertyCSSValue(textDecorationPropertyForEditing());
- return matches(element) && styleValue && styleValue->isValueList() && toCSSValueList(styleValue)->hasValue(*m_primitiveValue);
+ return matches(element) && styleValue && styleValue->isValueList() && toCSSValueList(styleValue)->hasValue(*m_identifierValue);
}
class HTMLAttributeEquivalent : public HTMLElementEquivalent {
@@ -349,7 +350,7 @@ const CSSValue* HTMLFontSizeEquivalent::attributeValueAsCSSValue(Element* elemen
CSSValueID size;
if (!HTMLFontElement::cssValueFromFontSizeNumber(value, size))
return nullptr;
- return CSSPrimitiveValue::createIdentifier(size);
+ return CSSIdentifierValue::create(size);
}
float EditingStyle::NoFontDelta = 0.0f;
@@ -379,7 +380,7 @@ EditingStyle::EditingStyle(CSSPropertyID propertyID, const String& value)
static Color cssValueToColor(const CSSValue* colorValue)
{
- if (!colorValue || (!colorValue->isColorValue() && !colorValue->isPrimitiveValue()))
+ if (!colorValue || (!colorValue->isColorValue() && !colorValue->isPrimitiveValue() && !colorValue->isIdentifierValue()))
return Color::transparent;
if (colorValue->isColorValue())
@@ -535,16 +536,16 @@ bool EditingStyle::textDirection(WritingDirection& writingDirection) const
return false;
const CSSValue* unicodeBidi = m_mutableStyle->getPropertyCSSValue(CSSPropertyUnicodeBidi);
- if (!unicodeBidi || !unicodeBidi->isPrimitiveValue())
+ if (!unicodeBidi || !unicodeBidi->isIdentifierValue())
return false;
- CSSValueID unicodeBidiValue = toCSSPrimitiveValue(unicodeBidi)->getValueID();
+ CSSValueID unicodeBidiValue = toCSSIdentifierValue(unicodeBidi)->getValueID();
if (isEmbedOrIsolate(unicodeBidiValue)) {
const CSSValue* direction = m_mutableStyle->getPropertyCSSValue(CSSPropertyDirection);
- if (!direction || !direction->isPrimitiveValue())
+ if (!direction || !direction->isIdentifierValue())
return false;
- writingDirection = toCSSPrimitiveValue(direction)->getValueID() == CSSValueLtr ? LeftToRightWritingDirection : RightToLeftWritingDirection;
+ writingDirection = toCSSIdentifierValue(direction)->getValueID() == CSSValueLtr ? LeftToRightWritingDirection : RightToLeftWritingDirection;
return true;
}
@@ -754,7 +755,7 @@ TriState EditingStyle::triStateOfStyle(const VisibleSelection& selection) const
// style(vertical-align) to it so that document.queryCommandState() works with the style.
// See bug http://crbug.com/582225.
if (m_isVerticalAlign && getIdentifierValue(nodeStyle, CSSPropertyVerticalAlign) == CSSValueBaseline) {
- const CSSPrimitiveValue* verticalAlign = toCSSPrimitiveValue(m_mutableStyle->getPropertyCSSValue(CSSPropertyVerticalAlign));
+ const CSSIdentifierValue* verticalAlign = toCSSIdentifierValue(m_mutableStyle->getPropertyCSSValue(CSSPropertyVerticalAlign));
if (hasAncestorVerticalAlignStyle(node, verticalAlign->getValueID()))
node.mutableComputedStyle()->setVerticalAlign(verticalAlign->convertTo<EVerticalAlign>());
}
@@ -1019,10 +1020,10 @@ void EditingStyle::prepareToApplyAt(const Position& position, ShouldPreserveWrit
|| cssValueToColor(m_mutableStyle->getPropertyCSSValue(CSSPropertyBackgroundColor)) == backgroundColorInEffect(position.computeContainerNode()))
m_mutableStyle->removeProperty(CSSPropertyBackgroundColor);
- if (unicodeBidi && unicodeBidi->isPrimitiveValue()) {
- m_mutableStyle->setProperty(CSSPropertyUnicodeBidi, toCSSPrimitiveValue(unicodeBidi)->getValueID());
- if (direction && direction->isPrimitiveValue())
- m_mutableStyle->setProperty(CSSPropertyDirection, toCSSPrimitiveValue(direction)->getValueID());
+ if (unicodeBidi && unicodeBidi->isIdentifierValue()) {
+ m_mutableStyle->setProperty(CSSPropertyUnicodeBidi, toCSSIdentifierValue(unicodeBidi)->getValueID());
+ if (direction && direction->isIdentifierValue())
+ m_mutableStyle->setProperty(CSSPropertyDirection, toCSSIdentifierValue(direction)->getValueID());
}
}
@@ -1142,8 +1143,8 @@ EditingStyle* EditingStyle::wrappingStyleForSerialization(ContainerNode* context
static const CSSValueList& mergeTextDecorationValues(const CSSValueList& mergedValue, const CSSValueList& valueToMerge)
{
- DEFINE_STATIC_LOCAL(CSSPrimitiveValue, underline, (CSSPrimitiveValue::createIdentifier(CSSValueUnderline)));
- DEFINE_STATIC_LOCAL(CSSPrimitiveValue, lineThrough, (CSSPrimitiveValue::createIdentifier(CSSValueLineThrough)));
+ DEFINE_STATIC_LOCAL(CSSIdentifierValue, underline, (CSSIdentifierValue::create(CSSValueUnderline)));
+ DEFINE_STATIC_LOCAL(CSSIdentifierValue, lineThrough, (CSSIdentifierValue::create(CSSValueLineThrough)));
CSSValueList& result = *mergedValue.copy();
if (valueToMerge.hasValue(underline) && !mergedValue.hasValue(underline))
result.append(underline);
@@ -1324,10 +1325,9 @@ void EditingStyle::forceInline()
int EditingStyle::legacyFontSize(Document* document) const
{
const CSSValue* cssValue = m_mutableStyle->getPropertyCSSValue(CSSPropertyFontSize);
- if (!cssValue || !cssValue->isPrimitiveValue())
+ if (!cssValue || !(cssValue->isPrimitiveValue() || cssValue->isIdentifierValue()))
return 0;
- return legacyFontSizeFromCSSValue(document, toCSSPrimitiveValue(cssValue),
- m_isMonospaceFont, AlwaysUseLegacyFontSize);
+ return legacyFontSizeFromCSSValue(document, cssValue, m_isMonospaceFont, AlwaysUseLegacyFontSize);
}
EditingStyle* EditingStyle::styleAtSelectionStart(const VisibleSelection& selection, bool shouldUseBackgroundColorInEffect, MutableStylePropertySet* styleToCheck)
@@ -1415,10 +1415,10 @@ WritingDirection EditingStyle::textDirectionForSelection(const VisibleSelection&
CSSComputedStyleDeclaration* style = CSSComputedStyleDeclaration::create(&n);
const CSSValue* unicodeBidi = style->getPropertyCSSValue(CSSPropertyUnicodeBidi);
- if (!unicodeBidi || !unicodeBidi->isPrimitiveValue())
+ if (!unicodeBidi || !unicodeBidi->isIdentifierValue())
continue;
- CSSValueID unicodeBidiValue = toCSSPrimitiveValue(unicodeBidi)->getValueID();
+ CSSValueID unicodeBidiValue = toCSSIdentifierValue(unicodeBidi)->getValueID();
if (isUnicodeBidiNestedOrMultipleEmbeddings(unicodeBidiValue))
return NaturalWritingDirection;
}
@@ -1448,10 +1448,10 @@ WritingDirection EditingStyle::textDirectionForSelection(const VisibleSelection&
Element* element = &toElement(runner);
CSSComputedStyleDeclaration* style = CSSComputedStyleDeclaration::create(element);
const CSSValue* unicodeBidi = style->getPropertyCSSValue(CSSPropertyUnicodeBidi);
- if (!unicodeBidi || !unicodeBidi->isPrimitiveValue())
+ if (!unicodeBidi || !unicodeBidi->isIdentifierValue())
continue;
- CSSValueID unicodeBidiValue = toCSSPrimitiveValue(unicodeBidi)->getValueID();
+ CSSValueID unicodeBidiValue = toCSSIdentifierValue(unicodeBidi)->getValueID();
if (unicodeBidiValue == CSSValueNormal)
continue;
@@ -1460,10 +1460,10 @@ WritingDirection EditingStyle::textDirectionForSelection(const VisibleSelection&
DCHECK(isEmbedOrIsolate(unicodeBidiValue)) << unicodeBidiValue;
const CSSValue* direction = style->getPropertyCSSValue(CSSPropertyDirection);
- if (!direction || !direction->isPrimitiveValue())
+ if (!direction || !direction->isIdentifierValue())
continue;
- int directionValue = toCSSPrimitiveValue(direction)->getValueID();
+ int directionValue = toCSSIdentifierValue(direction)->getValueID();
if (directionValue != CSSValueLtr && directionValue != CSSValueRtl)
continue;
@@ -1566,8 +1566,8 @@ void StyleChange::extractTextStyles(Document* document, MutableStylePropertySet*
// Furthermore, text-decoration: none has been trimmed so that text-decoration property is always a CSSValueList.
const CSSValue* textDecoration = style->getPropertyCSSValue(textDecorationPropertyForEditing());
if (textDecoration && textDecoration->isValueList()) {
- DEFINE_STATIC_LOCAL(CSSPrimitiveValue, underline, (CSSPrimitiveValue::createIdentifier(CSSValueUnderline)));
- DEFINE_STATIC_LOCAL(CSSPrimitiveValue, lineThrough, (CSSPrimitiveValue::createIdentifier(CSSValueLineThrough)));
+ DEFINE_STATIC_LOCAL(CSSIdentifierValue, underline, (CSSIdentifierValue::create(CSSValueUnderline)));
+ DEFINE_STATIC_LOCAL(CSSIdentifierValue, lineThrough, (CSSIdentifierValue::create(CSSValueLineThrough)));
CSSValueList* newTextDecoration = toCSSValueList(textDecoration)->copy();
if (newTextDecoration->removeAll(underline))
m_applyUnderline = true;
@@ -1601,9 +1601,9 @@ void StyleChange::extractTextStyles(Document* document, MutableStylePropertySet*
style->removeProperty(CSSPropertyFontFamily);
if (const CSSValue* fontSize = style->getPropertyCSSValue(CSSPropertyFontSize)) {
- if (!fontSize->isPrimitiveValue()) {
+ if (!fontSize->isPrimitiveValue() && !fontSize->isIdentifierValue()) {
style->removeProperty(CSSPropertyFontSize); // Can't make sense of the number. Put no font size.
- } else if (int legacyFontSize = legacyFontSizeFromCSSValue(document, toCSSPrimitiveValue(fontSize), isMonospaceFont, UseLegacyFontSizeOnlyIfPixelValuesMatch)) {
+ } else if (int legacyFontSize = legacyFontSizeFromCSSValue(document, fontSize, isMonospaceFont, UseLegacyFontSizeOnlyIfPixelValuesMatch)) {
m_applyFontSize = String::number(legacyFontSize);
style->removeProperty(CSSPropertyFontSize);
}
@@ -1627,12 +1627,12 @@ static void diffTextDecorations(MutableStylePropertySet* style, CSSPropertyID pr
static bool fontWeightIsBold(const CSSValue* fontWeight)
{
- if (!fontWeight->isPrimitiveValue())
+ if (!fontWeight->isIdentifierValue())
return false;
// Because b tag can only bold text, there are only two states in plain html: bold and not bold.
// Collapse all other values to either one of these two states for editing purposes.
- switch (toCSSPrimitiveValue(fontWeight)->getValueID()) {
+ switch (toCSSIdentifierValue(fontWeight)->getValueID()) {
case CSSValue100:
case CSSValue200:
case CSSValue300:
@@ -1656,10 +1656,10 @@ static bool fontWeightIsBold(const CSSValue* fontWeight)
static bool fontWeightNeedsResolving(const CSSValue* fontWeight)
{
- if (!fontWeight->isPrimitiveValue())
+ if (!fontWeight->isIdentifierValue())
return true;
- const CSSValueID value = toCSSPrimitiveValue(fontWeight)->getValueID();
+ const CSSValueID value = toCSSIdentifierValue(fontWeight)->getValueID();
return value == CSSValueLighter || value == CSSValueBolder;
}
@@ -1701,9 +1701,9 @@ CSSValueID getIdentifierValue(StylePropertySet* style, CSSPropertyID propertyID)
if (!style)
return CSSValueInvalid;
const CSSValue* value = style->getPropertyCSSValue(propertyID);
- if (!value || !value->isPrimitiveValue())
+ if (!value || !value->isIdentifierValue())
return CSSValueInvalid;
- return toCSSPrimitiveValue(value)->getValueID();
+ return toCSSIdentifierValue(value)->getValueID();
}
CSSValueID getIdentifierValue(CSSStyleDeclaration* style, CSSPropertyID propertyID)
@@ -1711,28 +1711,34 @@ CSSValueID getIdentifierValue(CSSStyleDeclaration* style, CSSPropertyID property
if (!style)
return CSSValueInvalid;
const CSSValue* value = style->getPropertyCSSValueInternal(propertyID);
- if (!value || !value->isPrimitiveValue())
+ if (!value || !value->isIdentifierValue())
return CSSValueInvalid;
- return toCSSPrimitiveValue(value)->getValueID();
+ return toCSSIdentifierValue(value)->getValueID();
}
-int legacyFontSizeFromCSSValue(Document* document, const CSSPrimitiveValue* value, bool isMonospaceFont, LegacyFontSizeMode mode)
+int legacyFontSizeFromCSSValue(Document* document, const CSSValue* value, bool isMonospaceFont, LegacyFontSizeMode mode)
{
- CSSPrimitiveValue::LengthUnitType lengthType;
- if (CSSPrimitiveValue::unitTypeToLengthUnitType(value->typeWithCalcResolved(), lengthType)
- && lengthType == CSSPrimitiveValue::UnitTypePixels) {
- double conversion = CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(value->typeWithCalcResolved());
- int pixelFontSize = clampTo<int>(value->getDoubleValue() * conversion);
- int legacyFontSize = FontSize::legacyFontSize(document, pixelFontSize, isMonospaceFont);
- // Use legacy font size only if pixel value matches exactly to that of legacy font size.
- if (mode == AlwaysUseLegacyFontSize || FontSize::fontSizeForKeyword(document, legacyFontSize, isMonospaceFont) == pixelFontSize)
- return legacyFontSize;
+ if (value->isPrimitiveValue()) {
+ const CSSPrimitiveValue& primitiveValue = toCSSPrimitiveValue(*value);
+ CSSPrimitiveValue::LengthUnitType lengthType;
+ if (CSSPrimitiveValue::unitTypeToLengthUnitType(primitiveValue.typeWithCalcResolved(), lengthType)
+ && lengthType == CSSPrimitiveValue::UnitTypePixels) {
+ double conversion = CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(primitiveValue.typeWithCalcResolved());
+ int pixelFontSize = clampTo<int>(primitiveValue.getDoubleValue() * conversion);
+ int legacyFontSize = FontSize::legacyFontSize(document, pixelFontSize, isMonospaceFont);
+ // Use legacy font size only if pixel value matches exactly to that of legacy font size.
+ if (mode == AlwaysUseLegacyFontSize || FontSize::fontSizeForKeyword(document, legacyFontSize, isMonospaceFont) == pixelFontSize)
+ return legacyFontSize;
- return 0;
+ return 0;
+ }
}
- if (CSSValueXSmall <= value->getValueID() && value->getValueID() <= CSSValueWebkitXxxLarge)
- return value->getValueID() - CSSValueXSmall + 1;
+ if (value->isIdentifierValue()) {
+ const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(*value);
+ if (CSSValueXSmall <= identifierValue.getValueID() && identifierValue.getValueID() <= CSSValueWebkitXxxLarge)
+ return identifierValue.getValueID() - CSSValueXSmall + 1;
+ }
return 0;
}
@@ -1743,10 +1749,9 @@ bool isTransparentColorValue(const CSSValue* cssValue)
return true;
if (cssValue->isColorValue())
return !toCSSColorValue(cssValue)->value().alpha();
- if (!cssValue->isPrimitiveValue())
+ if (!cssValue->isIdentifierValue())
return false;
- const CSSPrimitiveValue* value = toCSSPrimitiveValue(cssValue);
- return value->getValueID() == CSSValueTransparent;
+ return toCSSIdentifierValue(cssValue)->getValueID() == CSSValueTransparent;
}
bool hasTransparentBackgroundColor(CSSStyleDeclaration* style)
« no previous file with comments | « third_party/WebKit/Source/core/dom/TextLinkColors.cpp ('k') | third_party/WebKit/Source/core/editing/commands/EditorCommand.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698