Move StyleResolver and related classes to core/css/resolver

Source/core/css/resolver/StyleResolver.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  */
 
 #include "config.h"
-#include "core/css/StyleResolver.h"
+#include "core/css/resolver/StyleResolver.h"
 
 #include "CSSPropertyNames.h"
 #include "HTMLNames.h"
 #include "MathMLNames.h"
 #include "RuntimeEnabledFeatures.h"
 #include "UserAgentStyleSheets.h"
 #include "WebKitFontFamilyNames.h"
 #include "XMLNames.h"
 #include "core/animation/Animation.h"
 #include "core/css/CSSBorderImage.h"
@@ skipping 10 matching lines @@
 #include "core/css/CSSSelector.h"
 #include "core/css/CSSSelectorList.h"
 #include "core/css/CSSStyleRule.h"
 #include "core/css/CSSSupportsRule.h"
 #include "core/css/CSSTimingFunctionValue.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/CSSVariableValue.h"
 #include "core/css/Counter.h"
 #include "core/css/DeprecatedStyleBuilder.h"
 #include "core/css/ElementRuleCollector.h"
-#include "core/css/FilterOperationResolver.h"
 #include "core/css/FontFeatureValue.h"
 #include "core/css/FontValue.h"
 #include "core/css/MediaList.h"
 #include "core/css/MediaQueryEvaluator.h"
 #include "core/css/PageRuleCollector.h"
 #include "core/css/Pair.h"
 #include "core/css/Rect.h"
 #include "core/css/RuleSet.h"
 #include "core/css/SelectorCheckerFastPath.h"
 #include "core/css/ShadowValue.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StylePropertyShorthand.h"
 #include "core/css/StyleRule.h"
 #include "core/css/StyleRuleImport.h"
 #include "core/css/StyleSheetContents.h"
 #include "core/css/StyleSheetList.h"
-#include "core/css/TransformBuilder.h"
-#include "core/css/ViewportStyleResolver.h"
 #include "core/css/WebKitCSSKeyframeRule.h"
 #include "core/css/WebKitCSSKeyframesRule.h"
 #include "core/css/WebKitCSSRegionRule.h"
+#include "core/css/resolver/FilterOperationResolver.h"
+#include "core/css/resolver/TransformBuilder.h"
+#include "core/css/resolver/ViewportStyleResolver.h"
 #include "core/dom/Attribute.h"
 #include "core/dom/ContextFeatures.h"
 #include "core/dom/DocumentStyleSheetCollection.h"
 #include "core/dom/ElementShadow.h"
 #include "core/dom/NodeRenderStyle.h"
 #include "core/dom/NodeRenderingContext.h"
 #include "core/dom/ShadowRoot.h"
 #include "core/dom/Text.h"
 #include "core/dom/VisitedLinkState.h"
 #include "core/dom/WebCoreMemoryInstrumentation.h"
@@ skipping 26 matching lines @@
 #include "core/rendering/style/CursorList.h"
 #include "core/rendering/style/KeyframeList.h"
 #include "core/rendering/style/QuotesData.h"
 #include "core/rendering/style/RenderStyleConstants.h"
 #include "core/rendering/style/ShadowData.h"
 #include "core/rendering/style/StyleCachedImage.h"
 #include "core/rendering/style/StyleGeneratedImage.h"
 #include "core/rendering/style/StylePendingImage.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "core/svg/SVGFontFaceElement.h"
