CSS Properties and Values API: Support non-inherited custom properties

third_party/WebKit/Source/core/style/StyleInheritedVariables.cpp

 // Copyright 2015 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/style/StyleVariableData.h"
+#include "core/style/StyleInheritedVariables.h"
 
 #include "core/style/DataEquivalency.h"
 
 namespace blink {
 
-bool StyleVariableData::operator==(const StyleVariableData& other) const
+bool StyleInheritedVariables::operator==(const StyleInheritedVariables& other) const
 {
     // It's technically possible for divergent roots to be value-equal,
     // but unlikely. This equality operator is used for optimization purposes
     // so it's OK to be occasionally wrong.
     // TODO(shanestephens): Rename this to something that indicates it may not
     // always return equality.
     if (m_root != other.m_root)
         return false;
 
     if (m_data.size() != other.m_data.size())
         return false;
 
     for (const auto& iter : m_data) {
         RefPtr<CSSVariableData> otherData = other.m_data.get(iter.key);
         if (!dataEquivalent(iter.value, otherData))
             return false;
     }
 
     return true;
 }
 
-StyleVariableData::StyleVariableData(StyleVariableData& other)
+StyleInheritedVariables::StyleInheritedVariables(StyleInheritedVariables& other)
 {
     if (!other.m_root) {
         m_root = &other;
     } else {
         m_data = other.m_data;
         m_registeredData = other.m_registeredData;
         m_root = other.m_root;
     }
 }
 
-CSSVariableData* StyleVariableData::getVariable(const AtomicString& name) const
+CSSVariableData* StyleInheritedVariables::getVariable(const AtomicString& name) const
 {
     auto result = m_data.find(name);
     if (result == m_data.end() && m_root)
         return m_root->getVariable(name);
     if (result == m_data.end())
         return nullptr;
     return result->value.get();
 }
 
-void StyleVariableData::setRegisteredInheritedProperty(const AtomicString& name, const CSSValue* parsedValue)
+void StyleInheritedVariables::setRegisteredVariable(const AtomicString& name, const CSSValue* parsedValue)
 {
     m_registeredData.set(name, const_cast<CSSValue*>(parsedValue));
 }
 
-void StyleVariableData::removeVariable(const AtomicString& name)
+CSSValue* StyleInheritedVariables::registeredVariable(const AtomicString& name) const
+{
+    auto result = m_registeredData.find(name);
+    if (result != m_registeredData.end())
+        return result->value.get();
+    if (m_root)
+        return m_root->registeredVariable(name);
+    return nullptr;
+}
+
+void StyleInheritedVariables::removeVariable(const AtomicString& name)
 {
     m_data.set(name, nullptr);
     auto iterator = m_registeredData.find(name);
     if (iterator != m_registeredData.end())
         iterator->value = nullptr;
 }
 
-std::unique_ptr<HashMap<AtomicString, RefPtr<CSSVariableData>>> StyleVariableData::getVariables() const
+std::unique_ptr<HashMap<AtomicString, RefPtr<CSSVariableData>>> StyleInheritedVariables::getVariables() const
 {
     std::unique_ptr<HashMap<AtomicString, RefPtr<CSSVariableData>>> result;
     if (m_root) {
         result.reset(new HashMap<AtomicString, RefPtr<CSSVariableData>>(m_root->m_data));
         for (auto it = m_data.begin(); it != m_data.end(); ++it)
             result->set(it->key, it->value);
     } else {
         result.reset(new HashMap<AtomicString, RefPtr<CSSVariableData>>(m_data));
     }
     return result;
 }
 
 } // namespace blink