[Typed-OM] Get CSSTokenStreamValue from StyleMap

third_party/WebKit/Source/core/css/cssom/CSSTokenStreamValue.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/CSSTokenStreamValue.h"
 
-#include "core/css/CSSVariableReferenceValue.h"
 #include "core/css/cssom/CSSStyleVariableReferenceValue.h"
 #include "core/css/parser/CSSTokenizer.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 namespace {
 
 class TokenStreamValueIterationSource final : public ValueIterable<StringOrCSSVariableReferenceValue>::IterationSource {
 public:
@@ skipping 13 matching lines @@
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_tokenStreamValue);
         ValueIterable<StringOrCSSVariableReferenceValue>::IterationSource::trace(visitor);
     }
 
 private:
     const Member<CSSTokenStreamValue> m_tokenStreamValue;
 };
 
+CSSTokenStreamValue* fragmentsToTokenStreamValue(const HeapVector<StringOrCSSVariableReferenceValue>& fragments)

[anthonyhkf, 2016/08/25 03:48:31]

Should this be moved to the parserTokenRangeToFragments()? So it will become
parserTokenRangeToTokenStreamValue() and return the CSSTokenStreamValue from the
HeapVector (just move this function's body to the end of current
parserTokenRangeToFragments()).

+{
+    // returns undefined/null if there is no value following the variable's name
+    if (fragments.size() == 0)
+        return nullptr;
+    return CSSTokenStreamValue::create(fragments);
+}
+
+StringView findVariableName(CSSParserTokenRange& range)
+{
+    range.consumeWhitespace();
+    return range.consume().value();
+}
+
+CSSStyleVariableReferenceValue* variableReferenceValue(StringView variableName, CSSTokenStreamValue* tokenStreamValue)
+{
+    return CSSStyleVariableReferenceValue::create(variableName.toString(), tokenStreamValue);
+}
+
+HeapVector<StringOrCSSVariableReferenceValue> parserTokenRangeToFragments(CSSParserTokenRange range)
+{
+    HeapVector<StringOrCSSVariableReferenceValue> fragments;
+    StringBuilder builder;
+    while (!range.atEnd()) {
+        if (range.peek().functionId() == CSSValueVar) {
+            if (!builder.isEmpty()) {
+                fragments.append(StringOrCSSVariableReferenceValue::fromString(builder.toString()));
+                builder.clear();
+            }
+            CSSParserTokenRange current = range.consumeBlock();
+            StringView variableName = findVariableName(current);
+            while (!current.atEnd() && current.consume().type() != CSSParserTokenType::CommaToken) { }
+            CSSTokenStreamValue* tokenStreamValue = fragmentsToTokenStreamValue(parserTokenRangeToFragments(current));
+            fragments.append(StringOrCSSVariableReferenceValue::fromCSSVariableReferenceValue(variableReferenceValue(variableName, tokenStreamValue)));
+        } else {
+            range.consume().serialize(builder);
+        }
+    }
+    if (!builder.isEmpty())
+        fragments.append(StringOrCSSVariableReferenceValue::fromString(builder.toString()));
+    return fragments;
+}
+
 } // namespace
 
 ValueIterable<StringOrCSSVariableReferenceValue>::IterationSource* CSSTokenStreamValue::startIteration(ScriptState*, ExceptionState&)
 {
     return new TokenStreamValueIterationSource(this);
 }
 
+CSSTokenStreamValue* CSSTokenStreamValue::fromCSSValue(const CSSVariableReferenceValue& cssVariableReferenceValue)
+{
+    return fragmentsToTokenStreamValue(parserTokenRangeToFragments(cssVariableReferenceValue.variableDataValue()->tokenRange()));
+}
+
 CSSValue* CSSTokenStreamValue::toCSSValue() const
 {
     StringBuilder tokens;
 
     for (unsigned i = 0; i < m_fragments.size(); i++) {
         if (i)
             tokens.append("/**/");
         if (m_fragments[i].isString())
             tokens.append(m_fragments[i].getAsString());
         else if (m_fragments[i].isCSSVariableReferenceValue())
             tokens.append(m_fragments[i].getAsCSSVariableReferenceValue()->variable());
         else
             NOTREACHED();
     }
 
     CSSTokenizer::Scope scope(tokens.toString());
 
     return CSSVariableReferenceValue::create(CSSVariableData::create(scope.tokenRange()));
 }
 
 } // namespace blink