[CSSTypedOM] Computed StylePropertyMap use ComputedStyle for Lengths

third_party/WebKit/Source/core/css/cssom/ComputedStylePropertyMap.cpp

 // Copyright 2016 the Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/cssom/ComputedStylePropertyMap.h"
 
 #include "core/css/CSSComputedStyleDeclaration.h"
+#include "core/css/cssom/CSSCalcLength.h"
+#include "core/css/cssom/CSSKeywordValue.h"
+#include "core/css/cssom/CSSSimpleLength.h"
 #include "core/css/cssom/StyleValueFactory.h"
 
 namespace blink {
 
+CSSStyleValue* styleValueForLengthProperty(const Length& length)
+{
+    if (length.isAuto()) {
+        return CSSKeywordValue::create("auto");
+    }
+    if (length.isFixed()) {
+        return CSSSimpleLength::create(length.pixels(), CSSPrimitiveValue::UnitType::Pixels);
+    }
+    if (length.isPercent()) {
+        return CSSSimpleLength::create(length.percent(), CSSPrimitiveValue::UnitType::Percentage);
+    }
+    if (length.isCalculated()) {
+        return CSSCalcLength::fromLength(length);
+    }
+    NOTREACHED();
+    return nullptr;
+}
+
 CSSStyleValueVector ComputedStylePropertyMap::getAllInternal(CSSPropertyID propertyID)
 {
-    const CSSValue* cssValue = m_computedStyleDeclaration->getPropertyCSSValueInternal(propertyID);
-    if (!cssValue)
-        return CSSStyleValueVector();
-    return StyleValueFactory::cssValueToStyleValueVector(propertyID, *cssValue);
+    Document& document = m_node->document();
+    // TODO(rjwright): This style recalc is copied from
+    // CSSComputedStyleDeclaration::getPropertyValue, which also does a bunch of other stuff.
+    // Need to look back to it and see if I need to do more here.
+    document.updateStyleAndLayoutTreeForNode(m_node);
+    const ComputedStyle* style = m_node->ensureComputedStyle();
+    CSSStyleValueVector styleValueVector;
+    CSSStyleValue* styleValue = nullptr;
+    switch (propertyID) {
+    case CSSPropertyLeft:
+        styleValue = styleValueForLengthProperty(style->left());
+    case CSSPropertyRight:
+        styleValue = styleValueForLengthProperty(style->right());
+    case CSSPropertyTop:
+        styleValue = styleValueForLengthProperty(style->top());
+    case CSSPropertyBottom:
+        styleValue = styleValueForLengthProperty(style->bottom());
+    case CSSPropertyHeight:
+        styleValue = styleValueForLengthProperty(style->height());
+    case CSSPropertyWidth: {
+        styleValue = styleValueForLengthProperty(style->width());
+    }
+    default:
+        break;
+    }
+    if (!styleValue) {

[meade_UTC10, 2016/09/22 05:34:35]

I think it's clearer, and you can save a level of nesting if you invert this if
statement:

...

if (styleValue) {
  styleValueVector.append(styleValue);
  return styleValueVector;
}

const CSSValue* cssValue =
m_computedStyleDeclaration->getPropertyCSSValueInternal(propertyID);
if (cssValue)
  return StyleValueFactory::unsupportedCSSValue(*cssValue);

return styleValueVector;

[rjwright, 2016/09/23 04:50:04]

Done.

But I'm kinda unsure about our decision to use resolved style cssText to make an
unsupportedCSSValue. Wondering if we should go back to returning an empty
vector. Maybe we should chat to some other people (Shane, Doug?) and get their
opinion.

+        const CSSValue* cssValue = m_computedStyleDeclaration->getPropertyCSSValueInternal(propertyID);
+        if (cssValue) {
+            return StyleValueFactory::unsupportedCSSValue(*cssValue);
+        }
+        return styleValueVector;
+    }
+    styleValueVector.append(styleValue);
+    return styleValueVector;
 }
 
 CSSStyleValueVector ComputedStylePropertyMap::getAllInternal(AtomicString customPropertyName)
 {
     const CSSValue* cssValue = m_computedStyleDeclaration->getPropertyCSSValueInternal(customPropertyName);
     if (!cssValue)
         return CSSStyleValueVector();
     return StyleValueFactory::cssValueToStyleValueVector(CSSPropertyInvalid, *cssValue);
 }
 
 Vector<String> ComputedStylePropertyMap::getProperties()
 {
     Vector<String> result;
     for (unsigned i = 0; i < m_computedStyleDeclaration->length(); i++) {
         result.append(m_computedStyleDeclaration->item(i));
     }
     return result;
 }
 
 } // namespace blink