Remove OwnPtr from Blink.

third_party/WebKit/Source/core/css/parser/CSSParserImpl.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/CSSParserImpl.h"
 
 #include "core/css/CSSCustomIdentValue.h"
 #include "core/css/CSSCustomPropertyDeclaration.h"
 #include "core/css/CSSKeyframesRule.h"
 #include "core/css/CSSStyleSheet.h"
@@ skipping 10 matching lines @@
 #include "core/css/parser/CSSSelectorParser.h"
 #include "core/css/parser/CSSSupportsParser.h"
 #include "core/css/parser/CSSTokenizer.h"
 #include "core/css/parser/CSSVariableParser.h"
 #include "core/css/parser/MediaQueryParser.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/frame/Deprecation.h"
 #include "core/frame/UseCounter.h"
 #include "platform/TraceEvent.h"
+#include "wtf/PtrUtil.h"
 #include <bitset>
+#include <memory>
 
 namespace blink {
 
 CSSParserImpl::CSSParserImpl(const CSSParserContext& context, StyleSheetContents* styleSheet)
 : m_context(context)
 , m_styleSheet(styleSheet)
 , m_observerWrapper(nullptr)
 {
 }
 
@@ skipping 155 matching lines @@
         range.consume();
         if (range.peek().type() != IdentToken)
             return CSSSelectorList();
         pseudo = range.consume().value().toAtomicString();
     }
 
     range.consumeWhitespace();
     if (!range.atEnd())
         return CSSSelectorList(); // Parse error; extra tokens in @page selector
 
-    OwnPtr<CSSParserSelector> selector;
+    std::unique_ptr<CSSParserSelector> selector;
     if (!typeSelector.isNull() && pseudo.isNull()) {
         selector = CSSParserSelector::create(QualifiedName(nullAtom, typeSelector, styleSheet->defaultNamespace()));
     } else {
         selector = CSSParserSelector::create();
         if (!pseudo.isNull()) {
             selector->setMatch(CSSSelector::PagePseudoClass);
             selector->updatePseudoType(pseudo.lower());
             if (selector->pseudoType() == CSSSelector::PseudoUnknown)
                 return CSSSelectorList();
         }
         if (!typeSelector.isNull()) {
             selector->prependTagSelector(QualifiedName(nullAtom, typeSelector, styleSheet->defaultNamespace()));
         }
     }
 
     selector->setForPage();
-    Vector<OwnPtr<CSSParserSelector>> selectorVector;
+    Vector<std::unique_ptr<CSSParserSelector>> selectorVector;
     selectorVector.append(std::move(selector));
     CSSSelectorList selectorList = CSSSelectorList::adoptSelectorVector(selectorVector);
     return selectorList;
 }
 
 ImmutableStylePropertySet* CSSParserImpl::parseCustomPropertySet(CSSParserTokenRange range)
 {
     range.consumeWhitespace();
     if (range.peek().type() != LeftBraceToken)
         return nullptr;
     CSSParserTokenRange block = range.consumeBlock();
     range.consumeWhitespace();
     if (!range.atEnd())
         return nullptr;
     CSSParserImpl parser(strictCSSParserContext());
     parser.consumeDeclarationList(block, StyleRule::Style);
 
     // Drop nested @apply rules. Seems nicer to do this here instead of making
     // a different StyleRule type
     for (size_t i = parser.m_parsedProperties.size(); i--; ) {
         if (parser.m_parsedProperties[i].id() == CSSPropertyApplyAtRule)
             parser.m_parsedProperties.remove(i);
     }
 
     return createStylePropertySet(parser.m_parsedProperties, HTMLStandardMode);
 }
 
-PassOwnPtr<Vector<double>> CSSParserImpl::parseKeyframeKeyList(const String& keyList)
+std::unique_ptr<Vector<double>> CSSParserImpl::parseKeyframeKeyList(const String& keyList)
 {
     return consumeKeyframeKeyList(CSSTokenizer::Scope(keyList).tokenRange());
 }
 
 bool CSSParserImpl::supportsDeclaration(CSSParserTokenRange& range)
 {
     ASSERT(m_parsedProperties.isEmpty());
     consumeDeclaration(range, StyleRule::Style);
     bool result = !m_parsedProperties.isEmpty();
     m_parsedProperties.clear();
@@ skipping 376 matching lines @@
     const CSSParserToken& ident = prelude.consumeIncludingWhitespace();
     if (!prelude.atEnd() || !CSSVariableParser::isValidVariableName(ident))
         return; // Parse error, expected a single custom property name
     m_parsedProperties.append(CSSProperty(
         CSSPropertyApplyAtRule,
         *CSSCustomIdentValue::create(ident.value().toString())));
 }
 
 StyleRuleKeyframe* CSSParserImpl::consumeKeyframeStyleRule(CSSParserTokenRange prelude, CSSParserTokenRange block)
 {
-    OwnPtr<Vector<double>> keyList = consumeKeyframeKeyList(prelude);
+    std::unique_ptr<Vector<double>> keyList = consumeKeyframeKeyList(prelude);
     if (!keyList)
         return nullptr;
 
     if (m_observerWrapper) {
         m_observerWrapper->observer().startRuleHeader(StyleRule::Keyframe, m_observerWrapper->startOffset(prelude));
         m_observerWrapper->observer().endRuleHeader(m_observerWrapper->endOffset(prelude));
     }
 
     consumeDeclarationList(block, StyleRule::Keyframe);
     return StyleRuleKeyframe::create(std::move(keyList), createStylePropertySet(m_parsedProperties, m_context.mode()));
@@ skipping 136 matching lines @@
 {
     if (CSSCustomPropertyDeclaration* value = CSSVariableParser::parseDeclarationValue(variableName, range))
         m_parsedProperties.append(CSSProperty(CSSPropertyVariable, *value, important));
 }
 
 void CSSParserImpl::consumeDeclarationValue(CSSParserTokenRange range, CSSPropertyID unresolvedProperty, bool important, StyleRule::RuleType ruleType)
 {
     CSSPropertyParser::parseValue(unresolvedProperty, important, range, m_context, m_parsedProperties, ruleType);
 }
 
-PassOwnPtr<Vector<double>> CSSParserImpl::consumeKeyframeKeyList(CSSParserTokenRange range)
+std::unique_ptr<Vector<double>> CSSParserImpl::consumeKeyframeKeyList(CSSParserTokenRange range)
 {
-    OwnPtr<Vector<double>> result = adoptPtr(new Vector<double>);
+    std::unique_ptr<Vector<double>> result = wrapUnique(new Vector<double>);
     while (true) {
         range.consumeWhitespace();
         const CSSParserToken& token = range.consumeIncludingWhitespace();
         if (token.type() == PercentageToken && token.numericValue() >= 0 && token.numericValue() <= 100)
             result->append(token.numericValue() / 100);
         else if (token.type() == IdentToken && token.valueEqualsIgnoringASCIICase("from"))
             result->append(0);
         else if (token.type() == IdentToken && token.valueEqualsIgnoringASCIICase("to"))
             result->append(1);
         else
             return nullptr; // Parser error, invalid value in keyframe selector
         if (range.atEnd())
             return result;
         if (range.consume().type() != CommaToken)
             return nullptr; // Parser error
     }
 }
 
 } // namespace blink