Change various helper classes to transition types to get CSSValue entirely onto the gc heap.

Source/core/css/MediaList.cpp

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2006, 2010, 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,
@@ skipping 34 matching lines @@
  * However, the parsing rules for media queries are incompatible with those of HTML4
  * and are consistent with those of media queries used in CSS.
  *
  * HTML5 (at the moment of writing still work in progress) references the Media Queries
  * specification directly and thus updates the rules for HTML.
  *
  * CSS 2.1 Spec (http://www.w3.org/TR/CSS21/media.html)
  * CSS 3 Media Queries Spec (http://www.w3.org/TR/css3-mediaqueries/)
  */
 
+DEFINE_GC_INFO(MediaQuerySet);
+DEFINE_GC_INFO(MediaList);
+
 MediaQuerySet::MediaQuerySet()
 {
 }
 
 MediaQuerySet::MediaQuerySet(const MediaQuerySet& o)
-    : RefCounted<MediaQuerySet>()
-    , m_queries(o.m_queries.size())
+    : m_queries(o.m_queries.size())
 {
     for (unsigned i = 0; i < m_queries.size(); ++i)
         m_queries[i] = o.m_queries[i]->copy();
 }
 
 MediaQuerySet::~MediaQuerySet()
 {
 }
 
-PassRefPtr<MediaQuerySet> MediaQuerySet::create(const String& mediaString)
+PassRefPtrWillBeRawPtr<MediaQuerySet> MediaQuerySet::create(const String& mediaString)
 {
     if (mediaString.isEmpty())
         return MediaQuerySet::create();
 
     BisonCSSParser parser(strictCSSParserContext());
     return parser.parseMediaQueryList(mediaString);
 }
 
 bool MediaQuerySet::set(const String& mediaString)
 {
-    RefPtr<MediaQuerySet> result = create(mediaString);
+    RefPtrWillBeRawPtr<MediaQuerySet> result = create(mediaString);
     m_queries.swap(result->m_queries);
     return true;
 }
 
 bool MediaQuerySet::add(const String& queryString)
 {
     // To "parse a media query" for a given string means to follow "the parse
     // a media query list" steps and return "null" if more than one media query
     // is returned, or else the returned media query.
-    RefPtr<MediaQuerySet> result = create(queryString);
+    RefPtrWillBeRawPtr<MediaQuerySet> result = create(queryString);
 
     // Only continue if exactly one media query is found, as described above.
     if (result->m_queries.size() != 1)
         return true;
 
-    OwnPtr<MediaQuery> newQuery = result->m_queries[0].release();
+    OwnPtrWillBeRawPtr<MediaQuery> newQuery = result->m_queries[0].release();
     ASSERT(newQuery);
 
     // If comparing with any of the media queries in the collection of media
     // queries returns true terminate these steps.
     for (size_t i = 0; i < m_queries.size(); ++i) {
         MediaQuery* query = m_queries[i].get();
         if (*query == *newQuery)
             return true;
     }
 
     m_queries.append(newQuery.release());
     return true;
 }
 
 bool MediaQuerySet::remove(const String& queryStringToRemove)
 {
     // To "parse a media query" for a given string means to follow "the parse
     // a media query list" steps and return "null" if more than one media query
     // is returned, or else the returned media query.
-    RefPtr<MediaQuerySet> result = create(queryStringToRemove);
+    RefPtrWillBeRawPtr<MediaQuerySet> result = create(queryStringToRemove);
 
     // Only continue if exactly one media query is found, as described above.
     if (result->m_queries.size() != 1)
         return true;
 
-    OwnPtr<MediaQuery> newQuery = result->m_queries[0].release();
+    OwnPtrWillBeRawPtr<MediaQuery> newQuery = result->m_queries[0].release();
     ASSERT(newQuery);
 
     // Remove any media query from the collection of media queries for which
     // comparing with the media query returns true.
     bool found = false;
     for (size_t i = 0; i < m_queries.size(); ++i) {
         MediaQuery* query = m_queries[i].get();
         if (*query == *newQuery) {
             m_queries.remove(i);
             --i;
             found = true;
         }
     }
 
     return found;
 }
 
-void MediaQuerySet::addMediaQuery(PassOwnPtr<MediaQuery> mediaQuery)
+void MediaQuerySet::addMediaQuery(PassOwnPtrWillBeRawPtr<MediaQuery> mediaQuery)
 {
     m_queries.append(mediaQuery);
 }
 
 String MediaQuerySet::mediaText() const
 {
     StringBuilder text;
 
     bool first = true;
     for (size_t i = 0; i < m_queries.size(); ++i) {
         if (!first)
             text.appendLiteral(", ");
         else
             first = false;
         text.append(m_queries[i]->cssText());
     }
     return text.toString();
 }
 
+void MediaQuerySet::trace(Visitor* visitor)
+{
+    // We don't support tracing of vectors of OwnPtrs (ie. OwnPtr<Vector<OwnPtr<MediaQuery> > >).

[haraken, 2014/02/21 01:02:36]

OwnPtr<Vector<OwnPtr<MediaQuery> > > => Vector<OwnPtr<MediaQuery> >

Can we add a dummy trace for Vector<OwnPtr> and avoid adding ENABLE(OILPAN) ?

[wibling-chromium, 2014/02/21 08:43:08]

We talked a bit about this locally. We could fix the OffHeapCollectionTrait to
call the visitor->trace instead of calling the tracetrait. That would make it
work AFAICT. I will do a bit of experimenting locally with the oilpan branch to
see if that fixes the issue.
This would basically allow us to support tracing of Vector's of ownptrs
independent of whether oilpan flag is enabled.

If I instead add a dummy trace trait it would mean we could not support tracing
vector's of ownptrs even in the case where e.g. the modules wanted to do that.

[wibling-chromium, 2014/02/25 12:07:28]

I tried this above and both when calling visitor->trace in the
OffHeapCollectionTrait and when defining a dummy TraceTrait for the OwnPtr I got
into problems with the DefaultAllocatorDummyVisitor class defined in WTF and
that it was not assignable to the WebCore::Visitor class. I will leave the
ifdef's in for now and we can see if we come up with something clever in the
future.
This should go away together with the transition types.

[haraken, 2014/02/25 12:09:57]

Makes sense. Having #if in a couple of places in a transition period wouldn't be
a big deal.

+    // Since this is a transitional object we are just ifdef'ing it out when oilpan is not enabled.
+#if ENABLE(OILPAN)
+    visitor->trace(m_queries);
+#endif
+}
+
 MediaList::MediaList(MediaQuerySet* mediaQueries, CSSStyleSheet* parentSheet)
     : m_mediaQueries(mediaQueries)
     , m_parentStyleSheet(parentSheet)
     , m_parentRule(0)
 {
 }
 
 MediaList::MediaList(MediaQuerySet* mediaQueries, CSSRule* parentRule)
     : m_mediaQueries(mediaQueries)
     , m_parentStyleSheet(0)
@@ skipping 10 matching lines @@
     CSSStyleSheet::RuleMutationScope mutationScope(m_parentRule);
 
     m_mediaQueries->set(value);
 
     if (m_parentStyleSheet)
         m_parentStyleSheet->didMutate();
 }
 
 String MediaList::item(unsigned index) const
 {
-    const Vector<OwnPtr<MediaQuery> >& queries = m_mediaQueries->queryVector();
+    const WillBeHeapVector<OwnPtrWillBeMember<MediaQuery> >& queries = m_mediaQueries->queryVector();
     if (index < queries.size())
         return queries[index]->cssText();
     return String();
 }
 
 void MediaList::deleteMedium(const String& medium, ExceptionState& exceptionState)
 {
     CSSStyleSheet::RuleMutationScope mutationScope(m_parentRule);
 
     bool success = m_mediaQueries->remove(medium);
@@ skipping 18 matching lines @@
     if (m_parentStyleSheet)
         m_parentStyleSheet->didMutate();
 }
 
 void MediaList::reattach(MediaQuerySet* mediaQueries)
 {
     ASSERT(mediaQueries);
     m_mediaQueries = mediaQueries;
 }
 
+void MediaList::trace(Visitor* visitor)
+{
+    visitor->trace(m_mediaQueries);
+}
+
 static void addResolutionWarningMessageToConsole(Document* document, const String& serializedExpression, const CSSPrimitiveValue* value)
 {
     ASSERT(document);
     ASSERT(value);
 
     DEFINE_STATIC_LOCAL(String, mediaQueryMessage, ("Consider using 'dppx' units instead of '%replacementUnits%', as in CSS '%replacementUnits%' means dots-per-CSS-%lengthUnit%, not dots-per-physical-%lengthUnit%, so does not correspond to the actual '%replacementUnits%' of a screen. In media query expression: "));
     DEFINE_STATIC_LOCAL(String, mediaValueDPI, ("dpi"));
     DEFINE_STATIC_LOCAL(String, mediaValueDPCM, ("dpcm"));
     DEFINE_STATIC_LOCAL(String, lengthUnitInch, ("inch"));
     DEFINE_STATIC_LOCAL(String, lengthUnitCentimeter, ("centimeter"));
@@ skipping 16 matching lines @@
     return mediaFeature == MediaFeatureNames::resolutionMediaFeature
         || mediaFeature == MediaFeatureNames::maxResolutionMediaFeature
         || mediaFeature == MediaFeatureNames::minResolutionMediaFeature;
 }
 
 void reportMediaQueryWarningIfNeeded(Document* document, const MediaQuerySet* mediaQuerySet)
 {
     if (!mediaQuerySet || !document)
         return;
 
-    const Vector<OwnPtr<MediaQuery> >& mediaQueries = mediaQuerySet->queryVector();
+    const WillBeHeapVector<OwnPtrWillBeMember<MediaQuery> >& mediaQueries = mediaQuerySet->queryVector();
     const size_t queryCount = mediaQueries.size();
 
     if (!queryCount)
         return;
 
     for (size_t i = 0; i < queryCount; ++i) {
         const MediaQuery* query = mediaQueries[i].get();
         if (equalIgnoringCase(query->mediaType(), "print"))
             continue;
 
         const ExpressionVector& expressions = query->expressions();
         for (size_t j = 0; j < expressions.size(); ++j) {
             const MediaQueryExp* expression = expressions.at(j).get();
             if (isResolutionMediaFeature(expression->mediaFeature())) {
                 CSSValue* cssValue =  expression->value();
                 if (cssValue && cssValue->isPrimitiveValue()) {
                     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(cssValue);
                     if (primitiveValue->isDotsPerInch() || primitiveValue->isDotsPerCentimeter())
                         addResolutionWarningMessageToConsole(document, mediaQuerySet->mediaText(), primitiveValue);
                 }
             }
         }
     }
 }
 
 }