-#include <wtf/MemoryInstrumentationHashMap.h>
-#include <wtf/MemoryInstrumentationHashSet.h>
-#include <wtf/MemoryInstrumentationVector.h>
-#include <wtf/StdLibExtras.h>
-#include <wtf/Vector.h>
+#include "wtf/MemoryInstrumentationHashMap.h"
+#include "wtf/MemoryInstrumentationHashSet.h"
+#include "wtf/MemoryInstrumentationVector.h"
+#include "wtf/StdLibExtras.h"
+#include "wtf/Vector.h"
 
 #if ENABLE(SVG)
 #include "SVGNames.h"
 #include "core/css/WebKitCSSSVGDocumentValue.h"
 #include "core/loader/cache/CachedSVGDocument.h"
 #include "core/loader/cache/CachedSVGDocumentReference.h"
 #include "core/svg/SVGDocument.h"
 #include "core/svg/SVGElement.h"
 #include "core/svg/SVGURIReference.h"
 #endif
 
 #include "core/css/CSSImageSetValue.h"
 #include "core/css/WebKitCSSMixFunctionValue.h"
 #include "core/css/WebKitCSSShaderValue.h"
+#include "core/html/track/WebVTTElement.h"
 #include "core/platform/graphics/filters/custom/CustomFilterArrayParameter.h"
 #include "core/platform/graphics/filters/custom/CustomFilterConstants.h"
 #include "core/platform/graphics/filters/custom/CustomFilterNumberParameter.h"
 #include "core/platform/graphics/filters/custom/CustomFilterOperation.h"
 #include "core/platform/graphics/filters/custom/CustomFilterParameter.h"
 #include "core/platform/graphics/filters/custom/CustomFilterProgramInfo.h"
 #include "core/platform/graphics/filters/custom/CustomFilterTransformParameter.h"
 #include "core/rendering/style/StyleCachedImageSet.h"
 #include "core/rendering/style/StyleCachedShader.h"
 #include "core/rendering/style/StyleCustomFilterProgram.h"
 #include "core/rendering/style/StyleCustomFilterProgramCache.h"
 #include "core/rendering/style/StylePendingShader.h"
 #include "core/rendering/style/StyleShader.h"
 
-#include "core/html/track/WebVTTElement.h"
-
 using namespace std;
 
 namespace WTF {
 
 template<> struct SequenceMemoryInstrumentationTraits<const WebCore::RuleData*> {
     template <typename I> static void reportMemoryUsage(I, I, MemoryClassInfo&) { }
 };
 
 }
 
@@ skipping 316 matching lines @@
     // First we match rules from the user agent sheet.
     if (CSSDefaultStyleSheets::simpleDefaultStyleSheet)
         collector.matchedResult().isCacheable = false;
 
     RuleSet* userAgentStyleSheet = m_medium->mediaTypeMatchSpecific("print")
         ? CSSDefaultStyleSheets::defaultPrintStyle : CSSDefaultStyleSheets::defaultStyle;
     matchUARules(collector, userAgentStyleSheet);
 
     // In quirks mode, we match rules from the quirks user agent sheet.
     if (document()->inQuirksMode())
-      matchUARules(collector, CSSDefaultStyleSheets::defaultQuirksStyle);
+        matchUARules(collector, CSSDefaultStyleSheets::defaultQuirksStyle);
 
     // If document uses view source styles (in view source mode or in xml viewer mode), then we match rules from the view source style sheet.
     if (document()->isViewSource())
         matchUARules(collector, CSSDefaultStyleSheets::viewSourceStyle());
 
     collector.setMatchingUARules(false);
 }
 
 void StyleResolver::matchUARules(ElementRuleCollector& collector, RuleSet* rules)
 {
@@ skipping 31 matching lines @@
         }
     }
 
     // Check the rules in author sheets next.
     if (matchAuthorAndUserStyles)
         matchAuthorRules(collector, false);
 
     // Now check our inline style attribute.
     if (matchAuthorAndUserStyles && m_state.styledElement() && m_state.styledElement()->inlineStyle()) {
         // Inline style is immutable as long as there is no CSSOM wrapper.
-      // FIXME: Media control shadow trees seem to have problems with caching.
-      bool isInlineStyleCacheable = !m_state.styledElement()->inlineStyle()->isMutable() && !m_state.styledElement()->isInShadowTree();
-      // FIXME: Constify.
-      collector.addElementStyleProperties(m_state.styledElement()->inlineStyle(), isInlineStyleCacheable);
+        // FIXME: Media control shadow trees seem to have problems with caching.
+        bool isInlineStyleCacheable = !m_state.styledElement()->inlineStyle()->isMutable() && !m_state.styledElement()->isInShadowTree();
+        // FIXME: Constify.
+        collector.addElementStyleProperties(m_state.styledElement()->inlineStyle(), isInlineStyleCacheable);
     }
 
 #if ENABLE(SVG)
     // Now check SMIL animation override style.
     if (includeSMILProperties && matchAuthorAndUserStyles && m_state.styledElement() && m_state.styledElement()->isSVGElement())
         collector.addElementStyleProperties(toSVGElement(m_state.styledElement())->animatedSMILStyleProperties(), false /* isCacheable */);
 #else
     UNUSED_PARAM(includeSMILProperties);
 #endif
 
