Move MediaQuery classes off BlinkGC heap

third_party/WebKit/Source/core/css/MediaQueryExp.cpp

 /*
  * CSS Media Query
  *
  * Copyright (C) 2006 Kimmo Kinnunen <kimmo.t.kinnunen@nokia.com>.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
  * Copyright (C) 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ skipping 198 matching lines @@
          m_mediaFeature == shapeMediaFeature;
 }
 
 MediaQueryExp::MediaQueryExp(const MediaQueryExp& other)
     : m_mediaFeature(other.mediaFeature()), m_expValue(other.expValue()) {}
 
 MediaQueryExp::MediaQueryExp(const String& mediaFeature,
                              const MediaQueryExpValue& expValue)
     : m_mediaFeature(mediaFeature), m_expValue(expValue) {}
 
-MediaQueryExp* MediaQueryExp::createIfValid(
+MediaQueryExp MediaQueryExp::create(
     const String& mediaFeature,
     const Vector<CSSParserToken, 4>& tokenList) {
   ASSERT(!mediaFeature.isNull());
 
   MediaQueryExpValue expValue;
   String lowerMediaFeature = attemptStaticStringCreation(mediaFeature.lower());
 
   // Create value for media query expression that must have 1 or more values.
   if (tokenList.size() == 0 && featureWithoutValue(lowerMediaFeature)) {
     // Valid, creates a MediaQueryExp with an 'invalid' MediaQueryExpValue
   } else if (tokenList.size() == 1) {
     CSSParserToken token = tokenList.front();
 
     if (token.type() == IdentToken) {
       CSSValueID ident = token.id();
       if (!featureWithValidIdent(lowerMediaFeature, ident))
-        return nullptr;
+        return invalid();
       expValue.id = ident;
       expValue.isID = true;
     } else if (token.type() == NumberToken || token.type() == PercentageToken ||
                token.type() == DimensionToken) {
       // Check for numeric token types since it is only safe for these types to
       // call numericValue.
       if (featureWithValidDensity(lowerMediaFeature, token) ||
           featureWithValidPositiveLength(lowerMediaFeature, token)) {
         // Media features that must have non-negative <density>, ie. dppx, dpi
         // or dpcm, or Media features that must have non-negative <length> or
         // number value.
         expValue.value = token.numericValue();
         expValue.unit = token.unitType();
         expValue.isValue = true;
       } else if (featureWithPositiveInteger(lowerMediaFeature, token) ||
                  featureWithPositiveNumber(lowerMediaFeature, token) ||
                  featureWithZeroOrOne(lowerMediaFeature, token)) {
         // Media features that must have non-negative integer value,
         // or media features that must have non-negative number value,
         // or media features that must have (0|1) value.
         expValue.value = token.numericValue();
         expValue.unit = CSSPrimitiveValue::UnitType::Number;
         expValue.isValue = true;
       } else {
-        return nullptr;
+        return invalid();
       }
     } else {
-      return nullptr;
+      return invalid();
     }
   } else if (tokenList.size() == 3 &&
              featureWithAspectRatio(lowerMediaFeature)) {
     // TODO(timloh): <ratio> is supposed to allow whitespace around the '/'
     // Applicable to device-aspect-ratio and aspect-ratio.
     const CSSParserToken& numerator = tokenList[0];
     const CSSParserToken& delimiter = tokenList[1];
     const CSSParserToken& denominator = tokenList[2];
     if (delimiter.type() != DelimiterToken || delimiter.delimiter() != '/')
-      return nullptr;
+      return invalid();
     if (numerator.type() != NumberToken || numerator.numericValue() <= 0 ||
         numerator.numericValueType() != IntegerValueType)
-      return nullptr;
+      return invalid();
     if (denominator.type() != NumberToken || denominator.numericValue() <= 0 ||
         denominator.numericValueType() != IntegerValueType)
-      return nullptr;
+      return invalid();
 
     expValue.numerator = (unsigned)numerator.numericValue();
     expValue.denominator = (unsigned)denominator.numericValue();
     expValue.isRatio = true;
   } else {
-    return nullptr;
+    return invalid();
   }
 
-  return new MediaQueryExp(lowerMediaFeature, expValue);
+  return MediaQueryExp(lowerMediaFeature, expValue);
 }
 
 MediaQueryExp::~MediaQueryExp() {}
 
 bool MediaQueryExp::operator==(const MediaQueryExp& other) const {
   return (other.m_mediaFeature == m_mediaFeature) &&
          ((!other.m_expValue.isValid() && !m_expValue.isValid()) ||
           (other.m_expValue.isValid() && m_expValue.isValid() &&
            other.m_expValue.equals(m_expValue)));
 }
@@ skipping 25 matching lines @@
     output.append('/');
     output.append(printNumber(denominator));
   } else if (isID) {
     output.append(getValueName(id));
   }
 
   return output.toString();
 }
 
 }  // namespace blink