Move pure functions in CSSComputedStyleDeclaration.cpp into their own private namespace.

third_party/WebKit/Source/core/css/CSSComputedStyleDeclaration.cpp

 /*
  * Copyright (C) 2004 Zack Rusin <zack@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc.
  * All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2011 Sencha, Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ skipping 27 matching lines @@
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/PseudoElement.h"
 #include "core/dom/StyleEngine.h"
 #include "core/layout/LayoutObject.h"
 #include "core/style/ComputedStyle.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
+namespace {
+
 // List of all properties we know how to compute, omitting shorthands.
 // NOTE: Do not use this list, use computableProperties() instead
 // to respect runtime enabling of CSS properties.
-static const CSSPropertyID staticComputableProperties[] = {
+const CSSPropertyID computedPropertyArray[] = {
     CSSPropertyAnimationDelay, CSSPropertyAnimationDirection,
     CSSPropertyAnimationDuration, CSSPropertyAnimationFillMode,
     CSSPropertyAnimationIterationCount, CSSPropertyAnimationName,
     CSSPropertyAnimationPlayState, CSSPropertyAnimationTimingFunction,
     CSSPropertyBackgroundAttachment, CSSPropertyBackgroundBlendMode,
     CSSPropertyBackgroundClip, CSSPropertyBackgroundColor,
     CSSPropertyBackgroundImage, CSSPropertyBackgroundOrigin,
     // more-specific background-position-x/y are non-standard
     CSSPropertyBackgroundPosition, CSSPropertyBackgroundRepeat,
     CSSPropertyBackgroundSize, CSSPropertyBorderBottomColor,
@@ skipping 106 matching lines @@
     CSSPropertyStrokeOpacity, CSSPropertyStrokeWidth,
     CSSPropertyAlignmentBaseline, CSSPropertyBaselineShift,
     CSSPropertyDominantBaseline, CSSPropertyTextAnchor, CSSPropertyWritingMode,
     CSSPropertyVectorEffect, CSSPropertyPaintOrder, CSSPropertyD, CSSPropertyCx,
     CSSPropertyCy, CSSPropertyX, CSSPropertyY, CSSPropertyR, CSSPropertyRx,
     CSSPropertyRy, CSSPropertyScrollSnapType, CSSPropertyScrollSnapPointsX,
     CSSPropertyScrollSnapPointsY, CSSPropertyScrollSnapCoordinate,
     CSSPropertyScrollSnapDestination, CSSPropertyTranslate, CSSPropertyRotate,
     CSSPropertyScale, CSSPropertyCaretColor};
 
-static const Vector<CSSPropertyID>& computableProperties() {
+const Vector<CSSPropertyID>& computableProperties() {
   DEFINE_STATIC_LOCAL(Vector<CSSPropertyID>, properties, ());
-  if (properties.isEmpty())
+  if (properties.isEmpty()) {
     CSSPropertyMetadata::filterEnabledCSSPropertiesIntoVector(
-        staticComputableProperties,
-        WTF_ARRAY_LENGTH(staticComputableProperties), properties);
+        computedPropertyArray, WTF_ARRAY_LENGTH(computedPropertyArray),
+        properties);
+  }
   return properties;
 }
 
-CSSComputedStyleDeclaration::CSSComputedStyleDeclaration(
-    Node* n,
-    bool allowVisitedStyle,
-    const String& pseudoElementName)
-    : m_node(n),
-      m_pseudoElementSpecifier(CSSSelector::parsePseudoId(pseudoElementName)),
-      m_allowVisitedStyle(allowVisitedStyle) {}
-
-CSSComputedStyleDeclaration::~CSSComputedStyleDeclaration() {}
-
-String CSSComputedStyleDeclaration::cssText() const {
-  StringBuilder result;
-  const Vector<CSSPropertyID>& properties = computableProperties();
-
-  for (unsigned i = 0; i < properties.size(); i++) {
-    if (i)
-      result.append(' ');
-    result.append(getPropertyName(properties[i]));
-    result.append(": ");
-    result.append(getPropertyValue(properties[i]));
-    result.append(';');
-  }
-
-  return result.toString();
-}
-
-void CSSComputedStyleDeclaration::setCSSText(const String&,
-                                             ExceptionState& exceptionState) {
-  exceptionState.throwDOMException(
-      NoModificationAllowedError,
-      "These styles are computed, and therefore read-only.");
-}
-
-static CSSValueID cssIdentifierForFontSizeKeyword(int keywordSize) {
+CSSValueID cssIdentifierForFontSizeKeyword(int keywordSize) {
   DCHECK_NE(keywordSize, 0);
   DCHECK_LE(keywordSize, 8);
   return static_cast<CSSValueID>(CSSValueXxSmall + keywordSize - 1);
 }
 
-inline static CSSPrimitiveValue* zoomAdjustedPixelValue(
-    double value,
-    const ComputedStyle& style) {
+inline CSSPrimitiveValue* zoomAdjustedPixelValue(double value,
+                                                 const ComputedStyle& style) {
   return CSSPrimitiveValue::create(adjustFloatForAbsoluteZoom(value, style),
                                    CSSPrimitiveValue::UnitType::Pixels);
 }
 
-const CSSValue*
-CSSComputedStyleDeclaration::getFontSizeCSSValuePreferringKeyword() const {
-  if (!m_node)
-    return nullptr;
-
-  m_node->document().updateStyleAndLayoutIgnorePendingStylesheets();
-
-  const ComputedStyle* style =
-      m_node->ensureComputedStyle(m_pseudoElementSpecifier);
-  if (!style)
-    return nullptr;
-
-  if (int keywordSize = style->getFontDescription().keywordSize())
-    return CSSIdentifierValue::create(
-        cssIdentifierForFontSizeKeyword(keywordSize));
-
-  return zoomAdjustedPixelValue(style->getFontDescription().computedPixelSize(),
-                                *style);
-}
-
-bool CSSComputedStyleDeclaration::isMonospaceFont() const {
-  if (!m_node)
-    return false;
-
-  const ComputedStyle* style =
-      m_node->ensureComputedStyle(m_pseudoElementSpecifier);
-  if (!style)
-    return false;
-
-  return style->getFontDescription().isMonospace();
-}
-
-static void logUnimplementedPropertyID(CSSPropertyID propertyID) {
+void logUnimplementedPropertyID(CSSPropertyID propertyID) {
   DEFINE_STATIC_LOCAL(HashSet<CSSPropertyID>, propertyIDSet, ());
   if (!propertyIDSet.add(propertyID).isNewEntry)
     return;
 
   DLOG(ERROR) << "Blink does not yet implement getComputedStyle for '"
               << getPropertyName(propertyID) << "'.";
 }
 
-static bool isLayoutDependent(CSSPropertyID propertyID,
-                              const ComputedStyle* style,
-                              LayoutObject* layoutObject) {
+bool isLayoutDependent(CSSPropertyID propertyID,
+                       const ComputedStyle* style,
+                       LayoutObject* layoutObject) {
   if (!layoutObject)
     return false;
 
   // Some properties only depend on layout in certain conditions which
   // are specified in the main switch statement below. So we can avoid
   // forcing layout in those conditions. The conditions in this switch
   // statement must remain in sync with the conditions in the main switch.
   // FIXME: Some of these cases could be narrowed down or optimized better.
   switch (propertyID) {
     case CSSPropertyBottom:
@@ skipping 44 matching lines @@
     case CSSPropertyGridTemplateColumns:
     case CSSPropertyGridTemplateRows:
     case CSSPropertyGridTemplate:
     case CSSPropertyGrid:
       return layoutObject->isLayoutGrid();
     default:
       return false;
   }
 }
 
+}  // namespace
+
+CSSComputedStyleDeclaration::CSSComputedStyleDeclaration(
+    Node* n,
+    bool allowVisitedStyle,
+    const String& pseudoElementName)
+    : m_node(n),
+      m_pseudoElementSpecifier(CSSSelector::parsePseudoId(pseudoElementName)),
+      m_allowVisitedStyle(allowVisitedStyle) {}
+
+CSSComputedStyleDeclaration::~CSSComputedStyleDeclaration() {}
+
+String CSSComputedStyleDeclaration::cssText() const {
+  StringBuilder result;
+  const Vector<CSSPropertyID>& properties = computableProperties();
+
+  for (unsigned i = 0; i < properties.size(); i++) {
+    if (i)
+      result.append(' ');
+    result.append(getPropertyName(properties[i]));
+    result.append(": ");
+    result.append(getPropertyValue(properties[i]));
+    result.append(';');
+  }
+
+  return result.toString();
+}
+
+void CSSComputedStyleDeclaration::setCSSText(const String&,
+                                             ExceptionState& exceptionState) {
+  exceptionState.throwDOMException(
+      NoModificationAllowedError,
+      "These styles are computed, and therefore read-only.");
+}
+
+const CSSValue*
+CSSComputedStyleDeclaration::getFontSizeCSSValuePreferringKeyword() const {
+  if (!m_node)
+    return nullptr;
+
+  m_node->document().updateStyleAndLayoutIgnorePendingStylesheets();
+
+  const ComputedStyle* style =
+      m_node->ensureComputedStyle(m_pseudoElementSpecifier);
+  if (!style)
+    return nullptr;
+
+  if (int keywordSize = style->getFontDescription().keywordSize()) {
+    return CSSIdentifierValue::create(
+        cssIdentifierForFontSizeKeyword(keywordSize));
+  }
+
+  return zoomAdjustedPixelValue(style->getFontDescription().computedPixelSize(),
+                                *style);
+}
+
+bool CSSComputedStyleDeclaration::isMonospaceFont() const {
+  if (!m_node)
+    return false;
+
+  const ComputedStyle* style =
+      m_node->ensureComputedStyle(m_pseudoElementSpecifier);
+  if (!style)
+    return false;
+
+  return style->getFontDescription().isMonospace();
+}
 const ComputedStyle* CSSComputedStyleDeclaration::computeComputedStyle() const {
   Node* styledNode = this->styledNode();
   ASSERT(styledNode);
   return styledNode->ensureComputedStyle(
       styledNode->isPseudoElement() ? PseudoIdNone : m_pseudoElementSpecifier);
 }
 
 Node* CSSComputedStyleDeclaration::styledNode() const {
   if (!m_node)
     return nullptr;
@@ skipping 207 matching lines @@
       "These styles are computed, and therefore the '" +
           getPropertyNameString(id) + "' property is read-only.");
 }
 
 DEFINE_TRACE(CSSComputedStyleDeclaration) {
   visitor->trace(m_node);
   CSSStyleDeclaration::trace(visitor);
 }
 
 }  // namespace blink