Remove OwnPtr from Blink.

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

Index: third_party/WebKit/Source/core/css/parser/CSSSelectorParser.cpp
diff --git a/third_party/WebKit/Source/core/css/parser/CSSSelectorParser.cpp b/third_party/WebKit/Source/core/css/parser/CSSSelectorParser.cpp
index 8fac6031fe0ce2044aa6681ff0f3646af9f0df35..806f0fcfaad8fd267e1a1ef90bb3ff9d7a5d10c8 100644
--- a/third_party/WebKit/Source/core/css/parser/CSSSelectorParser.cpp
+++ b/third_party/WebKit/Source/core/css/parser/CSSSelectorParser.cpp
@@ -8,6 +8,8 @@
 #include "core/css/StyleSheetContents.h"
 #include "core/frame/UseCounter.h"
 #include "platform/RuntimeEnabledFeatures.h"
+#include "wtf/PtrUtil.h"
+#include <memory>
 
 namespace blink {
 
@@ -104,8 +106,8 @@ CSSSelectorParser::CSSSelectorParser(const CSSParserContext& context, StyleSheet
 
 CSSSelectorList CSSSelectorParser::consumeComplexSelectorList(CSSParserTokenRange& range)
 {
-    Vector<OwnPtr<CSSParserSelector>> selectorList;
-    OwnPtr<CSSParserSelector> selector = consumeComplexSelector(range);
+    Vector<std::unique_ptr<CSSParserSelector>> selectorList;
+    std::unique_ptr<CSSParserSelector> selector = consumeComplexSelector(range);
     if (!selector)
         return CSSSelectorList();
     selectorList.append(std::move(selector));
@@ -125,8 +127,8 @@ CSSSelectorList CSSSelectorParser::consumeComplexSelectorList(CSSParserTokenRang
 
 CSSSelectorList CSSSelectorParser::consumeCompoundSelectorList(CSSParserTokenRange& range)
 {
-    Vector<OwnPtr<CSSParserSelector>> selectorList;
-    OwnPtr<CSSParserSelector> selector = consumeCompoundSelector(range);
+    Vector<std::unique_ptr<CSSParserSelector>> selectorList;
+    std::unique_ptr<CSSParserSelector> selector = consumeCompoundSelector(range);
     range.consumeWhitespace();
     if (!selector)
         return CSSSelectorList();
@@ -171,9 +173,9 @@ unsigned extractCompoundFlags(const CSSParserSelector& simpleSelector, CSSParser
 
 } // namespace
 
-PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumeComplexSelector(CSSParserTokenRange& range)
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumeComplexSelector(CSSParserTokenRange& range)
 {
-    OwnPtr<CSSParserSelector> selector = consumeCompoundSelector(range);
+    std::unique_ptr<CSSParserSelector> selector = consumeCompoundSelector(range);
     if (!selector)
         return nullptr;
 
@@ -184,7 +186,7 @@ PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumeComplexSelector(CSSParse
         previousCompoundFlags |= extractCompoundFlags(*simple, m_context.mode());
 
     while (CSSSelector::RelationType combinator = consumeCombinator(range)) {
-        OwnPtr<CSSParserSelector> nextSelector = consumeCompoundSelector(range);
+        std::unique_ptr<CSSParserSelector> nextSelector = consumeCompoundSelector(range);
         if (!nextSelector)
             return combinator == CSSSelector::Descendant ? std::move(selector) : nullptr;
         if (previousCompoundFlags & HasPseudoElementForRightmostCompound)
@@ -286,9 +288,9 @@ bool isSimpleSelectorValidAfterPseudoElement(const CSSParserSelector& simpleSele
 
 } // namespace
 
-PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumeCompoundSelector(CSSParserTokenRange& range)
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumeCompoundSelector(CSSParserTokenRange& range)
 {
-    OwnPtr<CSSParserSelector> compoundSelector;
+    std::unique_ptr<CSSParserSelector> compoundSelector;
 
     AtomicString namespacePrefix;
     AtomicString elementName;
@@ -303,7 +305,7 @@ PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumeCompoundSelector(CSSPars
     if (m_context.isHTMLDocument())
         elementName = elementName.lower();
 
-    while (OwnPtr<CSSParserSelector> simpleSelector = consumeSimpleSelector(range)) {
+    while (std::unique_ptr<CSSParserSelector> simpleSelector = consumeSimpleSelector(range)) {
         // TODO(rune@opera.com): crbug.com/578131
         // The UASheetMode check is a work-around to allow this selector in mediaControls(New).css:
         // video::-webkit-media-text-track-region-container.scrolling
@@ -334,10 +336,10 @@ PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumeCompoundSelector(CSSPars
     return splitCompoundAtImplicitShadowCrossingCombinator(std::move(compoundSelector));
 }
 
-PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumeSimpleSelector(CSSParserTokenRange& range)
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumeSimpleSelector(CSSParserTokenRange& range)
 {
     const CSSParserToken& token = range.peek();
-    OwnPtr<CSSParserSelector> selector;
+    std::unique_ptr<CSSParserSelector> selector;
     if (token.type() == HashToken)
         selector = consumeId(range);
     else if (token.type() == DelimiterToken && token.delimiter() == '.')
@@ -391,33 +393,33 @@ bool CSSSelectorParser::consumeName(CSSParserTokenRange& range, AtomicString& na
     return true;
 }
 
-PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumeId(CSSParserTokenRange& range)
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumeId(CSSParserTokenRange& range)
 {
     ASSERT(range.peek().type() == HashToken);
     if (range.peek().getHashTokenType() != HashTokenId)
         return nullptr;
-    OwnPtr<CSSParserSelector> selector = CSSParserSelector::create();
+    std::unique_ptr<CSSParserSelector> selector = CSSParserSelector::create();
     selector->setMatch(CSSSelector::Id);
     AtomicString value = range.consume().value().toAtomicString();
     selector->setValue(value, isQuirksModeBehavior(m_context.matchMode()));
     return selector;
 }
 
-PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumeClass(CSSParserTokenRange& range)
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumeClass(CSSParserTokenRange& range)
 {
     ASSERT(range.peek().type() == DelimiterToken);
     ASSERT(range.peek().delimiter() == '.');
     range.consume();
     if (range.peek().type() != IdentToken)
         return nullptr;
-    OwnPtr<CSSParserSelector> selector = CSSParserSelector::create();
+    std::unique_ptr<CSSParserSelector> selector = CSSParserSelector::create();
     selector->setMatch(CSSSelector::Class);
     AtomicString value = range.consume().value().toAtomicString();
     selector->setValue(value, isQuirksModeBehavior(m_context.matchMode()));
     return selector;
 }
 
-PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumeAttribute(CSSParserTokenRange& range)
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumeAttribute(CSSParserTokenRange& range)
 {
     ASSERT(range.peek().type() == LeftBracketToken);
     CSSParserTokenRange block = range.consumeBlock();
@@ -440,7 +442,7 @@ PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumeAttribute(CSSParserToken
         ? QualifiedName(nullAtom, attributeName, nullAtom)
         : QualifiedName(namespacePrefix, attributeName, namespaceURI);
 
-    OwnPtr<CSSParserSelector> selector = CSSParserSelector::create();
+    std::unique_ptr<CSSParserSelector> selector = CSSParserSelector::create();
 
     if (block.atEnd()) {
         selector->setAttribute(qualifiedName, CSSSelector::CaseSensitive);
@@ -461,7 +463,7 @@ PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumeAttribute(CSSParserToken
     return selector;
 }
 
-PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumePseudo(CSSParserTokenRange& range)
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::consumePseudo(CSSParserTokenRange& range)
 {
     ASSERT(range.peek().type() == ColonToken);
     range.consume();
@@ -476,7 +478,7 @@ PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumePseudo(CSSParserTokenRan
     if (token.type() != IdentToken && token.type() != FunctionToken)
         return nullptr;
 
-    OwnPtr<CSSParserSelector> selector = CSSParserSelector::create();
+    std::unique_ptr<CSSParserSelector> selector = CSSParserSelector::create();
     selector->setMatch(colons == 1 ? CSSSelector::PseudoClass : CSSSelector::PseudoElement);
 
     String value = token.value().toString();
@@ -506,7 +508,7 @@ PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumePseudo(CSSParserTokenRan
         {
             DisallowPseudoElementsScope scope(this);
 
-            OwnPtr<CSSSelectorList> selectorList = adoptPtr(new CSSSelectorList());
+            std::unique_ptr<CSSSelectorList> selectorList = wrapUnique(new CSSSelectorList());
             *selectorList = consumeCompoundSelectorList(block);
             if (!selectorList->isValid() || !block.atEnd())
                 return nullptr;
@@ -515,11 +517,11 @@ PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumePseudo(CSSParserTokenRan
         }
     case CSSSelector::PseudoNot:
         {
-            OwnPtr<CSSParserSelector> innerSelector = consumeCompoundSelector(block);
+            std::unique_ptr<CSSParserSelector> innerSelector = consumeCompoundSelector(block);
             block.consumeWhitespace();
             if (!innerSelector || !innerSelector->isSimple() || !block.atEnd())
                 return nullptr;
-            Vector<OwnPtr<CSSParserSelector>> selectorVector;
+            Vector<std::unique_ptr<CSSParserSelector>> selectorVector;
             selectorVector.append(std::move(innerSelector));
             selector->adoptSelectorVector(selectorVector);
             return selector;
@@ -528,11 +530,11 @@ PassOwnPtr<CSSParserSelector> CSSSelectorParser::consumePseudo(CSSParserTokenRan
         {
             DisallowPseudoElementsScope scope(this);
 
-            OwnPtr<CSSParserSelector> innerSelector = consumeCompoundSelector(block);
+            std::unique_ptr<CSSParserSelector> innerSelector = consumeCompoundSelector(block);
             block.consumeWhitespace();
             if (!innerSelector || !block.atEnd() || !RuntimeEnabledFeatures::shadowDOMV1Enabled())
                 return nullptr;
-            Vector<OwnPtr<CSSParserSelector>> selectorVector;
+            Vector<std::unique_ptr<CSSParserSelector>> selectorVector;
             selectorVector.append(std::move(innerSelector));
             selector->adoptSelectorVector(selectorVector);
             return selector;
@@ -763,13 +765,13 @@ void CSSSelectorParser::prependTypeSelectorIfNeeded(const AtomicString& namespac
         compoundSelector->prependTagSelector(tag, determinedPrefix == nullAtom && determinedElementName == starAtom && !explicitForHost);
 }
 
-PassOwnPtr<CSSParserSelector> CSSSelectorParser::addSimpleSelectorToCompound(PassOwnPtr<CSSParserSelector> compoundSelector, PassOwnPtr<CSSParserSelector> simpleSelector)
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::addSimpleSelectorToCompound(std::unique_ptr<CSSParserSelector> compoundSelector, std::unique_ptr<CSSParserSelector> simpleSelector)
 {
     compoundSelector->appendTagHistory(CSSSelector::SubSelector, std::move(simpleSelector));
     return compoundSelector;
 }
 
-PassOwnPtr<CSSParserSelector> CSSSelectorParser::splitCompoundAtImplicitShadowCrossingCombinator(PassOwnPtr<CSSParserSelector> compoundSelector)
+std::unique_ptr<CSSParserSelector> CSSSelectorParser::splitCompoundAtImplicitShadowCrossingCombinator(std::unique_ptr<CSSParserSelector> compoundSelector)
 {
     // The tagHistory is a linked list that stores combinator separated compound selectors
     // from right-to-left. Yet, within a single compound selector, stores the simple selectors
@@ -796,7 +798,7 @@ PassOwnPtr<CSSParserSelector> CSSSelectorParser::splitCompoundAtImplicitShadowCr
     if (!splitAfter || !splitAfter->tagHistory())
         return compoundSelector;
 
-    OwnPtr<CSSParserSelector> secondCompound = splitAfter->releaseTagHistory();
+    std::unique_ptr<CSSParserSelector> secondCompound = splitAfter->releaseTagHistory();
     secondCompound->appendTagHistory(secondCompound->pseudoType() == CSSSelector::PseudoSlotted ? CSSSelector::ShadowSlot : CSSSelector::ShadowPseudo, std::move(compoundSelector));
     return secondCompound;
 }