@@ skipping 333 matching lines @@
     // Tracking child index requires unique style for each node. This may get set by the sibling rule match above.
     if (parentElementPreventsSharing(state.element()->parentElement()))
         return 0;
     return shareElement->renderStyle();
 }
 
 static void setStylesForPaginationMode(Pagination::Mode paginationMode, RenderStyle* style)
 {
     if (paginationMode == Pagination::Unpaginated)
         return;
-        
+
     switch (paginationMode) {
     case Pagination::LeftToRightPaginated:
         style->setColumnAxis(HorizontalColumnAxis);
         if (style->isHorizontalWritingMode())
             style->setColumnProgression(style->isLeftToRightDirection() ? NormalColumnProgression : ReverseColumnProgression);
         else
             style->setColumnProgression(style->isFlippedBlocksWritingMode() ? ReverseColumnProgression : NormalColumnProgression);
         break;
     case Pagination::RightToLeftPaginated:
         style->setColumnAxis(HorizontalColumnAxis);
@@ skipping 174 matching lines @@
         }
         element->document()->setHasNodesWithPlaceholderStyle();
         return s_styleNotYetAvailable;
     }
 
     StyleResolverState& state = m_state;
     initElement(element);
     state.initForStyleResolve(document(), element, defaultParent, regionForStyling);
     if (sharingBehavior == AllowStyleSharing && !state.distributedToInsertionPoint()) {
         RenderStyle* sharedStyle = locateSharedStyle();
-        if (sharedStyle)
-        {
+        if (sharedStyle) {
             state.clear();
             return sharedStyle;
         }
     }
 
     if (state.parentStyle()) {
         state.setStyle(RenderStyle::create());
         state.style()->inheritFrom(state.parentStyle(), isAtShadowBoundary(element) ? RenderStyle::AtShadowBoundary : RenderStyle::NotAtShadowBoundary);
     } else {
         state.setStyle(defaultStyleForElement());
@@ skipping 25 matching lines @@
         m_ruleSets.collectFeatures(document()->isViewSource(), m_scopeResolver.get());
         m_inspectorCSSOMWrappers.reset();
     }
 
     ElementRuleCollector collector(this, state);
     collector.setRegionForStyling(regionForStyling);
 
     if (matchingBehavior == MatchOnlyUserAgentRules)
         matchUARules(collector);
     else
-      matchAllRules(collector, m_matchAuthorAndUserStyles, matchingBehavior != MatchAllRulesExcludingSMIL);
+        matchAllRules(collector, m_matchAuthorAndUserStyles, matchingBehavior != MatchAllRulesExcludingSMIL);
 
     applyMatchedProperties(collector.matchedResult(), element);
 
     // Clean up our style object's display and text decorations (among other fixups).
     adjustRenderStyle(state.style(), state.parentStyle(), element);
 
     state.clear(); // Clear out for the next resolve.
 
     document()->didAccessStyleResolver();
 
@@ skipping 31 matching lines @@
     // Now do rest of the properties.
     if (keyframe->properties())
         applyMatchedProperties<LowPriorityProperties>(result, false, 0, result.matchedProperties.size() - 1, inheritedOnly);
 
     // If our font got dirtied by one of the non-essential font props,
     // go ahead and update it a second time.
     updateFont();
 
     // Start loading resources referenced by this style.
     loadPendingResources();
-    
+
     // Add all the animating properties to the keyframe.
     if (const StylePropertySet* styleDeclaration = keyframe->properties()) {
         unsigned propertyCount = styleDeclaration->propertyCount();
         for (unsigned i = 0; i < propertyCount; ++i) {
             CSSPropertyID property = styleDeclaration->propertyAt(i).id();
             // Timing-function within keyframes is special, because it is not animated; it just
             // describes the timing function between this keyframe and the next.
             if (property != CSSPropertyWebkitAnimationTimingFunction)
                 keyframeValue.addProperty(property);
         }
@@ skipping 241 matching lines @@
     case TABLE_CAPTION:
         return BLOCK;
     case NONE:
         ASSERT_NOT_REACHED();
         return NONE;
     }
     ASSERT_NOT_REACHED();
     return BLOCK;
 }
 
