[Oilpan]: Make StylePropertySet fully garbage collected.

Source/core/css/resolver/MatchResult.h

Index: Source/core/css/resolver/MatchResult.h
diff --git a/Source/core/css/resolver/MatchResult.h b/Source/core/css/resolver/MatchResult.h
index 25d9b91900a50be0e24b2af3e7725e6e291714ea..b1caefd5017094ff0e1ceabdd0362cc66e0db5c5 100644
--- a/Source/core/css/resolver/MatchResult.h
+++ b/Source/core/css/resolver/MatchResult.h
@@ -25,6 +25,7 @@
 
 #include "core/css/RuleSet.h"
 #include "core/css/SelectorChecker.h"
+#include "platform/heap/Handle.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
 
@@ -53,10 +54,15 @@ struct MatchRanges {
 };
 
 struct MatchedProperties {
+    ALLOW_ONLY_INLINE_ALLOCATION();
+public:
     MatchedProperties();
     ~MatchedProperties();
 
-    RefPtr<StylePropertySet> properties;
+    void trace(Visitor*);
+
+    RefPtrWillBeWeakMember<StylePropertySet> properties;
+
     union {
         struct {
             unsigned linkMatchType : 2;
@@ -67,11 +73,23 @@ struct MatchedProperties {
     };
 };
 
+} // WebCore namespace
+
+namespace WTF {

[Mads Ager (chromium), 2014/06/25 06:31:48]

You can use
WTF_ALLOW_MOVE_AND_INIT_WITH_MEM_FUNCTIONS(WebCore::MathcedProperties> here.

[wibling-chromium, 2014/06/25 09:03:27]

Done.

+template <> struct VectorTraits<WebCore::MatchedProperties> : VectorTraitsBase<WebCore::MatchedProperties> {
+    static const bool canInitializeWithMemset = true;
+    static const bool canMoveWithMemcpy = true;
+};
+
+}
+
+namespace WebCore {
+
 class MatchResult {
     STACK_ALLOCATED();
 public:
     MatchResult() : isCacheable(true) { }
-    Vector<MatchedProperties, 64> matchedProperties;
+    WillBeHeapVector<MatchedProperties, 64> matchedProperties;

[Mads Ager (chromium), 2014/06/25 06:31:48]

In MatchResult you are using the normal tracing of the MatchedProperties objects
which means that the WeakMember<StylePropertySet> can be cleared out if it is
the only reference. Is that what we want? I would guess that for the MatchResult
we want the pointer in MatchedProperties to be strong.

I think we can probably use a Member instead of a weak member because the
processing of the table is controlled by the trait and therefore we can do the
custom weak processing even though the field is a Member instead of a
WeakMember?

[Erik Corry, 2014/06/25 06:58:25]

I agree in principle, but it's sort of subtle. MatchResult is on the stack so it
is only ever found conservatively, and the pointer from the MatchResult to the
backing of the vector will look just like an iterator, so the backing of the
heap vector will be scanned with strongify on.

However, MatchedProperties does not have support for special weak processing, so
it will ignore the strongify flag and just zap the weak member while leaving the
entry in the collection. Because it's a vector we don't support the full weak
processing machinery (perhaps we should) so I think just adding special weak
processing support to MatchedProperties will not work right now. So Mads'
suggestion may be better.

There was talk (for something else) of adding support for weakness in vectors
that just compacts the vector, collecting all the surviving entries near the
start. It would support iterator-based iteration over weak vectors, but it would
fail for integer based iteration which would not trigger the strongified weak
processing. (If there was a GC during iteration.)

A side effect of adding that support for weakness in vectors would be that you
could fix this case cleanly just by having the right trait for
MatchedProperties. Though in this case the
compacting-vectors-when-removing-weak-entries support would never compact the
vector because the MatchResult acts like an iterator.
It's a nice documenting of the intent to have it be a WeakMember though.

[wibling-chromium, 2014/06/25 09:03:27]

Nice catch. I have changed it be a Member instead. As you say the tracing is
conditional anyway in the specialized traceInCollection method.

     WillBeHeapVector<RawPtrWillBeMember<StyleRule>, 64> matchedRules;
     MatchRanges ranges;
     bool isCacheable;