Introduce TerminatedArray<T> type to make data-structure used by RuleSet visible at the type level.

Source/core/css/RuleSet.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 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,
@@ skipping 96 matching lines @@
 
 struct SameSizeAsRuleData {
     void* a;
     unsigned b;
     unsigned c;
     unsigned d[4];
 };
 
 COMPILE_ASSERT(sizeof(RuleData) == sizeof(SameSizeAsRuleData), RuleData_should_stay_small);
 
+template<typename T>
+class TerminatedArray {

[abarth-chromium, 2014/03/04 19:03:35]

Can you move this into it's own header in WTF?

[Erik Corry, 2014/03/05 11:43:52]

I think this is rather too hacky to move to WTF.  There are a lot of potential
footguns in this code and it's only used one place.  I think once we are fully
moved to Oilpan we can make Vector work well enough that this is no longer
necessary and we can get rid of it again.

[Vyacheslav Egorov (Chromium), 2014/03/05 12:44:07]

I decided to move both TerminatedArray and TerminatedArrayBuilder into separate
files and into WTF namespace. 

I agree with Erik that they are quite hackish and preferably should go away, but
right now having them in the WTF seems like the right thing to do especially in
the light of forthcomming changes that are going to parameterize TerminatedArray
with HeapAllocator. 

Having all these details in the RuleSet.h seems like incorrect thing to do.

+    WTF_MAKE_FAST_ALLOCATED;

[haraken, 2014/03/05 01:47:06]

Add WTF_MAKE_NONCOPYABLE(TerminatedArray).

[Vyacheslav Egorov (Chromium), 2014/03/05 12:44:07]

Done.

+public:
+    static PassOwnPtr<TerminatedArray> create(size_t capacity)
+    {
+        return adoptPtr(static_cast<TerminatedArray*>(fastMalloc(capacity * sizeof(T))));

[Erik Corry, 2014/03/05 11:43:52]

Consider using zeroed malloc here, since normally the constructor for T is not
called.

[Vyacheslav Egorov (Chromium), 2014/03/05 12:44:07]

I will all be filled with real objects, so zeroing memory is not necessary. I
will move create() and realloc() to private section and make
TerminatedArrayBuilder a friend of this class.

+    }
+
+    PassOwnPtr<TerminatedArray> realloc(size_t capacity)

[haraken, 2014/03/05 01:47:06]

realloc => resize ?

[Vyacheslav Egorov (Chromium), 2014/03/05 12:44:07]

Done.

+    {
+        return adoptPtr(static_cast<TerminatedArray*>(fastRealloc(this, capacity * sizeof(T))));
+    }
+
+    T& at(size_t idx) { return reinterpret_cast<T*>(this)[idx]; }

[abarth-chromium, 2014/03/04 19:03:35]

idx -> index

[Vyacheslav Egorov (Chromium), 2014/03/05 12:44:07]

Done.

+    const T& at(size_t idx) const { return reinterpret_cast<const T*>(this)[idx]; }

[haraken, 2014/03/05 01:47:06]

Shall we add operator[] ?

[Vyacheslav Egorov (Chromium), 2014/03/05 12:44:07]

It will be useless because we pass these arrays by pointer everywhere right now.

+
+    template<typename U>
+    class iterator_base {
+    public:
+        iterator_base& operator++()
+        {
+            if (m_val->isLastInArray()) {
+                m_val = 0;
+            } else {
+                ++m_val;
+            }
+            return *this;
+        }
+
+        U& operator*() const { return *m_val; }
+
+        bool operator!=(const iterator_base& other) { return m_val != other.m_val; }

[haraken, 2014/03/05 01:47:06]

Shall we add operator== ?

[Vyacheslav Egorov (Chromium), 2014/03/05 12:44:07]

Done.

+
+    private:
+        iterator_base(U* val) : m_val(val) { }
+
+        U* m_val;
+
+        friend class TerminatedArray;
+    };
+
+    typedef iterator_base<T> iterator;
+    typedef iterator_base<const T> const_iterator;
+
+    iterator begin() { return iterator(reinterpret_cast<T*>(this)); }
+    const_iterator begin() const { return const_iterator(reinterpret_cast<const T*>(this)); }
+
+    iterator end() { return iterator(0); }
+    const_iterator end() const { return const_iterator(0); }
+
+    size_t size() const

[wibling-chromium, 2014/03/05 09:28:32]

Consider adding a comment describing how this datastructure should be used.
AFAICT you cannot iterate over the elements to determine the size unless the
caller has ensured there are no holes (empty elements) inline with non-empty
elements. Also it might be worth adding that only types with an isLastInArray
method can be used.

[Vyacheslav Egorov (Chromium), 2014/03/05 12:44:07]

Done.

+    {
+        size_t count = 0;
+        for (const_iterator it = begin(); it != end(); ++it)
+            count++;
+        return count;
+    }
+};
+
 class RuleSet {
     WTF_MAKE_NONCOPYABLE(RuleSet); WTF_MAKE_FAST_ALLOCATED;
 public:
     static PassOwnPtr<RuleSet> create() { return adoptPtr(new RuleSet); }
 
     void addRulesFromSheet(StyleSheetContents*, const MediaQueryEvaluator&, AddRuleFlags = RuleHasNoSpecialState);
     void addStyleRule(StyleRule*, AddRuleFlags);
     void addRule(StyleRule*, unsigned selectorIndex, AddRuleFlags);
 
     const RuleFeatureSet& features() const { return m_features; }
 
-    const RuleData* idRules(const AtomicString& key) const { ASSERT(!m_pendingRules); return m_idRules.get(key); }
-    const RuleData* classRules(const AtomicString& key) const { ASSERT(!m_pendingRules); return m_classRules.get(key); }
-    const RuleData* tagRules(const AtomicString& key) const { ASSERT(!m_pendingRules); return m_tagRules.get(key); }
-    const RuleData* shadowPseudoElementRules(const AtomicString& key) const { ASSERT(!m_pendingRules); return m_shadowPseudoElementRules.get(key); }
+    const TerminatedArray<RuleData>* idRules(const AtomicString& key) const { ASSERT(!m_pendingRules); return m_idRules.get(key); }
+    const TerminatedArray<RuleData>* classRules(const AtomicString& key) const { ASSERT(!m_pendingRules); return m_classRules.get(key); }
+    const TerminatedArray<RuleData>* tagRules(const AtomicString& key) const { ASSERT(!m_pendingRules); return m_tagRules.get(key); }
+    const TerminatedArray<RuleData>* shadowPseudoElementRules(const AtomicString& key) const { ASSERT(!m_pendingRules); return m_shadowPseudoElementRules.get(key); }
     const Vector<RuleData>* linkPseudoClassRules() const { ASSERT(!m_pendingRules); return &m_linkPseudoClassRules; }
     const Vector<RuleData>* cuePseudoRules() const { ASSERT(!m_pendingRules); return &m_cuePseudoRules; }
     const Vector<RuleData>* focusPseudoClassRules() const { ASSERT(!m_pendingRules); return &m_focusPseudoClassRules; }
     const Vector<RuleData>* universalRules() const { ASSERT(!m_pendingRules); return &m_universalRules; }
     const WillBeHeapVector<RawPtrWillBeMember<StyleRulePage> >& pageRules() const { ASSERT(!m_pendingRules); return m_pageRules; }
     const WillBeHeapVector<RawPtrWillBeMember<StyleRuleViewport> >& viewportRules() const { ASSERT(!m_pendingRules); return m_viewportRules; }
     const WillBeHeapVector<RawPtrWillBeMember<StyleRuleFontFace> >& fontFaceRules() const { return m_fontFaceRules; }
     const WillBeHeapVector<RawPtrWillBeMember<StyleRuleKeyframes> >& keyframesRules() const { return m_keyframesRules; }
     const Vector<MinimalRuleData>& treeBoundaryCrossingRules() const { return m_treeBoundaryCrossingRules; }
     const Vector<MinimalRuleData>& shadowDistributedRules() const { return m_shadowDistributedRules; }
@@ skipping 15 matching lines @@
     struct RuleSetSelectorPair {
         RuleSetSelectorPair(const CSSSelector* selector, PassOwnPtr<RuleSet> ruleSet) : selector(selector), ruleSet(ruleSet) { }
         RuleSetSelectorPair(const RuleSetSelectorPair& rs) : selector(rs.selector), ruleSet(const_cast<RuleSetSelectorPair*>(&rs)->ruleSet.release()) { }
 
         const CSSSelector* selector;
         OwnPtr<RuleSet> ruleSet;
     };
 
 private:
     typedef HashMap<AtomicString, OwnPtr<LinkedStack<RuleData> > > PendingRuleMap;
-    typedef HashMap<AtomicString, OwnPtr<RuleData> > CompactRuleMap;
+    typedef HashMap<AtomicString, OwnPtr<TerminatedArray<RuleData> > > CompactRuleMap;
 
     RuleSet()
         : m_ruleCount(0)
     {
     }
 
     void addToRuleSet(const AtomicString& key, PendingRuleMap&, const RuleData&);
     void addPageRule(StyleRulePage*);
     void addViewportRule(StyleRuleViewport*);
     void addFontFaceRule(StyleRuleFontFace*);
@@ skipping 41 matching lines @@
     OwnPtr<PendingRuleMaps> m_pendingRules;
 
 #ifndef NDEBUG
     Vector<RuleData> m_allRules;
 #endif
 };
 
 } // namespace WebCore
 
 #endif // RuleSet_h