[Oilpan]: Make StylePropertySet fully garbage collected.

Source/core/css/resolver/MatchResult.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.
  * Copyright (C) 2013 Google 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 MatchResult_h
 #define MatchResult_h
 
 #include "core/css/RuleSet.h"
 #include "core/css/SelectorChecker.h"
+#include "platform/heap/Handle.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
 
 namespace WebCore {
 
 class StylePropertySet;
 class StyleRule;
 
 struct RuleRange {
     RuleRange(int& firstRuleIndex, int& lastRuleIndex): firstRuleIndex(firstRuleIndex), lastRuleIndex(lastRuleIndex) { }
     int& firstRuleIndex;
     int& lastRuleIndex;
 };
 
 struct MatchRanges {
     MatchRanges() : firstUARule(-1), lastUARule(-1), firstAuthorRule(-1), lastAuthorRule(-1), firstUserRule(-1), lastUserRule(-1) { }
     int firstUARule;
     int lastUARule;
     int firstAuthorRule;
     int lastAuthorRule;
     int firstUserRule;
     int lastUserRule;
     RuleRange UARuleRange() { return RuleRange(firstUARule, lastUARule); }
     RuleRange authorRuleRange() { return RuleRange(firstAuthorRule, lastAuthorRule); }
     RuleRange userRuleRange() { return RuleRange(firstUserRule, lastUserRule); }
 };
 
 struct MatchedProperties {
+    ALLOW_ONLY_INLINE_ALLOCATION();
+public:
     MatchedProperties();
     ~MatchedProperties();
 
-    RefPtr<StylePropertySet> properties;
+    void trace(Visitor*);
+
+    RefPtrWillBeWeakMember<StylePropertySet> properties;
+
     union {
         struct {
             unsigned linkMatchType : 2;
             unsigned whitelistType : 2;
         };
         // Used to make sure all memory is zero-initialized since we compute the hash over the bytes of this object.
         void* possiblyPaddedMember;
     };
 };
 
+} // 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;
 
     void addMatchedProperties(const StylePropertySet* properties, StyleRule* = 0, unsigned linkMatchType = SelectorChecker::MatchAll, PropertyWhitelistType = PropertyWhitelistNone);
 };
 
 inline bool operator==(const MatchRanges& a, const MatchRanges& b)
 {
     return a.firstUARule == b.firstUARule
@@ skipping 15 matching lines @@
 }
 
 inline bool operator!=(const MatchedProperties& a, const MatchedProperties& b)
 {
     return !(a == b);
 }
 
 } // namespace WebCore
 
 #endif // MatchResult_h