-// CSS requires text-decoration to be reset at each DOM element for tables, 
+// CSS requires text-decoration to be reset at each DOM element for tables,
 // inline blocks, inline tables, run-ins, shadow DOM crossings, floating elements,
 // and absolute or relatively positioned elements.
 static bool doesNotInheritTextDecoration(RenderStyle* style, Element* e)
 {
     return style->display() == TABLE || style->display() == INLINE_TABLE || style->display() == RUN_IN
         || style->display() == INLINE_BLOCK || style->display() == INLINE_BOX || isAtShadowBoundary(e)
         || style->isFloating() || style->hasOutOfFlowPosition();
 }
 
 static bool isDisplayFlexibleBox(EDisplay display)
@@ skipping 313 matching lines @@
     initElement(e);
     m_state.initForStyleResolve(document(), e, 0);
 
     ElementRuleCollector collector(this, m_state);
     collector.setMode(SelectorChecker::CollectingRules);
     collector.setPseudoStyleRequest(PseudoStyleRequest(pseudoId));
 
     if (rulesToInclude & UAAndUserCSSRules) {
         // First we match rules from the user agent sheet.
         matchUARules(collector);
-        
+
         // Now we check user sheet rules.
         if (m_matchAuthorAndUserStyles)
             matchUserRules(collector, rulesToInclude & EmptyCSSRules);
     }
 
     if (m_matchAuthorAndUserStyles && (rulesToInclude & AuthorCSSRules)) {
         collector.setSameOriginOnly(!(rulesToInclude & CrossOriginCSSRules));
 
         // Check the rules in author sheets.
         matchAuthorRules(collector, rulesToInclude & EmptyCSSRules);
@@ skipping 122 matching lines @@
         return;
     }
     for (int i = startIndex; i <= endIndex; ++i) {
         const MatchedProperties& matchedProperties = matchResult.matchedProperties[i];
         applyProperties<pass>(matchedProperties.properties.get(), matchResult.matchedRules[i], isImportant, inheritedOnly, static_cast<PropertyWhitelistType>(matchedProperties.whitelistType));
     }
 }
 
 unsigned StyleResolver::computeMatchedPropertiesHash(const MatchedProperties* properties, unsigned size)
 {
-    
+
     return StringHasher::hashMemory(properties, sizeof(MatchedProperties) * size);
 }
 
 bool operator==(const StyleResolver::MatchRanges& a, const StyleResolver::MatchRanges& b)
 {
     return a.firstUARule == b.firstUARule
         && a.lastUARule == b.lastUARule
         && a.firstAuthorRule == b.firstAuthorRule
         && a.lastAuthorRule == b.lastAuthorRule
         && a.firstUserRule == b.firstUserRule
@@ skipping 84 matching lines @@
 
 void StyleResolver::applyMatchedProperties(const MatchResult& matchResult, const Element* element)
 {
     ASSERT(element);
     StyleResolverState& state = m_state;
     unsigned cacheHash = matchResult.isCacheable ? computeMatchedPropertiesHash(matchResult.matchedProperties.data(), matchResult.matchedProperties.size()) : 0;
     bool applyInheritedOnly = false;
     const MatchedPropertiesCacheItem* cacheItem = 0;
     if (cacheHash && (cacheItem = findFromMatchedPropertiesCache(cacheHash, matchResult))) {
         // We can build up the style by copying non-inherited properties from an earlier style object built using the same exact
-        // style declarations. We then only need to apply the inherited properties, if any, as their values can depend on the 
+        // style declarations. We then only need to apply the inherited properties, if any, as their values can depend on the
         // element context. This is fast and saves memory by reusing the style data structures.
         state.style()->copyNonInheritedFrom(cacheItem->renderStyle.get());
         if (state.parentStyle()->inheritedDataShared(cacheItem->parentRenderStyle.get()) && !isAtShadowBoundary(element)) {
             EInsideLink linkStatus = state.style()->insideLink();
             // If the cache item parent style has identical inherited properties to the current parent style then the
             // resulting style will be identical too. We copy the inherited properties over from the cache and are done.
             state.style()->inheritFrom(cacheItem->renderStyle.get());
 
             // Unfortunately the link status is treated like an inherited property. We need to explicitly restore it.
             state.style()->setInsideLink(linkStatus);
             return;
         }
-        applyInheritedOnly = true; 
+        applyInheritedOnly = true;
     }
 
     // First apply all variable definitions, as they may be used during application of later properties.
     applyMatchedProperties<VariableDefinitions>(matchResult, false, 0, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
     applyMatchedProperties<VariableDefinitions>(matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
     applyMatchedProperties<VariableDefinitions>(matchResult, true, matchResult.ranges.firstUserRule, matchResult.ranges.lastUserRule, applyInheritedOnly);
     applyMatchedProperties<VariableDefinitions>(matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
 
     // Now we have all of the matched rules in the appropriate order. Walk the rules and apply
     // high-priority properties first, i.e., those properties that other properties depend on.
@@ skipping 19 matching lines @@
     // Line-height is set when we are sure we decided on the font-size.
     if (state.lineHeightValue())
         applyProperty(CSSPropertyLineHeight, state.lineHeightValue());
 
     // Many properties depend on the font. If it changes we just apply all properties.
     if (cacheItem && cacheItem->renderStyle->fontDescription() != state.style()->fontDescription())
         applyInheritedOnly = false;
 
     // Now do the normal priority UA properties.
     applyMatchedProperties<LowPriorityProperties>(matchResult, false, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
-    
+
     // Cache our border and background so that we can examine them later.
     state.cacheBorderAndBackground();
-    
+
     // Now do the author and user normal priority properties and all the !important properties.
     applyMatchedProperties<LowPriorityProperties>(matchResult, false, matchResult.ranges.lastUARule + 1, matchResult.matchedProperties.size() - 1, applyInheritedOnly);
     if (RuntimeEnabledFeatures::webAnimationEnabled())
         applyAnimatedProperties<LowPriorityProperties>(element);
     applyMatchedProperties<LowPriorityProperties>(matchResult, true, matchResult.ranges.firstAuthorRule, matchResult.ranges.lastAuthorRule, applyInheritedOnly);
     applyMatchedProperties<LowPriorityProperties>(matchResult, true, matchResult.ranges.firstUserRule, matchResult.ranges.lastUserRule, applyInheritedOnly);
     applyMatchedProperties<LowPriorityProperties>(matchResult, true, matchResult.ranges.firstUARule, matchResult.ranges.lastUARule, applyInheritedOnly);
-   
+
     // Start loading resources referenced by this style.
     loadPendingResources();
-    
+
     ASSERT(!state.fontDirty());
-    
+
     if (cacheItem || !cacheHash)
         return;
     if (!isCacheableInMatchedPropertiesCache(state.element(), state.style(), state.parentStyle()))
         return;
     addToMatchedPropertiesCache(state.style(), state.parentStyle(), cacheHash, matchResult);
 }
 
 void StyleResolver::applyPropertyToStyle(CSSPropertyID id, CSSValue* value, RenderStyle* style)
 {
     initElement(0);
@@ skipping 766 matching lines @@
     case CSSPropertyTextUnderlineMode:
     case CSSPropertyTextUnderlineStyle:
     case CSSPropertyTextUnderlineWidth:
     case CSSPropertyWebkitFontSizeDelta:
     case CSSPropertyWebkitTextDecorationsInEffect:
         return;
 
     // CSS Text Layout Module Level 3: Vertical writing support
     case CSSPropertyWebkitWritingMode: {
         HANDLE_INHERIT_AND_INITIAL(writingMode, WritingMode);
-        
+
         if (primitiveValue)
             setWritingMode(*primitiveValue);
 
         // FIXME: It is not ok to modify document state while applying style.
         if (state.element() && state.element() == state.document()->documentElement())
             state.document()->setWritingModeSetOnDocumentElement(true);
         return;
     }
 
     case CSSPropertyWebkitTextOrientation: {
@@ skipping 469 matching lines @@
     // multiplying by our scale factor.
     float size;
     if (childFont.keywordSize())
         size = fontSizeForKeyword(document(), CSSValueXxSmall + childFont.keywordSize() - 1, childFont.useFixedDefaultSize());
     else {
         Settings* settings = documentSettings();
         float fixedScaleFactor = (settings && settings->defaultFixedFontSize() && settings->defaultFontSize())
             ? static_cast<float>(settings->defaultFixedFontSize()) / settings->defaultFontSize()
             : 1;
         size = parentFont.useFixedDefaultSize() ?
-                childFont.specifiedSize() / fixedScaleFactor :
-                childFont.specifiedSize() * fixedScaleFactor;
+            childFont.specifiedSize() / fixedScaleFactor :
+            childFont.specifiedSize() * fixedScaleFactor;
     }
 
     FontDescription newFontDescription(childFont);
     setFontSize(newFontDescription, size);
     style->setFontDescription(newFontDescription);
 }
 
 void StyleResolver::initializeFontStyle(Settings* settings)
 {
     FontDescription fontDescription;
@@ skipping 73 matching lines @@
     return min(maximumAllowedFontSize, zoomedSize);
 }
 
 const int fontSizeTableMax = 16;
 const int fontSizeTableMin = 9;
 const int totalKeywords = 8;
 
 // WinIE/Nav4 table for font sizes. Designed to match the legacy font mapping system of HTML.
 static const int quirksFontSizeTable[fontSizeTableMax - fontSizeTableMin + 1][totalKeywords] =
 {
-      { 9,    9,     9,     9,    11,    14,    18,    28 },
-      { 9,    9,     9,    10,    12,    15,    20,    31 },
-      { 9,    9,     9,    11,    13,    17,    22,    34 },
-      { 9,    9,    10,    12,    14,    18,    24,    37 },
-      { 9,    9,    10,    13,    16,    20,    26,    40 }, // fixed font default (13)
-      { 9,    9,    11,    14,    17,    21,    28,    42 },
-      { 9,   10,    12,    15,    17,    23,    30,    45 },
-      { 9,   10,    13,    16,    18,    24,    32,    48 } // proportional font default (16)
+    { 9,    9,     9,     9,    11,    14,    18,    28 },
+    { 9,    9,     9,    10,    12,    15,    20,    31 },
+    { 9,    9,     9,    11,    13,    17,    22,    34 },
+    { 9,    9,    10,    12,    14,    18,    24,    37 },
+    { 9,    9,    10,    13,    16,    20,    26,    40 }, // fixed font default (13)
+    { 9,    9,    11,    14,    17,    21,    28,    42 },
+    { 9,   10,    12,    15,    17,    23,    30,    45 },
+    { 9,   10,    13,    16,    18,    24,    32,    48 } // proportional font default (16)
 };
 // HTML       1      2      3      4      5      6      7
 // CSS  xxs   xs     s      m      l     xl     xxl
 //                          |
 //                      user pref
 
 // Strict mode table matches MacIE and Mozilla's settings exactly.
 static const int strictFontSizeTable[fontSizeTableMax - fontSizeTableMin + 1][totalKeywords] =
 {
-      { 9,    9,     9,     9,    11,    14,    18,    27 },
-      { 9,    9,     9,    10,    12,    15,    20,    30 },
-      { 9,    9,    10,    11,    13,    17,    22,    33 },
-      { 9,    9,    10,    12,    14,    18,    24,    36 },
-      { 9,   10,    12,    13,    16,    20,    26,    39 }, // fixed font default (13)
-      { 9,   10,    12,    14,    17,    21,    28,    42 },
-      { 9,   10,    13,    15,    18,    23,    30,    45 },
-      { 9,   10,    13,    16,    18,    24,    32,    48 } // proportional font default (16)
+    { 9,    9,     9,     9,    11,    14,    18,    27 },
+    { 9,    9,     9,    10,    12,    15,    20,    30 },
+    { 9,    9,    10,    11,    13,    17,    22,    33 },
+    { 9,    9,    10,    12,    14,    18,    24,    36 },
+    { 9,   10,    12,    13,    16,    20,    26,    39 }, // fixed font default (13)
+    { 9,   10,    12,    14,    17,    21,    28,    42 },
+    { 9,   10,    13,    15,    18,    23,    30,    45 },
+    { 9,   10,    13,    16,    18,    24,    32,    48 } // proportional font default (16)
 };
 // HTML       1      2      3      4      5      6      7
 // CSS  xxs   xs     s      m      l     xl     xxl
 //                          |
 //                      user pref
 
 // For values outside the range of the table, we use Todd Fahrner's suggested scale
 // factors for each keyword value.
 static const float fontSizeFactors[totalKeywords] = { 0.60f, 0.75f, 0.89f, 1.0f, 1.2f, 1.5f, 2.0f, 3.0f };
 
@@ skipping 252 matching lines @@
     m_state.pendingImageProperties().clear();
 }
 
 void StyleResolver::loadPendingResources()
 {
     // Start loading images referenced by this style.
     loadPendingImages();
 
     // Start loading the shaders referenced by this style.
     loadPendingShaders();
-    
+
 #if ENABLE(SVG)
     // Start loading the SVG Documents referenced by this style.
     loadPendingSVGDocuments();
 #endif
 }
 
 inline StyleResolver::MatchedProperties::MatchedProperties()
     : possiblyPaddedMember(0)
 {
 }
@@ skipping 39 matching lines @@
     info.addMember(m_viewportDependentMediaQueryResults, "viewportDependentMediaQueryResults");
     info.ignoreMember(m_styleBuilder);
     info.addMember(m_inspectorCSSOMWrappers);
     info.addMember(m_scopeResolver, "scopeResolver");
 
     info.addMember(m_state, "state");
 
     // FIXME: move this to a place where it would be called only once?
     info.addMember(CSSDefaultStyleSheets::defaultStyle, "defaultStyle");
     info.addMember(CSSDefaultStyleSheets::defaultQuirksStyle, "defaultQuirksStyle");
-    info.addMember(CSSDefaultStyleSheets::defaultPrintStyle,"defaultPrintStyle");
+    info.addMember(CSSDefaultStyleSheets::defaultPrintStyle, "defaultPrintStyle");
     info.addMember(CSSDefaultStyleSheets::defaultViewSourceStyle, "defaultViewSourceStyle");
 }
 
 } // namespace WebCore