Add forEach() to CSSVariablesMap

Source/core/css/StylePropertySet.h

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2008, 2012 Apple 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.
  */
 
 #ifndef StylePropertySet_h
 #define StylePropertySet_h
 
 #include "CSSPropertyNames.h"
 #include "core/css/CSSParserMode.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/css/CSSProperty.h"
+#include "core/css/CSSVariablesIterator.h"
 #include "core/css/PropertySetCSSStyleDeclaration.h"
 #include "wtf/ListHashSet.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 
 namespace WebCore {
 
 class CSSRule;
 class CSSStyleDeclaration;
 class Element;
@@ skipping 129 matching lines @@
     return reinterpret_cast<const CSSValue**>(const_cast<const void**>(&(this->m_storage)));
 }
 
 inline const StylePropertyMetadata* ImmutableStylePropertySet::metadataArray() const
 {
     return reinterpret_cast<const StylePropertyMetadata*>(&reinterpret_cast<const char*>(&(this->m_storage))[m_arraySize * sizeof(CSSValue*)]);
 }
 
 class MutableStylePropertySet : public StylePropertySet {
 public:
+    ~MutableStylePropertySet() { }
     static PassRefPtr<MutableStylePropertySet> create(CSSParserMode = CSSQuirksMode);
     static PassRefPtr<MutableStylePropertySet> create(const CSSProperty* properties, unsigned count);
 
     unsigned propertyCount() const { return m_propertyVector.size(); }
     PropertySetCSSStyleDeclaration* cssStyleDeclaration();
 
     void addParsedProperties(const Vector<CSSProperty, 256>&);
     void addParsedProperty(const CSSProperty&);
 
     // These expand shorthand properties into multiple properties.
@@ skipping 10 matching lines @@
 
     bool removeProperty(CSSPropertyID, String* returnText = 0);
     void removePrefixedOrUnprefixedProperty(CSSPropertyID);
     void removeBlockProperties();
     bool removePropertiesInSet(const CSSPropertyID* set, unsigned length);
     void removeEquivalentProperties(const StylePropertySet*);
     void removeEquivalentProperties(const CSSStyleDeclaration*);
     bool removeVariable(const AtomicString& name);
     bool clearVariables();
 
+    PassRefPtr<CSSVariablesIterator> variablesIterator() { return VariablesIterator::create(this); }
+
     void mergeAndOverrideOnConflict(const StylePropertySet*);
 
     void clear();
     void parseDeclaration(const String& styleDeclaration, StyleSheetContents* contextStyleSheet);
 
     CSSStyleDeclaration* ensureCSSStyleDeclaration();
     CSSStyleDeclaration* ensureInlineCSSStyleDeclaration(Element* parentElement);
 
     Vector<CSSProperty, 4> m_propertyVector;
 
 private:
+    class VariablesIterator : public CSSVariablesIterator {
+    public:
+        virtual ~VariablesIterator() { }
+        static PassRefPtr<VariablesIterator> create(MutableStylePropertySet*);
+    private:
+        explicit VariablesIterator(MutableStylePropertySet* propertySet) : m_propertySet(propertySet) { }
+        void takeRemainingNames(Vector<AtomicString>& remainingNames) { m_remainingNames.swap(remainingNames); }
+        virtual void advance() OVERRIDE;
+        virtual bool atEnd() const OVERRIDE { return m_remainingNames.isEmpty(); }
+        virtual AtomicString name() const OVERRIDE { return m_remainingNames.last(); }
+        virtual String value() const OVERRIDE { return m_propertySet->variableValue(name()); }
+        virtual void addedVariable(const AtomicString& name) OVERRIDE;
+        virtual void removedVariable(const AtomicString& name) OVERRIDE;
+        virtual void clearedVariables() OVERRIDE;
+
+        RefPtr<MutableStylePropertySet> m_propertySet;
+        Vector<AtomicString> m_remainingNames;
+        Vector<AtomicString> m_newNames;
+    };
+
     explicit MutableStylePropertySet(CSSParserMode);
     explicit MutableStylePropertySet(const StylePropertySet&);
     MutableStylePropertySet(const CSSProperty* properties, unsigned count);
 
     bool removeShorthandProperty(CSSPropertyID);
     CSSProperty* findCSSPropertyWithID(CSSPropertyID);
     OwnPtr<PropertySetCSSStyleDeclaration> m_cssomWrapper;
 
     friend class StylePropertySet;
 };
@@ skipping 31 matching lines @@
 
     if (m_isMutable)
         delete static_cast<MutableStylePropertySet*>(this);
     else
         delete static_cast<ImmutableStylePropertySet*>(this);
 }
 
 } // namespace WebCore
 
 #endif // StylePropertySet_h