Consistently use on-heap collections for StyleRuleBase descendants.

Source/core/css/ElementRuleCollector.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 57 matching lines @@
     const CSSStyleSheet* parentStyleSheet() const { return m_parentStyleSheet; }
 
 private:
     const RuleData* m_ruleData;
     unsigned m_specificity;
     CascadeScope m_cascadeScope;
     uint64_t m_position;
     const CSSStyleSheet* m_parentStyleSheet;
 };
 
+// FIXME: when transition types are gone this class can be replaced with HeapVector.

[haraken, 2014/02/26 02:20:13]

FIXME: oilpan:

[Vyacheslav Egorov (Chromium), 2014/02/26 13:12:24]

Done.

 class StyleRuleList : public RefCounted<StyleRuleList> {
 public:
     static PassRefPtr<StyleRuleList> create() { return adoptRef(new StyleRuleList()); }
-    Vector<StyleRule*> m_list;
+    WillBePersistentHeapVector<StyleRule*> m_list;

[haraken, 2014/02/26 02:20:13]

This should be WillBePersistentHeapVector<RawPtrWillBeMember<StyleRule>>.
Otherwise StyleRules are not traced, right?

[haraken, 2014/02/26 02:20:13]

Are you sure that this won't produce memory leaks? This is changing raw pointers
to Persistents.

You might want to move StyleRuleList to the heap at the same time if it isn't
that hard. (I'm not sure if moving StyleRuleList will fix the leak, but changing
raw pointers with Members will be "better" than changing raw pointers with
Persistents.)

[Erik Corry, 2014/02/26 13:01:28]

If the StyleRule stays raw, then it will not leak (the persistent will just keep
the backing store alive).

Presumably there is currently some property of pre-oilpan Blink that ensures
these are not collected during the lifetime of m_list.  When this is moved to
the heap and becomes HeapVector it will be natural to make these raw pointer
Members.

[Vyacheslav Egorov (Chromium), 2014/02/26 13:12:24]

Right thanks. I really don't like verbosity of the Collection<Member<T> > so I
always forget to write Member there.

On 2014/02/26 02:20:13, haraken wrote:
StyleRuleList is owned by stack allocated ElementRuleCollector, so no leaks will
be introduced.
I tried replacing StyleRuleList with HeapVector if ENABLE(OILPAN) as moving it
to the heap does not make much sense in terms of redundancy. However I did not
find a good way to avoid ifdef's at use sites. 

 };
 
 // ElementRuleCollector is designed to be used as a stack object.
 // Create one, ask what rules the ElementResolveContext matches
 // and then let it go out of scope.
 // FIXME: Currently it modifies the RenderStyle but should not!
 class ElementRuleCollector {
     WTF_MAKE_NONCOPYABLE(ElementRuleCollector);
 public:
     ElementRuleCollector(const ElementResolveContext&, const SelectorFilter&, RenderStyle* = 0);
@@ skipping 51 matching lines @@
 
     // Output.
     RefPtr<StaticCSSRuleList> m_cssRuleList;
     RefPtr<StyleRuleList> m_styleRuleList;
     MatchResult m_result;
 };
 
 } // namespace WebCore
 
 #endif // ElementRuleCollector_h