Use tighter typing in editing: EditingStyle

Source/core/editing/EditingStyle.h

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 32 matching lines @@
 #include "wtf/TriState.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 class CSSStyleDeclaration;
 class CSSComputedStyleDeclaration;
 class CSSPrimitiveValue;
 class CSSValue;
+class ContainerNode;
 class Document;
 class Element;
 class HTMLElement;
 class MutableStylePropertySet;
 class Node;
 class Position;
 class QualifiedName;
 class RenderStyle;
 class StylePropertySet;
 class VisibleSelection;
 
 class EditingStyle FINAL : public RefCountedWillBeGarbageCollectedFinalized<EditingStyle> {
 public:
 
     enum PropertiesToInclude { AllProperties, OnlyEditingInheritableProperties, EditingPropertiesInEffect };
     enum ShouldPreserveWritingDirection { PreserveWritingDirection, DoNotPreserveWritingDirection };
     enum ShouldExtractMatchingStyle { ExtractMatchingStyle, DoNotExtractMatchingStyle };
     static float NoFontDelta;
 
     static PassRefPtrWillBeRawPtr<EditingStyle> create()
     {
         return adoptRefWillBeNoop(new EditingStyle());
     }
 
-    static PassRefPtrWillBeRawPtr<EditingStyle> create(Node* node, PropertiesToInclude propertiesToInclude = OnlyEditingInheritableProperties)
+    static PassRefPtrWillBeRawPtr<EditingStyle> create(ContainerNode* node, PropertiesToInclude propertiesToInclude = OnlyEditingInheritableProperties)
     {
         return adoptRefWillBeNoop(new EditingStyle(node, propertiesToInclude));
     }
 
     static PassRefPtrWillBeRawPtr<EditingStyle> create(const Position& position, PropertiesToInclude propertiesToInclude = OnlyEditingInheritableProperties)
     {
         return adoptRefWillBeNoop(new EditingStyle(position, propertiesToInclude));
     }
 
     static PassRefPtrWillBeRawPtr<EditingStyle> create(const StylePropertySet* style)
@@ skipping 10 matching lines @@
 
     MutableStylePropertySet* style() { return m_mutableStyle.get(); }
     bool textDirection(WritingDirection&) const;
     bool isEmpty() const;
     void overrideWithStyle(const StylePropertySet*);
     void clear();
     PassRefPtrWillBeRawPtr<EditingStyle> copy() const;
     PassRefPtrWillBeRawPtr<EditingStyle> extractAndRemoveBlockProperties();
     PassRefPtrWillBeRawPtr<EditingStyle> extractAndRemoveTextDirection();
     void removeBlockProperties();
-    void removeStyleAddedByNode(Node*);
-    void removeStyleConflictingWithStyleOfNode(Node*);
+    void removeStyleAddedByElement(Element*);
+    void removeStyleConflictingWithStyleOfElement(Element*);
     void collapseTextDecorationProperties();
     enum ShouldIgnoreTextOnlyProperties { IgnoreTextOnlyProperties, DoNotIgnoreTextOnlyProperties };
     TriState triStateOfStyle(EditingStyle*) const;
     TriState triStateOfStyle(const VisibleSelection&) const;
-    bool conflictsWithInlineStyleOfElement(Element* element) const { return conflictsWithInlineStyleOfElement(element, 0, 0); }
-    bool conflictsWithInlineStyleOfElement(Element* element, EditingStyle* extractedStyle, Vector<CSSPropertyID>& conflictingProperties) const
+    bool conflictsWithInlineStyleOfElement(HTMLElement* element) const { return conflictsWithInlineStyleOfElement(element, 0, 0); }
+    bool conflictsWithInlineStyleOfElement(HTMLElement* element, EditingStyle* extractedStyle, Vector<CSSPropertyID>& conflictingProperties) const
     {
         return conflictsWithInlineStyleOfElement(element, extractedStyle, &conflictingProperties);
     }
     bool conflictsWithImplicitStyleOfElement(HTMLElement*, EditingStyle* extractedStyle = 0, ShouldExtractMatchingStyle = DoNotExtractMatchingStyle) const;
     bool conflictsWithImplicitStyleOfAttributes(HTMLElement*) const;
     bool extractConflictingImplicitStyleOfAttributes(HTMLElement*, ShouldPreserveWritingDirection, EditingStyle* extractedStyle,
             Vector<QualifiedName>& conflictingAttributes, ShouldExtractMatchingStyle) const;
     bool styleIsPresentInComputedStyleOfNode(Node*) const;
 
     static bool elementIsStyledSpanOrHTMLEquivalent(const HTMLElement*);
 
     void prepareToApplyAt(const Position&, ShouldPreserveWritingDirection = DoNotPreserveWritingDirection);
     void mergeTypingStyle(Document*);
     enum CSSPropertyOverrideMode { OverrideValues, DoNotOverrideValues };
-    void mergeInlineStyleOfElement(Element*, CSSPropertyOverrideMode, PropertiesToInclude = AllProperties);
-    static PassRefPtrWillBeRawPtr<EditingStyle> wrappingStyleForSerialization(Node* context, bool shouldAnnotate);
+    void mergeInlineStyleOfElement(HTMLElement*, CSSPropertyOverrideMode, PropertiesToInclude = AllProperties);
+    static PassRefPtrWillBeRawPtr<EditingStyle> wrappingStyleForSerialization(ContainerNode* context, bool shouldAnnotate);
     void mergeStyleFromRules(Element*);
     void mergeStyleFromRulesForSerialization(Element*);
-    void removeStyleFromRulesAndContext(Element*, Node* context);
+    void removeStyleFromRulesAndContext(Element*, ContainerNode* context);
     void removePropertiesInElementDefaultStyle(Element*);
     void addAbsolutePositioningFromElement(const Element&);
     void forceInline();
     int legacyFontSize(Document*) const;
 
     float fontSizeDelta() const { return m_fontSizeDelta; }
     bool hasFontSizeDelta() const { return m_fontSizeDelta != NoFontDelta; }
 
     static PassRefPtrWillBeRawPtr<EditingStyle> styleAtSelectionStart(const VisibleSelection&, bool shouldUseBackgroundColorInEffect = false);
     static WritingDirection textDirectionForSelection(const VisibleSelection&, EditingStyle* typingStyle, bool& hasNestedOrMultipleEmbeddings);
 
     void trace(Visitor*);
 
 private:
     EditingStyle();
-    EditingStyle(Node*, PropertiesToInclude);
+    EditingStyle(ContainerNode*, PropertiesToInclude);
     EditingStyle(const Position&, PropertiesToInclude);
     explicit EditingStyle(const StylePropertySet*);
     EditingStyle(CSSPropertyID, const String& value);
     void init(Node*, PropertiesToInclude);
     void removeTextFillAndStrokeColorsIfNeeded(RenderStyle*);
     void setProperty(CSSPropertyID, const String& value, bool important = false);
     void replaceFontSizeByKeywordIfPossible(RenderStyle*, CSSComputedStyleDeclaration*);
     void extractFontSizeDelta();
     TriState triStateOfStyle(CSSStyleDeclaration* styleToCompare, ShouldIgnoreTextOnlyProperties) const;
-    bool conflictsWithInlineStyleOfElement(Element*, EditingStyle* extractedStyle, Vector<CSSPropertyID>* conflictingProperties) const;
+    bool conflictsWithInlineStyleOfElement(HTMLElement*, EditingStyle* extractedStyle, Vector<CSSPropertyID>* conflictingProperties) const;

[eseidel, 2014/07/26 21:19:15]

Again, this clearly assumes non-SVG content?  It's possible to have SVG content
inside HTML as well...

[leviw_travelin_and_unemployed, 2014/07/29 21:59:18]

From what I can tell, the only tests covering editing SVG are to test for
assertions. I'm not opposed strengthening this typing if it's both the only way
it's currently used, and (more importantly) the only way we test it for the time
being.

     void mergeInlineAndImplicitStyleOfElement(Element*, CSSPropertyOverrideMode, PropertiesToInclude);
     void mergeStyle(const StylePropertySet*, CSSPropertyOverrideMode);
 
     RefPtrWillBeMember<MutableStylePropertySet> m_mutableStyle;
     FixedPitchFontType m_fixedPitchFontType;
     float m_fontSizeDelta;
 
     friend class HTMLElementEquivalent;
     friend class HTMLAttributeEquivalent;
 };
@@ skipping 58 matching lines @@
     String m_applyFontSize;
 };
 
 // FIXME: Remove these functions or make them non-global to discourage using CSSStyleDeclaration directly.
 CSSValueID getIdentifierValue(CSSStyleDeclaration*, CSSPropertyID);
 CSSValueID getIdentifierValue(StylePropertySet*, CSSPropertyID);
 
 } // namespace blink
 
 #endif // EditingStyle_h