Home | History | Annotate | Download | only in editing 
      1 /*
      2  * Copyright (C) 2007, 2008, 2009 Apple Computer, Inc.
      3  * Copyright (C) 2010, 2011 Google Inc. All rights reserved.
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions
      7  * are met:
      8  * 1. Redistributions of source code must retain the above copyright
      9  *    notice, this list of conditions and the following disclaimer.
     10  * 2. Redistributions in binary form must reproduce the above copyright
     11  *    notice, this list of conditions and the following disclaimer in the
     12  *    documentation and/or other materials provided with the distribution.
     13  *
     14  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     15  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     16  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     17  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     18  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     19  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     20  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     25  */
     26 
     27 #include "config.h"
     28 #include "core/editing/EditingStyle.h"
     29 
     30 #include "bindings/v8/ExceptionStatePlaceholder.h"
     31 #include "core/HTMLNames.h"
     32 #include "core/css/CSSComputedStyleDeclaration.h"
     33 #include "core/css/parser/BisonCSSParser.h"
     34 #include "core/css/CSSRuleList.h"
     35 #include "core/css/CSSStyleRule.h"
     36 #include "core/css/CSSValueList.h"
     37 #include "core/css/FontSize.h"
     38 #include "core/css/RuntimeCSSEnabled.h"
     39 #include "core/css/StylePropertySet.h"
     40 #include "core/css/StyleRule.h"
     41 #include "core/css/resolver/StyleResolver.h"
     42 #include "core/dom/Element.h"
     43 #include "core/dom/Node.h"
     44 #include "core/dom/NodeTraversal.h"
     45 #include "core/dom/Position.h"
     46 #include "core/dom/QualifiedName.h"
     47 #include "core/editing/ApplyStyleCommand.h"
     48 #include "core/editing/Editor.h"
     49 #include "core/editing/FrameSelection.h"
     50 #include "core/editing/HTMLInterchange.h"
     51 #include "core/editing/htmlediting.h"
     52 #include "core/frame/LocalFrame.h"
     53 #include "core/html/HTMLFontElement.h"
     54 #include "core/rendering/style/RenderStyle.h"
     55 
     56 namespace WebCore {
     57 
     58 static const CSSPropertyID& textDecorationPropertyForEditing()
     59 {
     60     static const CSSPropertyID property = RuntimeEnabledFeatures::css3TextDecorationsEnabled() ? CSSPropertyTextDecorationLine : CSSPropertyTextDecoration;
     61     return property;
     62 }
     63 
     64 // Editing style properties must be preserved during editing operation.
     65 // e.g. when a user inserts a new paragraph, all properties listed here must be copied to the new paragraph.
     66 // NOTE: Use either allEditingProperties() or inheritableEditingProperties() to
     67 // respect runtime enabling of properties.
     68 static const CSSPropertyID staticEditingProperties[] = {
     69     CSSPropertyBackgroundColor,
     70     CSSPropertyColor,
     71     CSSPropertyFontFamily,
     72     CSSPropertyFontSize,
     73     CSSPropertyFontStyle,
     74     CSSPropertyFontVariant,
     75     CSSPropertyFontWeight,
     76     CSSPropertyLetterSpacing,
     77     CSSPropertyLineHeight,
     78     CSSPropertyOrphans,
     79     CSSPropertyTextAlign,
     80     // FIXME: CSSPropertyTextDecoration needs to be removed when CSS3 Text
     81     // Decoration feature is no longer experimental.
     82     CSSPropertyTextDecoration,
     83     CSSPropertyTextDecorationLine,
     84     CSSPropertyTextIndent,
     85     CSSPropertyTextTransform,
     86     CSSPropertyWhiteSpace,
     87     CSSPropertyWidows,
     88     CSSPropertyWordSpacing,
     89     CSSPropertyWebkitTextDecorationsInEffect,
     90     CSSPropertyWebkitTextFillColor,
     91     CSSPropertyWebkitTextStrokeColor,
     92     CSSPropertyWebkitTextStrokeWidth,
     93 };
     94 
     95 enum EditingPropertiesType { OnlyInheritableEditingProperties, AllEditingProperties };
     96 
     97 static const Vector<CSSPropertyID>& allEditingProperties()
     98 {
     99     DEFINE_STATIC_LOCAL(Vector<CSSPropertyID>, properties, ());
    100     if (properties.isEmpty()) {
    101         RuntimeCSSEnabled::filterEnabledCSSPropertiesIntoVector(staticEditingProperties, WTF_ARRAY_LENGTH(staticEditingProperties), properties);
    102         if (RuntimeEnabledFeatures::css3TextDecorationsEnabled())
    103             properties.remove(properties.find(CSSPropertyTextDecoration));
    104     }
    105     return properties;
    106 }
    107 
    108 static const Vector<CSSPropertyID>& inheritableEditingProperties()
    109 {
    110     DEFINE_STATIC_LOCAL(Vector<CSSPropertyID>, properties, ());
    111     if (properties.isEmpty()) {
    112         RuntimeCSSEnabled::filterEnabledCSSPropertiesIntoVector(staticEditingProperties, WTF_ARRAY_LENGTH(staticEditingProperties), properties);
    113         for (size_t index = 0; index < properties.size();) {
    114             if (!CSSProperty::isInheritedProperty(properties[index])) {
    115                 properties.remove(index);
    116                 continue;
    117             }
    118             ++index;
    119         }
    120     }
    121     return properties;
    122 }
    123 
    124 template <class StyleDeclarationType>
    125 static PassRefPtrWillBeRawPtr<MutableStylePropertySet> copyEditingProperties(StyleDeclarationType* style, EditingPropertiesType type = OnlyInheritableEditingProperties)
    126 {
    127     if (type == AllEditingProperties)
    128         return style->copyPropertiesInSet(allEditingProperties());
    129     return style->copyPropertiesInSet(inheritableEditingProperties());
    130 }
    131 
    132 static inline bool isEditingProperty(int id)
    133 {
    134     return allEditingProperties().contains(static_cast<CSSPropertyID>(id));
    135 }
    136 
    137 static PassRefPtrWillBeRawPtr<MutableStylePropertySet> editingStyleFromComputedStyle(PassRefPtrWillBeRawPtr<CSSComputedStyleDeclaration> style, EditingPropertiesType type = OnlyInheritableEditingProperties)
    138 {
    139     if (!style)
    140         return MutableStylePropertySet::create();
    141     return copyEditingProperties(style.get(), type);
    142 }
    143 
    144 static PassRefPtrWillBeRawPtr<MutableStylePropertySet> getPropertiesNotIn(StylePropertySet* styleWithRedundantProperties, CSSStyleDeclaration* baseStyle);
    145 enum LegacyFontSizeMode { AlwaysUseLegacyFontSize, UseLegacyFontSizeOnlyIfPixelValuesMatch };
    146 static int legacyFontSizeFromCSSValue(Document*, CSSPrimitiveValue*, bool shouldUseFixedFontDefaultSize, LegacyFontSizeMode);
    147 static bool isTransparentColorValue(CSSValue*);
    148 static bool hasTransparentBackgroundColor(CSSStyleDeclaration*);
    149 static bool hasTransparentBackgroundColor(StylePropertySet*);
    150 static PassRefPtrWillBeRawPtr<CSSValue> backgroundColorInEffect(Node*);
    151 
    152 class HTMLElementEquivalent : public NoBaseWillBeGarbageCollected<HTMLElementEquivalent> {
    153     WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
    154     DECLARE_EMPTY_VIRTUAL_DESTRUCTOR_WILL_BE_REMOVED(HTMLElementEquivalent);
    155 public:
    156     static PassOwnPtrWillBeRawPtr<HTMLElementEquivalent> create(CSSPropertyID propertyID, CSSValueID primitiveValue, const QualifiedName& tagName)
    157     {
    158         return adoptPtrWillBeNoop(new HTMLElementEquivalent(propertyID, primitiveValue, tagName));
    159     }
    160 
    161     virtual bool matches(const Element* element) const { return !m_tagName || element->hasTagName(*m_tagName); }
    162     virtual bool hasAttribute() const { return false; }
    163     virtual bool propertyExistsInStyle(const StylePropertySet* style) const { return style->getPropertyCSSValue(m_propertyID); }
    164     virtual bool valueIsPresentInStyle(Element*, StylePropertySet*) const;
    165     virtual void addToStyle(Element*, EditingStyle*) const;
    166 
    167     virtual void trace(Visitor* visitor) { visitor->trace(m_primitiveValue); }
    168 
    169 protected:
    170     HTMLElementEquivalent(CSSPropertyID);
    171     HTMLElementEquivalent(CSSPropertyID, const QualifiedName& tagName);
    172     HTMLElementEquivalent(CSSPropertyID, CSSValueID primitiveValue, const QualifiedName& tagName);
    173     const CSSPropertyID m_propertyID;
    174     const RefPtrWillBeMember<CSSPrimitiveValue> m_primitiveValue;
    175     const QualifiedName* m_tagName; // We can store a pointer because HTML tag names are const global.
    176 };
    177 
    178 DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(HTMLElementEquivalent);
    179 
    180 HTMLElementEquivalent::HTMLElementEquivalent(CSSPropertyID id)
    181     : m_propertyID(id)
    182     , m_tagName(0)
    183 {
    184 }
    185 
    186 HTMLElementEquivalent::HTMLElementEquivalent(CSSPropertyID id, const QualifiedName& tagName)
    187     : m_propertyID(id)
    188     , m_tagName(&tagName)
    189 {
    190 }
    191 
    192 HTMLElementEquivalent::HTMLElementEquivalent(CSSPropertyID id, CSSValueID primitiveValue, const QualifiedName& tagName)
    193     : m_propertyID(id)
    194     , m_primitiveValue(CSSPrimitiveValue::createIdentifier(primitiveValue))
    195     , m_tagName(&tagName)
    196 {
    197     ASSERT(primitiveValue != CSSValueInvalid);
    198 }
    199 
    200 bool HTMLElementEquivalent::valueIsPresentInStyle(Element* element, StylePropertySet* style) const
    201 {
    202     RefPtrWillBeRawPtr<CSSValue> value = style->getPropertyCSSValue(m_propertyID);
    203     return matches(element) && value && value->isPrimitiveValue() && toCSSPrimitiveValue(value.get())->getValueID() == m_primitiveValue->getValueID();
    204 }
    205 
    206 void HTMLElementEquivalent::addToStyle(Element*, EditingStyle* style) const
    207 {
    208     style->setProperty(m_propertyID, m_primitiveValue->cssText());
    209 }
    210 
    211 class HTMLTextDecorationEquivalent FINAL : public HTMLElementEquivalent {
    212 public:
    213     static PassOwnPtrWillBeRawPtr<HTMLElementEquivalent> create(CSSValueID primitiveValue, const QualifiedName& tagName)
    214     {
    215         return adoptPtrWillBeNoop(new HTMLTextDecorationEquivalent(primitiveValue, tagName));
    216     }
    217     virtual bool propertyExistsInStyle(const StylePropertySet*) const OVERRIDE;
    218     virtual bool valueIsPresentInStyle(Element*, StylePropertySet*) const OVERRIDE;
    219 
    220     virtual void trace(Visitor* visitor) OVERRIDE { HTMLElementEquivalent::trace(visitor); }
    221 
    222 private:
    223     HTMLTextDecorationEquivalent(CSSValueID primitiveValue, const QualifiedName& tagName);
    224 };
    225 
    226 HTMLTextDecorationEquivalent::HTMLTextDecorationEquivalent(CSSValueID primitiveValue, const QualifiedName& tagName)
    227     : HTMLElementEquivalent(textDecorationPropertyForEditing(), primitiveValue, tagName)
    228     // m_propertyID is used in HTMLElementEquivalent::addToStyle
    229 {
    230 }
    231 
    232 bool HTMLTextDecorationEquivalent::propertyExistsInStyle(const StylePropertySet* style) const
    233 {
    234     return style->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect)
    235         || style->getPropertyCSSValue(textDecorationPropertyForEditing());
    236 }
    237 
    238 bool HTMLTextDecorationEquivalent::valueIsPresentInStyle(Element* element, StylePropertySet* style) const
    239 {
    240     RefPtrWillBeRawPtr<CSSValue> styleValue = style->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);
    241     if (!styleValue)
    242         styleValue = style->getPropertyCSSValue(textDecorationPropertyForEditing());
    243     return matches(element) && styleValue && styleValue->isValueList() && toCSSValueList(styleValue.get())->hasValue(m_primitiveValue.get());
    244 }
    245 
    246 class HTMLAttributeEquivalent : public HTMLElementEquivalent {
    247 public:
    248     static PassOwnPtrWillBeRawPtr<HTMLAttributeEquivalent> create(CSSPropertyID propertyID, const QualifiedName& tagName, const QualifiedName& attrName)
    249     {
    250         return adoptPtrWillBeNoop(new HTMLAttributeEquivalent(propertyID, tagName, attrName));
    251     }
    252     static PassOwnPtrWillBeRawPtr<HTMLAttributeEquivalent> create(CSSPropertyID propertyID, const QualifiedName& attrName)
    253     {
    254         return adoptPtrWillBeNoop(new HTMLAttributeEquivalent(propertyID, attrName));
    255     }
    256 
    257     virtual bool matches(const Element* elem) const OVERRIDE { return HTMLElementEquivalent::matches(elem) && elem->hasAttribute(m_attrName); }
    258     virtual bool hasAttribute() const OVERRIDE { return true; }
    259     virtual bool valueIsPresentInStyle(Element*, StylePropertySet*) const OVERRIDE;
    260     virtual void addToStyle(Element*, EditingStyle*) const OVERRIDE;
    261     virtual PassRefPtrWillBeRawPtr<CSSValue> attributeValueAsCSSValue(Element*) const;
    262     inline const QualifiedName& attributeName() const { return m_attrName; }
    263 
    264     virtual void trace(Visitor* visitor) OVERRIDE { HTMLElementEquivalent::trace(visitor); }
    265 
    266 protected:
    267     HTMLAttributeEquivalent(CSSPropertyID, const QualifiedName& tagName, const QualifiedName& attrName);
    268     HTMLAttributeEquivalent(CSSPropertyID, const QualifiedName& attrName);
    269     const QualifiedName& m_attrName; // We can store a reference because HTML attribute names are const global.
    270 };
    271 
    272 HTMLAttributeEquivalent::HTMLAttributeEquivalent(CSSPropertyID id, const QualifiedName& tagName, const QualifiedName& attrName)
    273     : HTMLElementEquivalent(id, tagName)
    274     , m_attrName(attrName)
    275 {
    276 }
    277 
    278 HTMLAttributeEquivalent::HTMLAttributeEquivalent(CSSPropertyID id, const QualifiedName& attrName)
    279     : HTMLElementEquivalent(id)
    280     , m_attrName(attrName)
    281 {
    282 }
    283 
    284 bool HTMLAttributeEquivalent::valueIsPresentInStyle(Element* element, StylePropertySet* style) const
    285 {
    286     RefPtrWillBeRawPtr<CSSValue> value = attributeValueAsCSSValue(element);
    287     RefPtrWillBeRawPtr<CSSValue> styleValue = style->getPropertyCSSValue(m_propertyID);
    288 
    289     return compareCSSValuePtr(value, styleValue);
    290 }
    291 
    292 void HTMLAttributeEquivalent::addToStyle(Element* element, EditingStyle* style) const
    293 {
    294     if (RefPtrWillBeRawPtr<CSSValue> value = attributeValueAsCSSValue(element))
    295         style->setProperty(m_propertyID, value->cssText());
    296 }
    297 
    298 PassRefPtrWillBeRawPtr<CSSValue> HTMLAttributeEquivalent::attributeValueAsCSSValue(Element* element) const
    299 {
    300     ASSERT(element);
    301     const AtomicString& value = element->getAttribute(m_attrName);
    302     if (value.isNull())
    303         return nullptr;
    304 
    305     RefPtrWillBeRawPtr<MutableStylePropertySet> dummyStyle = nullptr;
    306     dummyStyle = MutableStylePropertySet::create();
    307     dummyStyle->setProperty(m_propertyID, value);
    308     return dummyStyle->getPropertyCSSValue(m_propertyID);
    309 }
    310 
    311 class HTMLFontSizeEquivalent FINAL : public HTMLAttributeEquivalent {
    312 public:
    313     static PassOwnPtrWillBeRawPtr<HTMLFontSizeEquivalent> create()
    314     {
    315         return adoptPtrWillBeNoop(new HTMLFontSizeEquivalent());
    316     }
    317     virtual PassRefPtrWillBeRawPtr<CSSValue> attributeValueAsCSSValue(Element*) const OVERRIDE;
    318 
    319     virtual void trace(Visitor* visitor) OVERRIDE { HTMLAttributeEquivalent::trace(visitor); }
    320 
    321 private:
    322     HTMLFontSizeEquivalent();
    323 };
    324 
    325 HTMLFontSizeEquivalent::HTMLFontSizeEquivalent()
    326     : HTMLAttributeEquivalent(CSSPropertyFontSize, HTMLNames::fontTag, HTMLNames::sizeAttr)
    327 {
    328 }
    329 
    330 PassRefPtrWillBeRawPtr<CSSValue> HTMLFontSizeEquivalent::attributeValueAsCSSValue(Element* element) const
    331 {
    332     ASSERT(element);
    333     const AtomicString& value = element->getAttribute(m_attrName);
    334     if (value.isNull())
    335         return nullptr;
    336     CSSValueID size;
    337     if (!HTMLFontElement::cssValueFromFontSizeNumber(value, size))
    338         return nullptr;
    339     return CSSPrimitiveValue::createIdentifier(size);
    340 }
    341 
    342 float EditingStyle::NoFontDelta = 0.0f;
    343 
    344 EditingStyle::EditingStyle()
    345     : m_shouldUseFixedDefaultFontSize(false)
    346     , m_fontSizeDelta(NoFontDelta)
    347 {
    348 }
    349 
    350 EditingStyle::EditingStyle(Node* node, PropertiesToInclude propertiesToInclude)
    351     : m_shouldUseFixedDefaultFontSize(false)
    352     , m_fontSizeDelta(NoFontDelta)
    353 {
    354     init(node, propertiesToInclude);
    355 }
    356 
    357 EditingStyle::EditingStyle(const Position& position, PropertiesToInclude propertiesToInclude)
    358     : m_shouldUseFixedDefaultFontSize(false)
    359     , m_fontSizeDelta(NoFontDelta)
    360 {
    361     init(position.deprecatedNode(), propertiesToInclude);
    362 }
    363 
    364 EditingStyle::EditingStyle(const StylePropertySet* style)
    365     : m_mutableStyle(style ? style->mutableCopy() : nullptr)
    366     , m_shouldUseFixedDefaultFontSize(false)
    367     , m_fontSizeDelta(NoFontDelta)
    368 {
    369     extractFontSizeDelta();
    370 }
    371 
    372 EditingStyle::EditingStyle(CSSPropertyID propertyID, const String& value)
    373     : m_mutableStyle(nullptr)
    374     , m_shouldUseFixedDefaultFontSize(false)
    375     , m_fontSizeDelta(NoFontDelta)
    376 {
    377     setProperty(propertyID, value);
    378 }
    379 
    380 EditingStyle::~EditingStyle()
    381 {
    382 }
    383 
    384 static RGBA32 cssValueToRGBA(CSSValue* colorValue)
    385 {
    386     if (!colorValue || !colorValue->isPrimitiveValue())
    387         return Color::transparent;
    388 
    389     CSSPrimitiveValue* primitiveColor = toCSSPrimitiveValue(colorValue);
    390     if (primitiveColor->isRGBColor())
    391         return primitiveColor->getRGBA32Value();
    392 
    393     RGBA32 rgba = 0;
    394     BisonCSSParser::parseColor(rgba, colorValue->cssText());
    395     return rgba;
    396 }
    397 
    398 static inline RGBA32 getRGBAFontColor(CSSStyleDeclaration* style)
    399 {
    400     return cssValueToRGBA(style->getPropertyCSSValueInternal(CSSPropertyColor).get());
    401 }
    402 
    403 static inline RGBA32 getRGBAFontColor(StylePropertySet* style)
    404 {
    405     return cssValueToRGBA(style->getPropertyCSSValue(CSSPropertyColor).get());
    406 }
    407 
    408 static inline RGBA32 getRGBABackgroundColor(CSSStyleDeclaration* style)
    409 {
    410     return cssValueToRGBA(style->getPropertyCSSValueInternal(CSSPropertyBackgroundColor).get());
    411 }
    412 
    413 static inline RGBA32 getRGBABackgroundColor(StylePropertySet* style)
    414 {
    415     return cssValueToRGBA(style->getPropertyCSSValue(CSSPropertyBackgroundColor).get());
    416 }
    417 
    418 static inline RGBA32 rgbaBackgroundColorInEffect(Node* node)
    419 {
    420     return cssValueToRGBA(backgroundColorInEffect(node).get());
    421 }
    422 
    423 static int textAlignResolvingStartAndEnd(int textAlign, int direction)
    424 {
    425     switch (textAlign) {
    426     case CSSValueCenter:
    427     case CSSValueWebkitCenter:
    428         return CSSValueCenter;
    429     case CSSValueJustify:
    430         return CSSValueJustify;
    431     case CSSValueLeft:
    432     case CSSValueWebkitLeft:
    433         return CSSValueLeft;
    434     case CSSValueRight:
    435     case CSSValueWebkitRight:
    436         return CSSValueRight;
    437     case CSSValueStart:
    438         return direction != CSSValueRtl ? CSSValueLeft : CSSValueRight;
    439     case CSSValueEnd:
    440         return direction == CSSValueRtl ? CSSValueRight : CSSValueLeft;
    441     }
    442     return CSSValueInvalid;
    443 }
    444 
    445 template<typename T>
    446 static int textAlignResolvingStartAndEnd(T* style)
    447 {
    448     return textAlignResolvingStartAndEnd(getIdentifierValue(style, CSSPropertyTextAlign), getIdentifierValue(style, CSSPropertyDirection));
    449 }
    450 
    451 void EditingStyle::init(Node* node, PropertiesToInclude propertiesToInclude)
    452 {
    453     if (isTabSpanTextNode(node))
    454         node = tabSpanNode(node)->parentNode();
    455     else if (isTabSpanNode(node))
    456         node = node->parentNode();
    457 
    458     RefPtrWillBeRawPtr<CSSComputedStyleDeclaration> computedStyleAtPosition = CSSComputedStyleDeclaration::create(node);
    459     m_mutableStyle = propertiesToInclude == AllProperties && computedStyleAtPosition ? computedStyleAtPosition->copyProperties() : editingStyleFromComputedStyle(computedStyleAtPosition);
    460 
    461     if (propertiesToInclude == EditingPropertiesInEffect) {
    462         if (RefPtrWillBeRawPtr<CSSValue> value = backgroundColorInEffect(node))
    463             m_mutableStyle->setProperty(CSSPropertyBackgroundColor, value->cssText());
    464         if (RefPtrWillBeRawPtr<CSSValue> value = computedStyleAtPosition->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect))
    465             m_mutableStyle->setProperty(CSSPropertyTextDecoration, value->cssText());
    466     }
    467 
    468     if (node && node->computedStyle()) {
    469         RenderStyle* renderStyle = node->computedStyle();
    470         removeTextFillAndStrokeColorsIfNeeded(renderStyle);
    471         replaceFontSizeByKeywordIfPossible(renderStyle, computedStyleAtPosition.get());
    472     }
    473 
    474     m_shouldUseFixedDefaultFontSize = computedStyleAtPosition->useFixedFontDefaultSize();
    475     extractFontSizeDelta();
    476 }
    477 
    478 void EditingStyle::removeTextFillAndStrokeColorsIfNeeded(RenderStyle* renderStyle)
    479 {
    480     // If a node's text fill color is currentColor, then its children use
    481     // their font-color as their text fill color (they don't
    482     // inherit it).  Likewise for stroke color.
    483     if (renderStyle->textFillColor().isCurrentColor())
    484         m_mutableStyle->removeProperty(CSSPropertyWebkitTextFillColor);
    485     if (renderStyle->textStrokeColor().isCurrentColor())
    486         m_mutableStyle->removeProperty(CSSPropertyWebkitTextStrokeColor);
    487 }
    488 
    489 void EditingStyle::setProperty(CSSPropertyID propertyID, const String& value, bool important)
    490 {
    491     if (!m_mutableStyle)
    492         m_mutableStyle = MutableStylePropertySet::create();
    493 
    494     m_mutableStyle->setProperty(propertyID, value, important);
    495 }
    496 
    497 void EditingStyle::replaceFontSizeByKeywordIfPossible(RenderStyle* renderStyle, CSSComputedStyleDeclaration* computedStyle)
    498 {
    499     ASSERT(renderStyle);
    500     if (renderStyle->fontDescription().keywordSize())
    501         m_mutableStyle->setProperty(CSSPropertyFontSize, computedStyle->getFontSizeCSSValuePreferringKeyword()->cssText());
    502 }
    503 
    504 void EditingStyle::extractFontSizeDelta()
    505 {
    506     if (!m_mutableStyle)
    507         return;
    508 
    509     if (m_mutableStyle->getPropertyCSSValue(CSSPropertyFontSize)) {
    510         // Explicit font size overrides any delta.
    511         m_mutableStyle->removeProperty(CSSPropertyWebkitFontSizeDelta);
    512         return;
    513     }
    514 
    515     // Get the adjustment amount out of the style.
    516     RefPtrWillBeRawPtr<CSSValue> value = m_mutableStyle->getPropertyCSSValue(CSSPropertyWebkitFontSizeDelta);
    517     if (!value || !value->isPrimitiveValue())
    518         return;
    519 
    520     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value.get());
    521 
    522     // Only PX handled now. If we handle more types in the future, perhaps
    523     // a switch statement here would be more appropriate.
    524     if (!primitiveValue->isPx())
    525         return;
    526 
    527     m_fontSizeDelta = primitiveValue->getFloatValue();
    528     m_mutableStyle->removeProperty(CSSPropertyWebkitFontSizeDelta);
    529 }
    530 
    531 bool EditingStyle::isEmpty() const
    532 {
    533     return (!m_mutableStyle || m_mutableStyle->isEmpty()) && m_fontSizeDelta == NoFontDelta;
    534 }
    535 
    536 bool EditingStyle::textDirection(WritingDirection& writingDirection) const
    537 {
    538     if (!m_mutableStyle)
    539         return false;
    540 
    541     RefPtrWillBeRawPtr<CSSValue> unicodeBidi = m_mutableStyle->getPropertyCSSValue(CSSPropertyUnicodeBidi);
    542     if (!unicodeBidi || !unicodeBidi->isPrimitiveValue())
    543         return false;
    544 
    545     CSSValueID unicodeBidiValue = toCSSPrimitiveValue(unicodeBidi.get())->getValueID();
    546     if (unicodeBidiValue == CSSValueEmbed) {
    547         RefPtrWillBeRawPtr<CSSValue> direction = m_mutableStyle->getPropertyCSSValue(CSSPropertyDirection);
    548         if (!direction || !direction->isPrimitiveValue())
    549             return false;
    550 
    551         writingDirection = toCSSPrimitiveValue(direction.get())->getValueID() == CSSValueLtr ? LeftToRightWritingDirection : RightToLeftWritingDirection;
    552 
    553         return true;
    554     }
    555 
    556     if (unicodeBidiValue == CSSValueNormal) {
    557         writingDirection = NaturalWritingDirection;
    558         return true;
    559     }
    560 
    561     return false;
    562 }
    563 
    564 void EditingStyle::overrideWithStyle(const StylePropertySet* style)
    565 {
    566     if (!style || style->isEmpty())
    567         return;
    568     if (!m_mutableStyle)
    569         m_mutableStyle = MutableStylePropertySet::create();
    570     m_mutableStyle->mergeAndOverrideOnConflict(style);
    571     extractFontSizeDelta();
    572 }
    573 
    574 void EditingStyle::clear()
    575 {
    576     m_mutableStyle.clear();
    577     m_shouldUseFixedDefaultFontSize = false;
    578     m_fontSizeDelta = NoFontDelta;
    579 }
    580 
    581 PassRefPtrWillBeRawPtr<EditingStyle> EditingStyle::copy() const
    582 {
    583     RefPtrWillBeRawPtr<EditingStyle> copy = EditingStyle::create();
    584     if (m_mutableStyle)
    585         copy->m_mutableStyle = m_mutableStyle->mutableCopy();
    586     copy->m_shouldUseFixedDefaultFontSize = m_shouldUseFixedDefaultFontSize;
    587     copy->m_fontSizeDelta = m_fontSizeDelta;
    588     return copy;
    589 }
    590 
    591 PassRefPtrWillBeRawPtr<EditingStyle> EditingStyle::extractAndRemoveBlockProperties()
    592 {
    593     RefPtrWillBeRawPtr<EditingStyle> blockProperties = EditingStyle::create();
    594     if (!m_mutableStyle)
    595         return blockProperties;
    596 
    597     blockProperties->m_mutableStyle = m_mutableStyle->copyBlockProperties();
    598     m_mutableStyle->removeBlockProperties();
    599 
    600     return blockProperties;
    601 }
    602 
    603 PassRefPtrWillBeRawPtr<EditingStyle> EditingStyle::extractAndRemoveTextDirection()
    604 {
    605     RefPtrWillBeRawPtr<EditingStyle> textDirection = EditingStyle::create();
    606     textDirection->m_mutableStyle = MutableStylePropertySet::create();
    607     textDirection->m_mutableStyle->setProperty(CSSPropertyUnicodeBidi, CSSValueEmbed, m_mutableStyle->propertyIsImportant(CSSPropertyUnicodeBidi));
    608     textDirection->m_mutableStyle->setProperty(CSSPropertyDirection, m_mutableStyle->getPropertyValue(CSSPropertyDirection),
    609         m_mutableStyle->propertyIsImportant(CSSPropertyDirection));
    610 
    611     m_mutableStyle->removeProperty(CSSPropertyUnicodeBidi);
    612     m_mutableStyle->removeProperty(CSSPropertyDirection);
    613 
    614     return textDirection;
    615 }
    616 
    617 void EditingStyle::removeBlockProperties()
    618 {
    619     if (!m_mutableStyle)
    620         return;
    621 
    622     m_mutableStyle->removeBlockProperties();
    623 }
    624 
    625 void EditingStyle::removeStyleAddedByNode(Node* node)
    626 {
    627     if (!node || !node->parentNode())
    628         return;
    629     RefPtrWillBeRawPtr<MutableStylePropertySet> parentStyle = editingStyleFromComputedStyle(CSSComputedStyleDeclaration::create(node->parentNode()), AllEditingProperties);
    630     RefPtrWillBeRawPtr<MutableStylePropertySet> nodeStyle = editingStyleFromComputedStyle(CSSComputedStyleDeclaration::create(node), AllEditingProperties);
    631     nodeStyle->removeEquivalentProperties(parentStyle.get());
    632     m_mutableStyle->removeEquivalentProperties(nodeStyle.get());
    633 }
    634 
    635 void EditingStyle::removeStyleConflictingWithStyleOfNode(Node* node)
    636 {
    637     if (!node || !node->parentNode() || !m_mutableStyle)
    638         return;
    639 
    640     RefPtrWillBeRawPtr<MutableStylePropertySet> parentStyle = editingStyleFromComputedStyle(CSSComputedStyleDeclaration::create(node->parentNode()), AllEditingProperties);
    641     RefPtrWillBeRawPtr<MutableStylePropertySet> nodeStyle = editingStyleFromComputedStyle(CSSComputedStyleDeclaration::create(node), AllEditingProperties);
    642     nodeStyle->removeEquivalentProperties(parentStyle.get());
    643 
    644     unsigned propertyCount = nodeStyle->propertyCount();
    645     for (unsigned i = 0; i < propertyCount; ++i)
    646         m_mutableStyle->removeProperty(nodeStyle->propertyAt(i).id());
    647 }
    648 
    649 void EditingStyle::collapseTextDecorationProperties()
    650 {
    651     if (!m_mutableStyle)
    652         return;
    653 
    654     RefPtrWillBeRawPtr<CSSValue> textDecorationsInEffect = m_mutableStyle->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);
    655     if (!textDecorationsInEffect)
    656         return;
    657 
    658     if (textDecorationsInEffect->isValueList())
    659         m_mutableStyle->setProperty(textDecorationPropertyForEditing(), textDecorationsInEffect->cssText(), m_mutableStyle->propertyIsImportant(textDecorationPropertyForEditing()));
    660     else
    661         m_mutableStyle->removeProperty(textDecorationPropertyForEditing());
    662     m_mutableStyle->removeProperty(CSSPropertyWebkitTextDecorationsInEffect);
    663 }
    664 
    665 // CSS properties that create a visual difference only when applied to text.
    666 static const CSSPropertyID textOnlyProperties[] = {
    667     // FIXME: CSSPropertyTextDecoration needs to be removed when CSS3 Text
    668     // Decoration feature is no longer experimental.
    669     CSSPropertyTextDecoration,
    670     CSSPropertyTextDecorationLine,
    671     CSSPropertyWebkitTextDecorationsInEffect,
    672     CSSPropertyFontStyle,
    673     CSSPropertyFontWeight,
    674     CSSPropertyColor,
    675 };
    676 
    677 TriState EditingStyle::triStateOfStyle(EditingStyle* style) const
    678 {
    679     if (!style || !style->m_mutableStyle)
    680         return FalseTriState;
    681     return triStateOfStyle(style->m_mutableStyle->ensureCSSStyleDeclaration(), DoNotIgnoreTextOnlyProperties);
    682 }
    683 
    684 TriState EditingStyle::triStateOfStyle(CSSStyleDeclaration* styleToCompare, ShouldIgnoreTextOnlyProperties shouldIgnoreTextOnlyProperties) const
    685 {
    686     RefPtrWillBeRawPtr<MutableStylePropertySet> difference = getPropertiesNotIn(m_mutableStyle.get(), styleToCompare);
    687 
    688     if (shouldIgnoreTextOnlyProperties == IgnoreTextOnlyProperties)
    689         difference->removePropertiesInSet(textOnlyProperties, WTF_ARRAY_LENGTH(textOnlyProperties));
    690 
    691     if (difference->isEmpty())
    692         return TrueTriState;
    693     if (difference->propertyCount() == m_mutableStyle->propertyCount())
    694         return FalseTriState;
    695 
    696     return MixedTriState;
    697 }
    698 
    699 TriState EditingStyle::triStateOfStyle(const VisibleSelection& selection) const
    700 {
    701     if (!selection.isCaretOrRange())
    702         return FalseTriState;
    703 
    704     if (selection.isCaret())
    705         return triStateOfStyle(EditingStyle::styleAtSelectionStart(selection).get());
    706 
    707     TriState state = FalseTriState;
    708     bool nodeIsStart = true;
    709     for (Node* node = selection.start().deprecatedNode(); node; node = NodeTraversal::next(*node)) {
    710         if (node->renderer() && node->rendererIsEditable()) {
    711             RefPtrWillBeRawPtr<CSSComputedStyleDeclaration> nodeStyle = CSSComputedStyleDeclaration::create(node);
    712             if (nodeStyle) {
    713                 TriState nodeState = triStateOfStyle(nodeStyle.get(), node->isTextNode() ? EditingStyle::DoNotIgnoreTextOnlyProperties : EditingStyle::IgnoreTextOnlyProperties);
    714                 if (nodeIsStart) {
    715                     state = nodeState;
    716                     nodeIsStart = false;
    717                 } else if (state != nodeState && node->isTextNode()) {
    718                     state = MixedTriState;
    719                     break;
    720                 }
    721             }
    722         }
    723         if (node == selection.end().deprecatedNode())
    724             break;
    725     }
    726 
    727     return state;
    728 }
    729 
    730 bool EditingStyle::conflictsWithInlineStyleOfElement(Element* element, EditingStyle* extractedStyle, Vector<CSSPropertyID>* conflictingProperties) const
    731 {
    732     ASSERT(element);
    733     ASSERT(!conflictingProperties || conflictingProperties->isEmpty());
    734 
    735     const StylePropertySet* inlineStyle = element->inlineStyle();
    736     if (!m_mutableStyle || !inlineStyle)
    737         return false;
    738 
    739     unsigned propertyCount = m_mutableStyle->propertyCount();
    740     for (unsigned i = 0; i < propertyCount; ++i) {
    741         CSSPropertyID propertyID = m_mutableStyle->propertyAt(i).id();
    742 
    743         // We don't override whitespace property of a tab span because that would collapse the tab into a space.
    744         if (propertyID == CSSPropertyWhiteSpace && isTabSpanNode(element))
    745             continue;
    746 
    747         if (propertyID == CSSPropertyWebkitTextDecorationsInEffect && inlineStyle->getPropertyCSSValue(textDecorationPropertyForEditing())) {
    748             if (!conflictingProperties)
    749                 return true;
    750             conflictingProperties->append(CSSPropertyTextDecoration);
    751             // Because text-decoration expands to text-decoration-line when CSS3
    752             // Text Decoration is enabled, we also state it as conflicting.
    753             if (RuntimeEnabledFeatures::css3TextDecorationsEnabled())
    754                 conflictingProperties->append(CSSPropertyTextDecorationLine);
    755             if (extractedStyle)
    756                 extractedStyle->setProperty(textDecorationPropertyForEditing(), inlineStyle->getPropertyValue(textDecorationPropertyForEditing()), inlineStyle->propertyIsImportant(textDecorationPropertyForEditing()));
    757             continue;
    758         }
    759 
    760         if (!inlineStyle->getPropertyCSSValue(propertyID))
    761             continue;
    762 
    763         if (propertyID == CSSPropertyUnicodeBidi && inlineStyle->getPropertyCSSValue(CSSPropertyDirection)) {
    764             if (!conflictingProperties)
    765                 return true;
    766             conflictingProperties->append(CSSPropertyDirection);
    767             if (extractedStyle)
    768                 extractedStyle->setProperty(propertyID, inlineStyle->getPropertyValue(propertyID), inlineStyle->propertyIsImportant(propertyID));
    769         }
    770 
    771         if (!conflictingProperties)
    772             return true;
    773 
    774         conflictingProperties->append(propertyID);
    775 
    776         if (extractedStyle)
    777             extractedStyle->setProperty(propertyID, inlineStyle->getPropertyValue(propertyID), inlineStyle->propertyIsImportant(propertyID));
    778     }
    779 
    780     return conflictingProperties && !conflictingProperties->isEmpty();
    781 }
    782 
    783 static const WillBeHeapVector<OwnPtrWillBeMember<HTMLElementEquivalent> >& htmlElementEquivalents()
    784 {
    785     DEFINE_STATIC_LOCAL(WillBePersistentHeapVector<OwnPtrWillBeMember<HTMLElementEquivalent> >, HTMLElementEquivalents, ());
    786     if (!HTMLElementEquivalents.size()) {
    787         HTMLElementEquivalents.append(HTMLElementEquivalent::create(CSSPropertyFontWeight, CSSValueBold, HTMLNames::bTag));
    788         HTMLElementEquivalents.append(HTMLElementEquivalent::create(CSSPropertyFontWeight, CSSValueBold, HTMLNames::strongTag));
    789         HTMLElementEquivalents.append(HTMLElementEquivalent::create(CSSPropertyVerticalAlign, CSSValueSub, HTMLNames::subTag));
    790         HTMLElementEquivalents.append(HTMLElementEquivalent::create(CSSPropertyVerticalAlign, CSSValueSuper, HTMLNames::supTag));
    791         HTMLElementEquivalents.append(HTMLElementEquivalent::create(CSSPropertyFontStyle, CSSValueItalic, HTMLNames::iTag));
    792         HTMLElementEquivalents.append(HTMLElementEquivalent::create(CSSPropertyFontStyle, CSSValueItalic, HTMLNames::emTag));
    793 
    794         HTMLElementEquivalents.append(HTMLTextDecorationEquivalent::create(CSSValueUnderline, HTMLNames::uTag));
    795         HTMLElementEquivalents.append(HTMLTextDecorationEquivalent::create(CSSValueLineThrough, HTMLNames::sTag));
    796         HTMLElementEquivalents.append(HTMLTextDecorationEquivalent::create(CSSValueLineThrough, HTMLNames::strikeTag));
    797     }
    798 
    799     return HTMLElementEquivalents;
    800 }
    801 
    802 
    803 bool EditingStyle::conflictsWithImplicitStyleOfElement(HTMLElement* element, EditingStyle* extractedStyle, ShouldExtractMatchingStyle shouldExtractMatchingStyle) const
    804 {
    805     if (!m_mutableStyle)
    806         return false;
    807 
    808     const WillBeHeapVector<OwnPtrWillBeMember<HTMLElementEquivalent> >& HTMLElementEquivalents = htmlElementEquivalents();
    809     for (size_t i = 0; i < HTMLElementEquivalents.size(); ++i) {
    810         const HTMLElementEquivalent* equivalent = HTMLElementEquivalents[i].get();
    811         if (equivalent->matches(element) && equivalent->propertyExistsInStyle(m_mutableStyle.get())
    812             && (shouldExtractMatchingStyle == ExtractMatchingStyle || !equivalent->valueIsPresentInStyle(element, m_mutableStyle.get()))) {
    813             if (extractedStyle)
    814                 equivalent->addToStyle(element, extractedStyle);
    815             return true;
    816         }
    817     }
    818     return false;
    819 }
    820 
    821 static const WillBeHeapVector<OwnPtrWillBeMember<HTMLAttributeEquivalent> >& htmlAttributeEquivalents()
    822 {
    823     DEFINE_STATIC_LOCAL(WillBePersistentHeapVector<OwnPtrWillBeMember<HTMLAttributeEquivalent> >, HTMLAttributeEquivalents, ());
    824     if (!HTMLAttributeEquivalents.size()) {
    825         // elementIsStyledSpanOrHTMLEquivalent depends on the fact each HTMLAttriuteEquivalent matches exactly one attribute
    826         // of exactly one element except dirAttr.
    827         HTMLAttributeEquivalents.append(HTMLAttributeEquivalent::create(CSSPropertyColor, HTMLNames::fontTag, HTMLNames::colorAttr));
    828         HTMLAttributeEquivalents.append(HTMLAttributeEquivalent::create(CSSPropertyFontFamily, HTMLNames::fontTag, HTMLNames::faceAttr));
    829         HTMLAttributeEquivalents.append(HTMLFontSizeEquivalent::create());
    830 
    831         HTMLAttributeEquivalents.append(HTMLAttributeEquivalent::create(CSSPropertyDirection, HTMLNames::dirAttr));
    832         HTMLAttributeEquivalents.append(HTMLAttributeEquivalent::create(CSSPropertyUnicodeBidi, HTMLNames::dirAttr));
    833     }
    834 
    835     return HTMLAttributeEquivalents;
    836 }
    837 
    838 bool EditingStyle::conflictsWithImplicitStyleOfAttributes(HTMLElement* element) const
    839 {
    840     ASSERT(element);
    841     if (!m_mutableStyle)
    842         return false;
    843 
    844     const WillBeHeapVector<OwnPtrWillBeMember<HTMLAttributeEquivalent> >& HTMLAttributeEquivalents = htmlAttributeEquivalents();
    845     for (size_t i = 0; i < HTMLAttributeEquivalents.size(); ++i) {
    846         if (HTMLAttributeEquivalents[i]->matches(element) && HTMLAttributeEquivalents[i]->propertyExistsInStyle(m_mutableStyle.get())
    847             && !HTMLAttributeEquivalents[i]->valueIsPresentInStyle(element, m_mutableStyle.get()))
    848             return true;
    849     }
    850 
    851     return false;
    852 }
    853 
    854 bool EditingStyle::extractConflictingImplicitStyleOfAttributes(HTMLElement* element, ShouldPreserveWritingDirection shouldPreserveWritingDirection,
    855     EditingStyle* extractedStyle, Vector<QualifiedName>& conflictingAttributes, ShouldExtractMatchingStyle shouldExtractMatchingStyle) const
    856 {
    857     ASSERT(element);
    858     // HTMLAttributeEquivalent::addToStyle doesn't support unicode-bidi and direction properties
    859     ASSERT(!extractedStyle || shouldPreserveWritingDirection == PreserveWritingDirection);
    860     if (!m_mutableStyle)
    861         return false;
    862 
    863     const WillBeHeapVector<OwnPtrWillBeMember<HTMLAttributeEquivalent> >& HTMLAttributeEquivalents = htmlAttributeEquivalents();
    864     bool removed = false;
    865     for (size_t i = 0; i < HTMLAttributeEquivalents.size(); ++i) {
    866         const HTMLAttributeEquivalent* equivalent = HTMLAttributeEquivalents[i].get();
    867 
    868         // unicode-bidi and direction are pushed down separately so don't push down with other styles.
    869         if (shouldPreserveWritingDirection == PreserveWritingDirection && equivalent->attributeName() == HTMLNames::dirAttr)
    870             continue;
    871 
    872         if (!equivalent->matches(element) || !equivalent->propertyExistsInStyle(m_mutableStyle.get())
    873             || (shouldExtractMatchingStyle == DoNotExtractMatchingStyle && equivalent->valueIsPresentInStyle(element, m_mutableStyle.get())))
    874             continue;
    875 
    876         if (extractedStyle)
    877             equivalent->addToStyle(element, extractedStyle);
    878         conflictingAttributes.append(equivalent->attributeName());
    879         removed = true;
    880     }
    881 
    882     return removed;
    883 }
    884 
    885 bool EditingStyle::styleIsPresentInComputedStyleOfNode(Node* node) const
    886 {
    887     return !m_mutableStyle || getPropertiesNotIn(m_mutableStyle.get(), CSSComputedStyleDeclaration::create(node).get())->isEmpty();
    888 }
    889 
    890 bool EditingStyle::elementIsStyledSpanOrHTMLEquivalent(const HTMLElement* element)
    891 {
    892     ASSERT(element);
    893     bool elementIsSpanOrElementEquivalent = false;
    894     if (isHTMLSpanElement(*element))
    895         elementIsSpanOrElementEquivalent = true;
    896     else {
    897         const WillBeHeapVector<OwnPtrWillBeMember<HTMLElementEquivalent> >& HTMLElementEquivalents = htmlElementEquivalents();
    898         size_t i;
    899         for (i = 0; i < HTMLElementEquivalents.size(); ++i) {
    900             if (HTMLElementEquivalents[i]->matches(element)) {
    901                 elementIsSpanOrElementEquivalent = true;
    902                 break;
    903             }
    904         }
    905     }
    906 
    907     if (!element->hasAttributes())
    908         return elementIsSpanOrElementEquivalent; // span, b, etc... without any attributes
    909 
    910     unsigned matchedAttributes = 0;
    911     const WillBeHeapVector<OwnPtrWillBeMember<HTMLAttributeEquivalent> >& HTMLAttributeEquivalents = htmlAttributeEquivalents();
    912     for (size_t i = 0; i < HTMLAttributeEquivalents.size(); ++i) {
    913         if (HTMLAttributeEquivalents[i]->matches(element) && HTMLAttributeEquivalents[i]->attributeName() != HTMLNames::dirAttr)
    914             matchedAttributes++;
    915     }
    916 
    917     if (!elementIsSpanOrElementEquivalent && !matchedAttributes)
    918         return false; // element is not a span, a html element equivalent, or font element.
    919 
    920     if (element->getAttribute(HTMLNames::classAttr) == AppleStyleSpanClass)
    921         matchedAttributes++;
    922 
    923     if (element->hasAttribute(HTMLNames::styleAttr)) {
    924         if (const StylePropertySet* style = element->inlineStyle()) {
    925             unsigned propertyCount = style->propertyCount();
    926             for (unsigned i = 0; i < propertyCount; ++i) {
    927                 if (!isEditingProperty(style->propertyAt(i).id()))
    928                     return false;
    929             }
    930         }
    931         matchedAttributes++;
    932     }
    933 
    934     // font with color attribute, span with style attribute, etc...
    935     ASSERT(matchedAttributes <= element->attributeCount());
    936     return matchedAttributes >= element->attributeCount();
    937 }
    938 
    939 void EditingStyle::prepareToApplyAt(const Position& position, ShouldPreserveWritingDirection shouldPreserveWritingDirection)
    940 {
    941     if (!m_mutableStyle)
    942         return;
    943 
    944     // ReplaceSelectionCommand::handleStyleSpans() requires that this function only removes the editing style.
    945     // If this function was modified in the future to delete all redundant properties, then add a boolean value to indicate
    946     // which one of editingStyleAtPosition or computedStyle is called.
    947     RefPtrWillBeRawPtr<EditingStyle> editingStyleAtPosition = EditingStyle::create(position, EditingPropertiesInEffect);
    948     StylePropertySet* styleAtPosition = editingStyleAtPosition->m_mutableStyle.get();
    949 
    950     RefPtrWillBeRawPtr<CSSValue> unicodeBidi = nullptr;
    951     RefPtrWillBeRawPtr<CSSValue> direction = nullptr;
    952     if (shouldPreserveWritingDirection == PreserveWritingDirection) {
    953         unicodeBidi = m_mutableStyle->getPropertyCSSValue(CSSPropertyUnicodeBidi);
    954         direction = m_mutableStyle->getPropertyCSSValue(CSSPropertyDirection);
    955     }
    956 
    957     m_mutableStyle->removeEquivalentProperties(styleAtPosition);
    958 
    959     if (textAlignResolvingStartAndEnd(m_mutableStyle.get()) == textAlignResolvingStartAndEnd(styleAtPosition))
    960         m_mutableStyle->removeProperty(CSSPropertyTextAlign);
    961 
    962     if (getRGBAFontColor(m_mutableStyle.get()) == getRGBAFontColor(styleAtPosition))
    963         m_mutableStyle->removeProperty(CSSPropertyColor);
    964 
    965     if (hasTransparentBackgroundColor(m_mutableStyle.get())
    966         || cssValueToRGBA(m_mutableStyle->getPropertyCSSValue(CSSPropertyBackgroundColor).get()) == rgbaBackgroundColorInEffect(position.containerNode()))
    967         m_mutableStyle->removeProperty(CSSPropertyBackgroundColor);
    968 
    969     if (unicodeBidi && unicodeBidi->isPrimitiveValue()) {
    970         m_mutableStyle->setProperty(CSSPropertyUnicodeBidi, toCSSPrimitiveValue(unicodeBidi.get())->getValueID());
    971         if (direction && direction->isPrimitiveValue())
    972             m_mutableStyle->setProperty(CSSPropertyDirection, toCSSPrimitiveValue(direction.get())->getValueID());
    973     }
    974 }
    975 
    976 void EditingStyle::mergeTypingStyle(Document* document)
    977 {
    978     ASSERT(document);
    979 
    980     RefPtrWillBeRawPtr<EditingStyle> typingStyle = document->frame()->selection().typingStyle();
    981     if (!typingStyle || typingStyle == this)
    982         return;
    983 
    984     mergeStyle(typingStyle->style(), OverrideValues);
    985 }
    986 
    987 void EditingStyle::mergeInlineStyleOfElement(Element* element, CSSPropertyOverrideMode mode, PropertiesToInclude propertiesToInclude)
    988 {
    989     ASSERT(element);
    990     if (!element->inlineStyle())
    991         return;
    992 
    993     switch (propertiesToInclude) {
    994     case AllProperties:
    995         mergeStyle(element->inlineStyle(), mode);
    996         return;
    997     case OnlyEditingInheritableProperties:
    998         mergeStyle(copyEditingProperties(element->inlineStyle(), OnlyInheritableEditingProperties).get(), mode);
    999         return;
   1000     case EditingPropertiesInEffect:
   1001         mergeStyle(copyEditingProperties(element->inlineStyle(), AllEditingProperties).get(), mode);
   1002         return;
   1003     }
   1004 }
   1005 
   1006 static inline bool elementMatchesAndPropertyIsNotInInlineStyleDecl(const HTMLElementEquivalent* equivalent, const Element* element,
   1007     EditingStyle::CSSPropertyOverrideMode mode, StylePropertySet* style)
   1008 {
   1009     return equivalent->matches(element) && (!element->inlineStyle() || !equivalent->propertyExistsInStyle(element->inlineStyle()))
   1010         && (mode == EditingStyle::OverrideValues || !equivalent->propertyExistsInStyle(style));
   1011 }
   1012 
   1013 static PassRefPtrWillBeRawPtr<MutableStylePropertySet> extractEditingProperties(const StylePropertySet* style, EditingStyle::PropertiesToInclude propertiesToInclude)
   1014 {
   1015     if (!style)
   1016         return nullptr;
   1017 
   1018     switch (propertiesToInclude) {
   1019     case EditingStyle::AllProperties:
   1020     case EditingStyle::EditingPropertiesInEffect:
   1021         return copyEditingProperties(style, AllEditingProperties);
   1022     case EditingStyle::OnlyEditingInheritableProperties:
   1023         return copyEditingProperties(style, OnlyInheritableEditingProperties);
   1024     }
   1025 
   1026     ASSERT_NOT_REACHED();
   1027     return nullptr;
   1028 }
   1029 
   1030 void EditingStyle::mergeInlineAndImplicitStyleOfElement(Element* element, CSSPropertyOverrideMode mode, PropertiesToInclude propertiesToInclude)
   1031 {
   1032     RefPtrWillBeRawPtr<EditingStyle> styleFromRules = EditingStyle::create();
   1033     styleFromRules->mergeStyleFromRulesForSerialization(element);
   1034     styleFromRules->m_mutableStyle = extractEditingProperties(styleFromRules->m_mutableStyle.get(), propertiesToInclude);
   1035     mergeStyle(styleFromRules->m_mutableStyle.get(), mode);
   1036 
   1037     mergeInlineStyleOfElement(element, mode, propertiesToInclude);
   1038 
   1039     const WillBeHeapVector<OwnPtrWillBeMember<HTMLElementEquivalent> >& elementEquivalents = htmlElementEquivalents();
   1040     for (size_t i = 0; i < elementEquivalents.size(); ++i) {
   1041         if (elementMatchesAndPropertyIsNotInInlineStyleDecl(elementEquivalents[i].get(), element, mode, m_mutableStyle.get()))
   1042             elementEquivalents[i]->addToStyle(element, this);
   1043     }
   1044 
   1045     const WillBeHeapVector<OwnPtrWillBeMember<HTMLAttributeEquivalent> >& attributeEquivalents = htmlAttributeEquivalents();
   1046     for (size_t i = 0; i < attributeEquivalents.size(); ++i) {
   1047         if (attributeEquivalents[i]->attributeName() == HTMLNames::dirAttr)
   1048             continue; // We don't want to include directionality
   1049         if (elementMatchesAndPropertyIsNotInInlineStyleDecl(attributeEquivalents[i].get(), element, mode, m_mutableStyle.get()))
   1050             attributeEquivalents[i]->addToStyle(element, this);
   1051     }
   1052 }
   1053 
   1054 PassRefPtrWillBeRawPtr<EditingStyle> EditingStyle::wrappingStyleForSerialization(Node* context, bool shouldAnnotate)
   1055 {
   1056     RefPtrWillBeRawPtr<EditingStyle> wrappingStyle = nullptr;
   1057     if (shouldAnnotate) {
   1058         wrappingStyle = EditingStyle::create(context, EditingStyle::EditingPropertiesInEffect);
   1059 
   1060         // Styles that Mail blockquotes contribute should only be placed on the Mail blockquote,
   1061         // to help us differentiate those styles from ones that the user has applied.
   1062         // This helps us get the color of content pasted into blockquotes right.
   1063         wrappingStyle->removeStyleAddedByNode(enclosingNodeOfType(firstPositionInOrBeforeNode(context), isMailBlockquote, CanCrossEditingBoundary));
   1064 
   1065         // Call collapseTextDecorationProperties first or otherwise it'll copy the value over from in-effect to text-decorations.
   1066         wrappingStyle->collapseTextDecorationProperties();
   1067 
   1068         return wrappingStyle.release();
   1069     }
   1070 
   1071     wrappingStyle = EditingStyle::create();
   1072 
   1073     // When not annotating for interchange, we only preserve inline style declarations.
   1074     for (Node* node = context; node && !node->isDocumentNode(); node = node->parentNode()) {
   1075         if (node->isStyledElement() && !isMailBlockquote(node)) {
   1076             wrappingStyle->mergeInlineAndImplicitStyleOfElement(toElement(node), EditingStyle::DoNotOverrideValues,
   1077                 EditingStyle::EditingPropertiesInEffect);
   1078         }
   1079     }
   1080 
   1081     return wrappingStyle.release();
   1082 }
   1083 
   1084 
   1085 static void mergeTextDecorationValues(CSSValueList* mergedValue, const CSSValueList* valueToMerge)
   1086 {
   1087 #if ENABLE_OILPAN
   1088     DEFINE_STATIC_LOCAL(Persistent<CSSPrimitiveValue>, underline, (CSSPrimitiveValue::createIdentifier(CSSValueUnderline)));
   1089     DEFINE_STATIC_LOCAL(Persistent<CSSPrimitiveValue>, lineThrough, (CSSPrimitiveValue::createIdentifier(CSSValueLineThrough)));
   1090     if (valueToMerge->hasValue(underline) && !mergedValue->hasValue(underline))
   1091         mergedValue->append(underline.get());
   1092 
   1093     if (valueToMerge->hasValue(lineThrough) && !mergedValue->hasValue(lineThrough))
   1094         mergedValue->append(lineThrough.get());
   1095 #else
   1096     DEFINE_STATIC_REF(CSSPrimitiveValue, underline, (CSSPrimitiveValue::createIdentifier(CSSValueUnderline)));
   1097     DEFINE_STATIC_REF(CSSPrimitiveValue, lineThrough, (CSSPrimitiveValue::createIdentifier(CSSValueLineThrough)));
   1098     if (valueToMerge->hasValue(underline) && !mergedValue->hasValue(underline))
   1099         mergedValue->append(underline);
   1100 
   1101     if (valueToMerge->hasValue(lineThrough) && !mergedValue->hasValue(lineThrough))
   1102         mergedValue->append(lineThrough);
   1103 #endif
   1104 }
   1105 
   1106 void EditingStyle::mergeStyle(const StylePropertySet* style, CSSPropertyOverrideMode mode)
   1107 {
   1108     if (!style)
   1109         return;
   1110 
   1111     if (!m_mutableStyle) {
   1112         m_mutableStyle = style->mutableCopy();
   1113         return;
   1114     }
   1115 
   1116     unsigned propertyCount = style->propertyCount();
   1117     for (unsigned i = 0; i < propertyCount; ++i) {
   1118         StylePropertySet::PropertyReference property = style->propertyAt(i);
   1119         RefPtrWillBeRawPtr<CSSValue> value = m_mutableStyle->getPropertyCSSValue(property.id());
   1120 
   1121         // text decorations never override values
   1122         if ((property.id() == textDecorationPropertyForEditing() || property.id() == CSSPropertyWebkitTextDecorationsInEffect) && property.value()->isValueList() && value) {
   1123             if (value->isValueList()) {
   1124                 mergeTextDecorationValues(toCSSValueList(value.get()), toCSSValueList(property.value()));
   1125                 continue;
   1126             }
   1127             value = nullptr; // text-decoration: none is equivalent to not having the property
   1128         }
   1129 
   1130         if (mode == OverrideValues || (mode == DoNotOverrideValues && !value))
   1131             m_mutableStyle->setProperty(property.id(), property.value()->cssText(), property.isImportant());
   1132     }
   1133 }
   1134 
   1135 static PassRefPtrWillBeRawPtr<MutableStylePropertySet> styleFromMatchedRulesForElement(Element* element, unsigned rulesToInclude)
   1136 {
   1137     RefPtrWillBeRawPtr<MutableStylePropertySet> style = MutableStylePropertySet::create();
   1138     RefPtrWillBeRawPtr<StyleRuleList> matchedRules = element->document().ensureStyleResolver().styleRulesForElement(element, rulesToInclude);
   1139     if (matchedRules) {
   1140         for (unsigned i = 0; i < matchedRules->m_list.size(); ++i)
   1141             style->mergeAndOverrideOnConflict(&matchedRules->m_list[i]->properties());
   1142     }
   1143     return style.release();
   1144 }
   1145 
   1146 void EditingStyle::mergeStyleFromRules(Element* element)
   1147 {
   1148     RefPtrWillBeRawPtr<MutableStylePropertySet> styleFromMatchedRules = styleFromMatchedRulesForElement(element,
   1149         StyleResolver::AuthorCSSRules | StyleResolver::CrossOriginCSSRules);
   1150     // Styles from the inline style declaration, held in the variable "style", take precedence
   1151     // over those from matched rules.
   1152     if (m_mutableStyle)
   1153         styleFromMatchedRules->mergeAndOverrideOnConflict(m_mutableStyle.get());
   1154 
   1155     clear();
   1156     m_mutableStyle = styleFromMatchedRules;
   1157 }
   1158 
   1159 void EditingStyle::mergeStyleFromRulesForSerialization(Element* element)
   1160 {
   1161     mergeStyleFromRules(element);
   1162 
   1163     // The property value, if it's a percentage, may not reflect the actual computed value.
   1164     // For example: style="height: 1%; overflow: visible;" in quirksmode
   1165     // FIXME: There are others like this, see <rdar://problem/5195123> Slashdot copy/paste fidelity problem
   1166     RefPtrWillBeRawPtr<CSSComputedStyleDeclaration> computedStyleForElement = CSSComputedStyleDeclaration::create(element);
   1167     RefPtrWillBeRawPtr<MutableStylePropertySet> fromComputedStyle = MutableStylePropertySet::create();
   1168     {
   1169         unsigned propertyCount = m_mutableStyle->propertyCount();
   1170         for (unsigned i = 0; i < propertyCount; ++i) {
   1171             StylePropertySet::PropertyReference property = m_mutableStyle->propertyAt(i);
   1172             CSSValue* value = property.value();
   1173             if (!value->isPrimitiveValue())
   1174                 continue;
   1175             if (toCSSPrimitiveValue(value)->isPercentage()) {
   1176                 if (RefPtrWillBeRawPtr<CSSValue> computedPropertyValue = computedStyleForElement->getPropertyCSSValue(property.id()))
   1177                     fromComputedStyle->addParsedProperty(CSSProperty(property.id(), computedPropertyValue));
   1178             }
   1179         }
   1180     }
   1181     m_mutableStyle->mergeAndOverrideOnConflict(fromComputedStyle.get());
   1182 }
   1183 
   1184 static void removePropertiesInStyle(MutableStylePropertySet* styleToRemovePropertiesFrom, StylePropertySet* style)
   1185 {
   1186     unsigned propertyCount = style->propertyCount();
   1187     Vector<CSSPropertyID> propertiesToRemove(propertyCount);
   1188     for (unsigned i = 0; i < propertyCount; ++i)
   1189         propertiesToRemove[i] = style->propertyAt(i).id();
   1190 
   1191     styleToRemovePropertiesFrom->removePropertiesInSet(propertiesToRemove.data(), propertiesToRemove.size());
   1192 }
   1193 
   1194 void EditingStyle::removeStyleFromRulesAndContext(Element* element, Node* context)
   1195 {
   1196     ASSERT(element);
   1197     if (!m_mutableStyle)
   1198         return;
   1199 
   1200     // 1. Remove style from matched rules because style remain without repeating it in inline style declaration
   1201     RefPtrWillBeRawPtr<MutableStylePropertySet> styleFromMatchedRules = styleFromMatchedRulesForElement(element, StyleResolver::AllButEmptyCSSRules);
   1202     if (styleFromMatchedRules && !styleFromMatchedRules->isEmpty())
   1203         m_mutableStyle = getPropertiesNotIn(m_mutableStyle.get(), styleFromMatchedRules->ensureCSSStyleDeclaration());
   1204 
   1205     // 2. Remove style present in context and not overriden by matched rules.
   1206     RefPtrWillBeRawPtr<EditingStyle> computedStyle = EditingStyle::create(context, EditingPropertiesInEffect);
   1207     if (computedStyle->m_mutableStyle) {
   1208         if (!computedStyle->m_mutableStyle->getPropertyCSSValue(CSSPropertyBackgroundColor))
   1209             computedStyle->m_mutableStyle->setProperty(CSSPropertyBackgroundColor, CSSValueTransparent);
   1210 
   1211         removePropertiesInStyle(computedStyle->m_mutableStyle.get(), styleFromMatchedRules.get());
   1212         m_mutableStyle = getPropertiesNotIn(m_mutableStyle.get(), computedStyle->m_mutableStyle->ensureCSSStyleDeclaration());
   1213     }
   1214 
   1215     // 3. If this element is a span and has display: inline or float: none, remove them unless they are overriden by rules.
   1216     // These rules are added by serialization code to wrap text nodes.
   1217     if (isStyleSpanOrSpanWithOnlyStyleAttribute(element)) {
   1218         if (!styleFromMatchedRules->getPropertyCSSValue(CSSPropertyDisplay) && getIdentifierValue(m_mutableStyle.get(), CSSPropertyDisplay) == CSSValueInline)
   1219             m_mutableStyle->removeProperty(CSSPropertyDisplay);
   1220         if (!styleFromMatchedRules->getPropertyCSSValue(CSSPropertyFloat) && getIdentifierValue(m_mutableStyle.get(), CSSPropertyFloat) == CSSValueNone)
   1221             m_mutableStyle->removeProperty(CSSPropertyFloat);
   1222     }
   1223 }
   1224 
   1225 void EditingStyle::removePropertiesInElementDefaultStyle(Element* element)
   1226 {
   1227     if (!m_mutableStyle || m_mutableStyle->isEmpty())
   1228         return;
   1229 
   1230     RefPtr<StylePropertySet> defaultStyle = styleFromMatchedRulesForElement(element, StyleResolver::UAAndUserCSSRules);
   1231 
   1232     removePropertiesInStyle(m_mutableStyle.get(), defaultStyle.get());
   1233 }
   1234 
   1235 void EditingStyle::forceInline()
   1236 {
   1237     if (!m_mutableStyle)
   1238         m_mutableStyle = MutableStylePropertySet::create();
   1239     const bool propertyIsImportant = true;
   1240     m_mutableStyle->setProperty(CSSPropertyDisplay, CSSValueInline, propertyIsImportant);
   1241 }
   1242 
   1243 int EditingStyle::legacyFontSize(Document* document) const
   1244 {
   1245     RefPtrWillBeRawPtr<CSSValue> cssValue = m_mutableStyle->getPropertyCSSValue(CSSPropertyFontSize);
   1246     if (!cssValue || !cssValue->isPrimitiveValue())
   1247         return 0;
   1248     return legacyFontSizeFromCSSValue(document, toCSSPrimitiveValue(cssValue.get()),
   1249         m_shouldUseFixedDefaultFontSize, AlwaysUseLegacyFontSize);
   1250 }
   1251 
   1252 PassRefPtrWillBeRawPtr<EditingStyle> EditingStyle::styleAtSelectionStart(const VisibleSelection& selection, bool shouldUseBackgroundColorInEffect)
   1253 {
   1254     if (selection.isNone())
   1255         return nullptr;
   1256 
   1257     Position position = adjustedSelectionStartForStyleComputation(selection);
   1258 
   1259     // If the pos is at the end of a text node, then this node is not fully selected.
   1260     // Move it to the next deep equivalent position to avoid removing the style from this node.
   1261     // e.g. if pos was at Position("hello", 5) in <b>hello<div>world</div></b>, we want Position("world", 0) instead.
   1262     // We only do this for range because caret at Position("hello", 5) in <b>hello</b>world should give you font-weight: bold.
   1263     Node* positionNode = position.containerNode();
   1264     if (selection.isRange() && positionNode && positionNode->isTextNode() && position.computeOffsetInContainerNode() == positionNode->maxCharacterOffset())
   1265         position = nextVisuallyDistinctCandidate(position);
   1266 
   1267     Element* element = position.element();
   1268     if (!element)
   1269         return nullptr;
   1270 
   1271     RefPtrWillBeRawPtr<EditingStyle> style = EditingStyle::create(element, EditingStyle::AllProperties);
   1272     style->mergeTypingStyle(&element->document());
   1273 
   1274     // If background color is transparent, traverse parent nodes until we hit a different value or document root
   1275     // Also, if the selection is a range, ignore the background color at the start of selection,
   1276     // and find the background color of the common ancestor.
   1277     if (shouldUseBackgroundColorInEffect && (selection.isRange() || hasTransparentBackgroundColor(style->m_mutableStyle.get()))) {
   1278         RefPtrWillBeRawPtr<Range> range(selection.toNormalizedRange());
   1279         if (PassRefPtrWillBeRawPtr<CSSValue> value = backgroundColorInEffect(range->commonAncestorContainer()))
   1280             style->setProperty(CSSPropertyBackgroundColor, value->cssText());
   1281     }
   1282 
   1283     return style;
   1284 }
   1285 
   1286 WritingDirection EditingStyle::textDirectionForSelection(const VisibleSelection& selection, EditingStyle* typingStyle, bool& hasNestedOrMultipleEmbeddings)
   1287 {
   1288     hasNestedOrMultipleEmbeddings = true;
   1289 
   1290     if (selection.isNone())
   1291         return NaturalWritingDirection;
   1292 
   1293     Position position = selection.start().downstream();
   1294 
   1295     Node* node = position.deprecatedNode();
   1296     if (!node)
   1297         return NaturalWritingDirection;
   1298 
   1299     Position end;
   1300     if (selection.isRange()) {
   1301         end = selection.end().upstream();
   1302 
   1303         ASSERT(end.document());
   1304         Node* pastLast = Range::create(*end.document(), position.parentAnchoredEquivalent(), end.parentAnchoredEquivalent())->pastLastNode();
   1305         for (Node* n = node; n && n != pastLast; n = NodeTraversal::next(*n)) {
   1306             if (!n->isStyledElement())
   1307                 continue;
   1308 
   1309             RefPtrWillBeRawPtr<CSSComputedStyleDeclaration> style = CSSComputedStyleDeclaration::create(n);
   1310             RefPtrWillBeRawPtr<CSSValue> unicodeBidi = style->getPropertyCSSValue(CSSPropertyUnicodeBidi);
   1311             if (!unicodeBidi || !unicodeBidi->isPrimitiveValue())
   1312                 continue;
   1313 
   1314             CSSValueID unicodeBidiValue = toCSSPrimitiveValue(unicodeBidi.get())->getValueID();
   1315             if (unicodeBidiValue == CSSValueEmbed || unicodeBidiValue == CSSValueBidiOverride)
   1316                 return NaturalWritingDirection;
   1317         }
   1318     }
   1319 
   1320     if (selection.isCaret()) {
   1321         WritingDirection direction;
   1322         if (typingStyle && typingStyle->textDirection(direction)) {
   1323             hasNestedOrMultipleEmbeddings = false;
   1324             return direction;
   1325         }
   1326         node = selection.visibleStart().deepEquivalent().deprecatedNode();
   1327     }
   1328 
   1329     // The selection is either a caret with no typing attributes or a range in which no embedding is added, so just use the start position
   1330     // to decide.
   1331     Node* block = enclosingBlock(node);
   1332     WritingDirection foundDirection = NaturalWritingDirection;
   1333 
   1334     for (; node != block; node = node->parentNode()) {
   1335         if (!node->isStyledElement())
   1336             continue;
   1337 
   1338         RefPtrWillBeRawPtr<CSSComputedStyleDeclaration> style = CSSComputedStyleDeclaration::create(node);
   1339         RefPtrWillBeRawPtr<CSSValue> unicodeBidi = style->getPropertyCSSValue(CSSPropertyUnicodeBidi);
   1340         if (!unicodeBidi || !unicodeBidi->isPrimitiveValue())
   1341             continue;
   1342 
   1343         CSSValueID unicodeBidiValue = toCSSPrimitiveValue(unicodeBidi.get())->getValueID();
   1344         if (unicodeBidiValue == CSSValueNormal)
   1345             continue;
   1346 
   1347         if (unicodeBidiValue == CSSValueBidiOverride)
   1348             return NaturalWritingDirection;
   1349 
   1350         ASSERT(unicodeBidiValue == CSSValueEmbed);
   1351         RefPtrWillBeRawPtr<CSSValue> direction = style->getPropertyCSSValue(CSSPropertyDirection);
   1352         if (!direction || !direction->isPrimitiveValue())
   1353             continue;
   1354 
   1355         int directionValue = toCSSPrimitiveValue(direction.get())->getValueID();
   1356         if (directionValue != CSSValueLtr && directionValue != CSSValueRtl)
   1357             continue;
   1358 
   1359         if (foundDirection != NaturalWritingDirection)
   1360             return NaturalWritingDirection;
   1361 
   1362         // In the range case, make sure that the embedding element persists until the end of the range.
   1363         if (selection.isRange() && !end.deprecatedNode()->isDescendantOf(node))
   1364             return NaturalWritingDirection;
   1365 
   1366         foundDirection = directionValue == CSSValueLtr ? LeftToRightWritingDirection : RightToLeftWritingDirection;
   1367     }
   1368     hasNestedOrMultipleEmbeddings = false;
   1369     return foundDirection;
   1370 }
   1371 
   1372 void EditingStyle::trace(Visitor* visitor)
   1373 {
   1374     visitor->trace(m_mutableStyle);
   1375 }
   1376 
   1377 static void reconcileTextDecorationProperties(MutableStylePropertySet* style)
   1378 {
   1379     RefPtrWillBeRawPtr<CSSValue> textDecorationsInEffect = style->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);
   1380     RefPtrWillBeRawPtr<CSSValue> textDecoration = style->getPropertyCSSValue(textDecorationPropertyForEditing());
   1381     // We shouldn't have both text-decoration and -webkit-text-decorations-in-effect because that wouldn't make sense.
   1382     ASSERT(!textDecorationsInEffect || !textDecoration);
   1383     if (textDecorationsInEffect) {
   1384         style->setProperty(textDecorationPropertyForEditing(), textDecorationsInEffect->cssText());
   1385         style->removeProperty(CSSPropertyWebkitTextDecorationsInEffect);
   1386         textDecoration = textDecorationsInEffect;
   1387     }
   1388 
   1389     // If text-decoration is set to "none", remove the property because we don't want to add redundant "text-decoration: none".
   1390     if (textDecoration && !textDecoration->isValueList())
   1391         style->removeProperty(textDecorationPropertyForEditing());
   1392 }
   1393 
   1394 StyleChange::StyleChange(EditingStyle* style, const Position& position)
   1395     : m_applyBold(false)
   1396     , m_applyItalic(false)
   1397     , m_applyUnderline(false)
   1398     , m_applyLineThrough(false)
   1399     , m_applySubscript(false)
   1400     , m_applySuperscript(false)
   1401 {
   1402     Document* document = position.document();
   1403     if (!style || !style->style() || !document || !document->frame())
   1404         return;
   1405 
   1406     RefPtrWillBeRawPtr<CSSComputedStyleDeclaration> computedStyle = position.computedStyle();
   1407     // FIXME: take care of background-color in effect
   1408     RefPtrWillBeRawPtr<MutableStylePropertySet> mutableStyle = getPropertiesNotIn(style->style(), computedStyle.get());
   1409 
   1410     reconcileTextDecorationProperties(mutableStyle.get());
   1411     if (!document->frame()->editor().shouldStyleWithCSS())
   1412         extractTextStyles(document, mutableStyle.get(), computedStyle->useFixedFontDefaultSize());
   1413 
   1414     // Changing the whitespace style in a tab span would collapse the tab into a space.
   1415     if (isTabSpanTextNode(position.deprecatedNode()) || isTabSpanNode((position.deprecatedNode())))
   1416         mutableStyle->removeProperty(CSSPropertyWhiteSpace);
   1417 
   1418     // If unicode-bidi is present in mutableStyle and direction is not, then add direction to mutableStyle.
   1419     // FIXME: Shouldn't this be done in getPropertiesNotIn?
   1420     if (mutableStyle->getPropertyCSSValue(CSSPropertyUnicodeBidi) && !style->style()->getPropertyCSSValue(CSSPropertyDirection))
   1421         mutableStyle->setProperty(CSSPropertyDirection, style->style()->getPropertyValue(CSSPropertyDirection));
   1422 
   1423     // Save the result for later
   1424     m_cssStyle = mutableStyle->asText().stripWhiteSpace();
   1425 }
   1426 
   1427 static void setTextDecorationProperty(MutableStylePropertySet* style, const CSSValueList* newTextDecoration, CSSPropertyID propertyID)
   1428 {
   1429     if (newTextDecoration->length())
   1430         style->setProperty(propertyID, newTextDecoration->cssText(), style->propertyIsImportant(propertyID));
   1431     else {
   1432         // text-decoration: none is redundant since it does not remove any text decorations.
   1433         style->removeProperty(propertyID);
   1434     }
   1435 }
   1436 
   1437 void StyleChange::extractTextStyles(Document* document, MutableStylePropertySet* style, bool shouldUseFixedFontDefaultSize)
   1438 {
   1439     ASSERT(style);
   1440 
   1441     if (getIdentifierValue(style, CSSPropertyFontWeight) == CSSValueBold) {
   1442         style->removeProperty(CSSPropertyFontWeight);
   1443         m_applyBold = true;
   1444     }
   1445 
   1446     int fontStyle = getIdentifierValue(style, CSSPropertyFontStyle);
   1447     if (fontStyle == CSSValueItalic || fontStyle == CSSValueOblique) {
   1448         style->removeProperty(CSSPropertyFontStyle);
   1449         m_applyItalic = true;
   1450     }
   1451 
   1452     // Assuming reconcileTextDecorationProperties has been called, there should not be -webkit-text-decorations-in-effect
   1453     // Furthermore, text-decoration: none has been trimmed so that text-decoration property is always a CSSValueList.
   1454     RefPtrWillBeRawPtr<CSSValue> textDecoration = style->getPropertyCSSValue(textDecorationPropertyForEditing());
   1455     if (textDecoration && textDecoration->isValueList()) {
   1456 #if ENABLE(OILPAN)
   1457         DEFINE_STATIC_LOCAL(Persistent<CSSPrimitiveValue>, underline, (CSSPrimitiveValue::createIdentifier(CSSValueUnderline)));
   1458         DEFINE_STATIC_LOCAL(Persistent<CSSPrimitiveValue>, lineThrough, (CSSPrimitiveValue::createIdentifier(CSSValueLineThrough)));
   1459 #else
   1460         DEFINE_STATIC_REF(CSSPrimitiveValue, underline, (CSSPrimitiveValue::createIdentifier(CSSValueUnderline)));
   1461         DEFINE_STATIC_REF(CSSPrimitiveValue, lineThrough, (CSSPrimitiveValue::createIdentifier(CSSValueLineThrough)));
   1462 #endif
   1463         RefPtrWillBeRawPtr<CSSValueList> newTextDecoration = toCSSValueList(textDecoration.get())->copy();
   1464         if (newTextDecoration->removeAll(underline))
   1465             m_applyUnderline = true;
   1466         if (newTextDecoration->removeAll(lineThrough))
   1467             m_applyLineThrough = true;
   1468 
   1469         // If trimTextDecorations, delete underline and line-through
   1470         setTextDecorationProperty(style, newTextDecoration.get(), textDecorationPropertyForEditing());
   1471     }
   1472 
   1473     int verticalAlign = getIdentifierValue(style, CSSPropertyVerticalAlign);
   1474     switch (verticalAlign) {
   1475     case CSSValueSub:
   1476         style->removeProperty(CSSPropertyVerticalAlign);
   1477         m_applySubscript = true;
   1478         break;
   1479     case CSSValueSuper:
   1480         style->removeProperty(CSSPropertyVerticalAlign);
   1481         m_applySuperscript = true;
   1482         break;
   1483     }
   1484 
   1485     if (style->getPropertyCSSValue(CSSPropertyColor)) {
   1486         m_applyFontColor = Color(getRGBAFontColor(style)).serialized();
   1487         style->removeProperty(CSSPropertyColor);
   1488     }
   1489 
   1490     m_applyFontFace = style->getPropertyValue(CSSPropertyFontFamily);
   1491     // Remove single quotes for Outlook 2007 compatibility. See https://bugs.webkit.org/show_bug.cgi?id=79448
   1492     m_applyFontFace.replaceWithLiteral('\'', "");
   1493     style->removeProperty(CSSPropertyFontFamily);
   1494 
   1495     if (RefPtrWillBeRawPtr<CSSValue> fontSize = style->getPropertyCSSValue(CSSPropertyFontSize)) {
   1496         if (!fontSize->isPrimitiveValue())
   1497             style->removeProperty(CSSPropertyFontSize); // Can't make sense of the number. Put no font size.
   1498         else if (int legacyFontSize = legacyFontSizeFromCSSValue(document, toCSSPrimitiveValue(fontSize.get()),
   1499                 shouldUseFixedFontDefaultSize, UseLegacyFontSizeOnlyIfPixelValuesMatch)) {
   1500             m_applyFontSize = String::number(legacyFontSize);
   1501             style->removeProperty(CSSPropertyFontSize);
   1502         }
   1503     }
   1504 }
   1505 
   1506 static void diffTextDecorations(MutableStylePropertySet* style, CSSPropertyID propertID, CSSValue* refTextDecoration)
   1507 {
   1508     RefPtrWillBeRawPtr<CSSValue> textDecoration = style->getPropertyCSSValue(propertID);
   1509     if (!textDecoration || !textDecoration->isValueList() || !refTextDecoration || !refTextDecoration->isValueList())
   1510         return;
   1511 
   1512     RefPtrWillBeRawPtr<CSSValueList> newTextDecoration = toCSSValueList(textDecoration.get())->copy();
   1513     CSSValueList* valuesInRefTextDecoration = toCSSValueList(refTextDecoration);
   1514 
   1515     for (size_t i = 0; i < valuesInRefTextDecoration->length(); i++)
   1516         newTextDecoration->removeAll(valuesInRefTextDecoration->item(i));
   1517 
   1518     setTextDecorationProperty(style, newTextDecoration.get(), propertID);
   1519 }
   1520 
   1521 static bool fontWeightIsBold(CSSValue* fontWeight)
   1522 {
   1523     if (!fontWeight->isPrimitiveValue())
   1524         return false;
   1525 
   1526     // Because b tag can only bold text, there are only two states in plain html: bold and not bold.
   1527     // Collapse all other values to either one of these two states for editing purposes.
   1528     switch (toCSSPrimitiveValue(fontWeight)->getValueID()) {
   1529         case CSSValue100:
   1530         case CSSValue200:
   1531         case CSSValue300:
   1532         case CSSValue400:
   1533         case CSSValue500:
   1534         case CSSValueNormal:
   1535             return false;
   1536         case CSSValueBold:
   1537         case CSSValue600:
   1538         case CSSValue700:
   1539         case CSSValue800:
   1540         case CSSValue900:
   1541             return true;
   1542         default:
   1543             break;
   1544     }
   1545 
   1546     ASSERT_NOT_REACHED(); // For CSSValueBolder and CSSValueLighter
   1547     return false;
   1548 }
   1549 
   1550 static bool fontWeightNeedsResolving(CSSValue* fontWeight)
   1551 {
   1552     if (!fontWeight->isPrimitiveValue())
   1553         return true;
   1554 
   1555     CSSValueID value = toCSSPrimitiveValue(fontWeight)->getValueID();
   1556     return value == CSSValueLighter || value == CSSValueBolder;
   1557 }
   1558 
   1559 PassRefPtrWillBeRawPtr<MutableStylePropertySet> getPropertiesNotIn(StylePropertySet* styleWithRedundantProperties, CSSStyleDeclaration* baseStyle)
   1560 {
   1561     ASSERT(styleWithRedundantProperties);
   1562     ASSERT(baseStyle);
   1563     RefPtrWillBeRawPtr<MutableStylePropertySet> result = styleWithRedundantProperties->mutableCopy();
   1564 
   1565     result->removeEquivalentProperties(baseStyle);
   1566 
   1567     RefPtrWillBeRawPtr<CSSValue> baseTextDecorationsInEffect = baseStyle->getPropertyCSSValueInternal(CSSPropertyWebkitTextDecorationsInEffect);
   1568     diffTextDecorations(result.get(), textDecorationPropertyForEditing(), baseTextDecorationsInEffect.get());
   1569     diffTextDecorations(result.get(), CSSPropertyWebkitTextDecorationsInEffect, baseTextDecorationsInEffect.get());
   1570 
   1571     if (RefPtrWillBeRawPtr<CSSValue> baseFontWeight = baseStyle->getPropertyCSSValueInternal(CSSPropertyFontWeight)) {
   1572         if (RefPtrWillBeRawPtr<CSSValue> fontWeight = result->getPropertyCSSValue(CSSPropertyFontWeight)) {
   1573             if (!fontWeightNeedsResolving(fontWeight.get()) && (fontWeightIsBold(fontWeight.get()) == fontWeightIsBold(baseFontWeight.get())))
   1574                 result->removeProperty(CSSPropertyFontWeight);
   1575         }
   1576     }
   1577 
   1578     if (baseStyle->getPropertyCSSValueInternal(CSSPropertyColor) && getRGBAFontColor(result.get()) == getRGBAFontColor(baseStyle))
   1579         result->removeProperty(CSSPropertyColor);
   1580 
   1581     if (baseStyle->getPropertyCSSValueInternal(CSSPropertyTextAlign)
   1582         && textAlignResolvingStartAndEnd(result.get()) == textAlignResolvingStartAndEnd(baseStyle))
   1583         result->removeProperty(CSSPropertyTextAlign);
   1584 
   1585     if (baseStyle->getPropertyCSSValueInternal(CSSPropertyBackgroundColor) && getRGBABackgroundColor(result.get()) == getRGBABackgroundColor(baseStyle))
   1586         result->removeProperty(CSSPropertyBackgroundColor);
   1587 
   1588     return result.release();
   1589 }
   1590 
   1591 CSSValueID getIdentifierValue(StylePropertySet* style, CSSPropertyID propertyID)
   1592 {
   1593     if (!style)
   1594         return CSSValueInvalid;
   1595     RefPtrWillBeRawPtr<CSSValue> value = style->getPropertyCSSValue(propertyID);
   1596     if (!value || !value->isPrimitiveValue())
   1597         return CSSValueInvalid;
   1598     return toCSSPrimitiveValue(value.get())->getValueID();
   1599 }
   1600 
   1601 CSSValueID getIdentifierValue(CSSStyleDeclaration* style, CSSPropertyID propertyID)
   1602 {
   1603     if (!style)
   1604         return CSSValueInvalid;
   1605     RefPtrWillBeRawPtr<CSSValue> value = style->getPropertyCSSValueInternal(propertyID);
   1606     if (!value || !value->isPrimitiveValue())
   1607         return CSSValueInvalid;
   1608     return toCSSPrimitiveValue(value.get())->getValueID();
   1609 }
   1610 
   1611 static bool isCSSValueLength(CSSPrimitiveValue* value)
   1612 {
   1613     return value->isFontIndependentLength();
   1614 }
   1615 
   1616 int legacyFontSizeFromCSSValue(Document* document, CSSPrimitiveValue* value, bool shouldUseFixedFontDefaultSize, LegacyFontSizeMode mode)
   1617 {
   1618     if (isCSSValueLength(value)) {
   1619         int pixelFontSize = value->getIntValue(CSSPrimitiveValue::CSS_PX);
   1620         int legacyFontSize = FontSize::legacyFontSize(document, pixelFontSize, shouldUseFixedFontDefaultSize);
   1621         // Use legacy font size only if pixel value matches exactly to that of legacy font size.
   1622         int cssPrimitiveEquivalent = legacyFontSize - 1 + CSSValueXSmall;
   1623         if (mode == AlwaysUseLegacyFontSize || FontSize::fontSizeForKeyword(document, cssPrimitiveEquivalent, shouldUseFixedFontDefaultSize) == pixelFontSize)
   1624             return legacyFontSize;
   1625 
   1626         return 0;
   1627     }
   1628 
   1629     if (CSSValueXSmall <= value->getValueID() && value->getValueID() <= CSSValueWebkitXxxLarge)
   1630         return value->getValueID() - CSSValueXSmall + 1;
   1631 
   1632     return 0;
   1633 }
   1634 
   1635 bool isTransparentColorValue(CSSValue* cssValue)
   1636 {
   1637     if (!cssValue)
   1638         return true;
   1639     if (!cssValue->isPrimitiveValue())
   1640         return false;
   1641     CSSPrimitiveValue* value = toCSSPrimitiveValue(cssValue);
   1642     if (value->isRGBColor())
   1643         return !alphaChannel(value->getRGBA32Value());
   1644     return value->getValueID() == CSSValueTransparent;
   1645 }
   1646 
   1647 bool hasTransparentBackgroundColor(CSSStyleDeclaration* style)
   1648 {
   1649     RefPtrWillBeRawPtr<CSSValue> cssValue = style->getPropertyCSSValueInternal(CSSPropertyBackgroundColor);
   1650     return isTransparentColorValue(cssValue.get());
   1651 }
   1652 
   1653 bool hasTransparentBackgroundColor(StylePropertySet* style)
   1654 {
   1655     RefPtrWillBeRawPtr<CSSValue> cssValue = style->getPropertyCSSValue(CSSPropertyBackgroundColor);
   1656     return isTransparentColorValue(cssValue.get());
   1657 }
   1658 
   1659 PassRefPtrWillBeRawPtr<CSSValue> backgroundColorInEffect(Node* node)
   1660 {
   1661     for (Node* ancestor = node; ancestor; ancestor = ancestor->parentNode()) {
   1662         RefPtrWillBeRawPtr<CSSComputedStyleDeclaration> ancestorStyle = CSSComputedStyleDeclaration::create(ancestor);
   1663         if (!hasTransparentBackgroundColor(ancestorStyle.get()))
   1664             return ancestorStyle->getPropertyCSSValue(CSSPropertyBackgroundColor);
   1665     }
   1666     return nullptr;
   1667 }
   1668 
   1669 }
   1670