Move MediaQuery classes off BlinkGC heap

third_party/WebKit/Source/core/css/parser/MediaQueryParser.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/css/parser/MediaQueryParser.h"
 
 #include "core/MediaTypeNames.h"
 #include "core/css/parser/CSSTokenizer.h"
 #include "platform/wtf/Vector.h"
 
 namespace blink {
 
-MediaQuerySet* MediaQueryParser::ParseMediaQuerySet(
+RefPtr<MediaQuerySet> MediaQueryParser::ParseMediaQuerySet(
     const String& query_string) {
   return ParseMediaQuerySet(CSSTokenizer(query_string).TokenRange());
 }
 
-MediaQuerySet* MediaQueryParser::ParseMediaQuerySet(CSSParserTokenRange range) {
+RefPtr<MediaQuerySet> MediaQueryParser::ParseMediaQuerySet(
+    CSSParserTokenRange range) {
   return MediaQueryParser(kMediaQuerySetParser).ParseImpl(range);
 }
 
-MediaQuerySet* MediaQueryParser::ParseMediaCondition(
+RefPtr<MediaQuerySet> MediaQueryParser::ParseMediaCondition(
     CSSParserTokenRange range) {
   return MediaQueryParser(kMediaConditionParser).ParseImpl(range);
 }
 
 const MediaQueryParser::State MediaQueryParser::kReadRestrictor =
     &MediaQueryParser::ReadRestrictor;
 const MediaQueryParser::State MediaQueryParser::kReadMediaNot =
     &MediaQueryParser::ReadMediaNot;
 const MediaQueryParser::State MediaQueryParser::kReadMediaType =
     &MediaQueryParser::ReadMediaType;
@@ skipping 186 matching lines @@
 
   HandleBlocks(token);
   block_watcher_.HandleToken(token);
 
   // Call the function that handles current state
   if (type != kWhitespaceToken)
     ((this)->*(state_))(type, token);
 }
 
 // The state machine loop
-MediaQuerySet* MediaQueryParser::ParseImpl(CSSParserTokenRange range) {
+RefPtr<MediaQuerySet> MediaQueryParser::ParseImpl(CSSParserTokenRange range) {
   while (!range.AtEnd())
     ProcessToken(range.Consume());
 
   // FIXME: Can we get rid of this special case?
   if (parser_type_ == kMediaQuerySetParser)
     ProcessToken(CSSParserToken(kEOFToken));
 
   if (state_ != kReadAnd && state_ != kReadRestrictor && state_ != kDone &&
       state_ != kReadMediaNot)
     query_set_->AddMediaQuery(MediaQuery::CreateNotAll());
@@ skipping 10 matching lines @@
 
 void MediaQueryData::Clear() {
   restrictor_ = MediaQuery::kNone;
   media_type_ = MediaTypeNames::all;
   media_type_set_ = false;
   media_feature_ = String();
   value_list_.clear();
   expressions_.clear();
 }
 
-MediaQuery* MediaQueryData::TakeMediaQuery() {
-  MediaQuery* media_query = MediaQuery::Create(
+std::unique_ptr<MediaQuery> MediaQueryData::TakeMediaQuery() {
+  std::unique_ptr<MediaQuery> media_query = MediaQuery::Create(
       restrictor_, std::move(media_type_), std::move(expressions_));
   Clear();
   return media_query;
 }
 
 bool MediaQueryData::AddExpression() {
-  MediaQueryExp* expression =
-      MediaQueryExp::CreateIfValid(media_feature_, value_list_);
-  bool is_valid = !!expression;
+  MediaQueryExp expression = MediaQueryExp::Create(media_feature_, value_list_);
   expressions_.push_back(expression);
   value_list_.clear();
-  return is_valid;
+  return expression.IsValid();
 }
 
 bool MediaQueryData::TryAddParserToken(CSSParserTokenType type,
                                        const CSSParserToken& token) {
   if (type == kNumberToken || type == kPercentageToken ||
       type == kDimensionToken || type == kDelimiterToken ||
       type == kIdentToken) {
     value_list_.push_back(token);
     return true;
   }
 
   return false;
 }
 
 void MediaQueryData::SetMediaType(const String& media_type) {
   media_type_ = media_type;
   media_type_set_ = true;
 }
 
 }  // namespace blink