<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[163747] trunk/Source/WebCore</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/163747">163747</a></dd>
<dt>Author</dt> <dd>zandobersek@gmail.com</dd>
<dt>Date</dt> <dd>2014-02-09 00:58:56 -0800 (Sun, 09 Feb 2014)</dd>
</dl>
<h3>Log Message</h3>
<pre>Switch the rest of CSS code from OwnPtr over to std::unique_ptr
https://bugs.webkit.org/show_bug.cgi?id=128471
Reviewed by Andreas Kling.
Replace the remaining uses of OwnPtr in the CSS code with std::unique_ptr, covering
the CSSParser, CSSParserSelector and CSSSelector classes and a few additional, closely related classes.
* css/CSSGrammar.y.in:
* css/CSSParser.cpp:
(WebCore::CSSParser::parseSheet):
(WebCore::CSSParser::parseDeclaration):
(WebCore::CSSParser::parseValue):
(WebCore::CSSParser::markSupportsRuleHeaderStart):
(WebCore::CSSParser::createKeyframesRule):
(WebCore::CSSParser::createStyleRule):
(WebCore::CSSParser::rewriteSpecifiersWithElementName):
(WebCore::CSSParser::rewriteSpecifiers):
* css/CSSParser.h:
* css/CSSParserValues.cpp:
(WebCore::CSSParserSelector::CSSParserSelector):
(WebCore::CSSParserSelector::~CSSParserSelector):
(WebCore::CSSParserSelector::adoptSelectorVector):
(WebCore::CSSParserSelector::insertTagHistory):
(WebCore::CSSParserSelector::appendTagHistory):
(WebCore::CSSParserSelector::prependTagSelector):
* css/CSSParserValues.h:
(WebCore::CSSParserSelector::releaseSelector):
(WebCore::CSSParserSelector::setTagHistory):
(WebCore::CSSParserSelector::clearTagHistory):
* css/CSSSelector.cpp:
(WebCore::CSSSelector::setSelectorList):
* css/CSSSelector.h:
* css/CSSSelectorList.cpp:
(WebCore::CSSSelectorList::adoptSelectorVector):
* css/CSSSelectorList.h:
* css/CSSValueList.cpp:
* css/StyleRule.cpp:
(WebCore::StyleRuleRegion::StyleRuleRegion):
* css/StyleRule.h:
(WebCore::StyleRule::parserAdoptSelectorVector):
(WebCore::StyleRulePage::parserAdoptSelectorVector):
(WebCore::StyleRuleRegion::create):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceWebCoreChangeLog">trunk/Source/WebCore/ChangeLog</a></li>
<li><a href="#trunkSourceWebCorecssCSSGrammaryin">trunk/Source/WebCore/css/CSSGrammar.y.in</a></li>
<li><a href="#trunkSourceWebCorecssCSSParsercpp">trunk/Source/WebCore/css/CSSParser.cpp</a></li>
<li><a href="#trunkSourceWebCorecssCSSParserh">trunk/Source/WebCore/css/CSSParser.h</a></li>
<li><a href="#trunkSourceWebCorecssCSSParserValuescpp">trunk/Source/WebCore/css/CSSParserValues.cpp</a></li>
<li><a href="#trunkSourceWebCorecssCSSParserValuesh">trunk/Source/WebCore/css/CSSParserValues.h</a></li>
<li><a href="#trunkSourceWebCorecssCSSSelectorcpp">trunk/Source/WebCore/css/CSSSelector.cpp</a></li>
<li><a href="#trunkSourceWebCorecssCSSSelectorh">trunk/Source/WebCore/css/CSSSelector.h</a></li>
<li><a href="#trunkSourceWebCorecssCSSSelectorListcpp">trunk/Source/WebCore/css/CSSSelectorList.cpp</a></li>
<li><a href="#trunkSourceWebCorecssCSSSelectorListh">trunk/Source/WebCore/css/CSSSelectorList.h</a></li>
<li><a href="#trunkSourceWebCorecssCSSValueListcpp">trunk/Source/WebCore/css/CSSValueList.cpp</a></li>
<li><a href="#trunkSourceWebCorecssStyleRulecpp">trunk/Source/WebCore/css/StyleRule.cpp</a></li>
<li><a href="#trunkSourceWebCorecssStyleRuleh">trunk/Source/WebCore/css/StyleRule.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/ChangeLog (163746 => 163747)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/ChangeLog 2014-02-09 08:33:19 UTC (rev 163746)
+++ trunk/Source/WebCore/ChangeLog 2014-02-09 08:58:56 UTC (rev 163747)
</span><span class="lines">@@ -1,5 +1,51 @@
</span><span class="cx"> 2014-02-09 Zan Dobersek <zdobersek@igalia.com>
</span><span class="cx">
</span><ins>+ Switch the rest of CSS code from OwnPtr over to std::unique_ptr
+ https://bugs.webkit.org/show_bug.cgi?id=128471
+
+ Reviewed by Andreas Kling.
+
+ Replace the remaining uses of OwnPtr in the CSS code with std::unique_ptr, covering
+ the CSSParser, CSSParserSelector and CSSSelector classes and a few additional, closely related classes.
+
+ * css/CSSGrammar.y.in:
+ * css/CSSParser.cpp:
+ (WebCore::CSSParser::parseSheet):
+ (WebCore::CSSParser::parseDeclaration):
+ (WebCore::CSSParser::parseValue):
+ (WebCore::CSSParser::markSupportsRuleHeaderStart):
+ (WebCore::CSSParser::createKeyframesRule):
+ (WebCore::CSSParser::createStyleRule):
+ (WebCore::CSSParser::rewriteSpecifiersWithElementName):
+ (WebCore::CSSParser::rewriteSpecifiers):
+ * css/CSSParser.h:
+ * css/CSSParserValues.cpp:
+ (WebCore::CSSParserSelector::CSSParserSelector):
+ (WebCore::CSSParserSelector::~CSSParserSelector):
+ (WebCore::CSSParserSelector::adoptSelectorVector):
+ (WebCore::CSSParserSelector::insertTagHistory):
+ (WebCore::CSSParserSelector::appendTagHistory):
+ (WebCore::CSSParserSelector::prependTagSelector):
+ * css/CSSParserValues.h:
+ (WebCore::CSSParserSelector::releaseSelector):
+ (WebCore::CSSParserSelector::setTagHistory):
+ (WebCore::CSSParserSelector::clearTagHistory):
+ * css/CSSSelector.cpp:
+ (WebCore::CSSSelector::setSelectorList):
+ * css/CSSSelector.h:
+ * css/CSSSelectorList.cpp:
+ (WebCore::CSSSelectorList::adoptSelectorVector):
+ * css/CSSSelectorList.h:
+ * css/CSSValueList.cpp:
+ * css/StyleRule.cpp:
+ (WebCore::StyleRuleRegion::StyleRuleRegion):
+ * css/StyleRule.h:
+ (WebCore::StyleRule::parserAdoptSelectorVector):
+ (WebCore::StyleRulePage::parserAdoptSelectorVector):
+ (WebCore::StyleRuleRegion::create):
+
+2014-02-09 Zan Dobersek <zdobersek@igalia.com>
+
</ins><span class="cx"> Manage MutationObserverInterestGroup through std::unique_ptr
</span><span class="cx"> https://bugs.webkit.org/show_bug.cgi?id=128468
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSGrammaryin"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSGrammar.y.in (163746 => 163747)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSGrammar.y.in 2014-02-09 08:33:19 UTC (rev 163746)
+++ trunk/Source/WebCore/css/CSSGrammar.y.in 2014-02-09 08:58:56 UTC (rev 163747)
</span><span class="lines">@@ -238,7 +238,7 @@
</span><span class="cx"> %type <selector> attrib class page_selector pseudo pseudo_page selector selector_with_trailing_whitespace simple_selector specifier specifier_list
</span><span class="cx"> %destructor { delete $$; } attrib class page_selector pseudo pseudo_page selector selector_with_trailing_whitespace simple_selector specifier specifier_list
</span><span class="cx">
</span><del>-%union { Vector<OwnPtr<CSSParserSelector>>* selectorList; }
</del><ins>+%union { Vector<std::unique_ptr<CSSParserSelector>>* selectorList; }
</ins><span class="cx"> %type <selectorList> selector_list simple_selector_list
</span><span class="cx"> %destructor { delete $$; } selector_list simple_selector_list
</span><span class="cx">
</span><span class="lines">@@ -317,7 +317,7 @@
</span><span class="cx"> webkit_value:
</span><span class="cx"> WEBKIT_VALUE_SYM '{' maybe_space expr '}' {
</span><span class="cx"> if ($4) {
</span><del>- parser->m_valueList = adoptPtr($4);
</del><ins>+ parser->m_valueList = std::unique_ptr<CSSParserValueList>($4);
</ins><span class="cx"> int oldParsedProperties = parser->m_parsedProperties.size();
</span><span class="cx"> if (!parser->parseValue(parser->m_id, parser->m_important))
</span><span class="cx"> parser->rollbackLastProperties(parser->m_parsedProperties.size() - oldParsedProperties);
</span><span class="lines">@@ -333,7 +333,7 @@
</span><span class="cx"> if ($4) {
</span><span class="cx"> if (parser->m_selectorListForParseSelector)
</span><span class="cx"> parser->m_selectorListForParseSelector->adoptSelectorVector(*$4);
</span><del>- parser->recycleSelectorVector(adoptPtr($4));
</del><ins>+ parser->recycleSelectorVector(std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>>($4));
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> ;
</span><span class="lines">@@ -501,7 +501,7 @@
</span><span class="cx"> maybe_media_restrictor maybe_space '(' maybe_space IDENT maybe_space maybe_media_value ')' maybe_space {
</span><span class="cx"> // If restrictor is specified, media query expression is invalid.
</span><span class="cx"> // Create empty media query expression and continue parsing media query.
</span><del>- OwnPtr<CSSParserValueList> mediaValue = adoptPtr($7);
</del><ins>+ std::unique_ptr<CSSParserValueList> mediaValue($7);
</ins><span class="cx"> if ($1 != MediaQuery::None)
</span><span class="cx"> $$ = new MediaQueryExp(emptyString(), nullptr);
</span><span class="cx"> else {
</span><span class="lines">@@ -597,10 +597,10 @@
</span><span class="cx">
</span><span class="cx"> media:
</span><span class="cx"> before_media_rule MEDIA_SYM maybe_space media_list at_rule_header_end '{' at_rule_body_start maybe_space block_rule_list save_block {
</span><del>- $$ = parser->createMediaRule(adoptRef($4), adoptPtr($9).get()).leakRef();
</del><ins>+ $$ = parser->createMediaRule(adoptRef($4), std::unique_ptr<Vector<RefPtr<StyleRuleBase>>>($9).get()).leakRef();
</ins><span class="cx"> }
</span><span class="cx"> | before_media_rule MEDIA_SYM at_rule_header_end_maybe_space '{' at_rule_body_start maybe_space block_rule_list save_block {
</span><del>- $$ = parser->createEmptyMediaRule(adoptPtr($7).get()).leakRef();
</del><ins>+ $$ = parser->createEmptyMediaRule(std::unique_ptr<Vector<RefPtr<StyleRuleBase>>>($7).get()).leakRef();
</ins><span class="cx"> }
</span><span class="cx"> | before_media_rule MEDIA_SYM at_rule_header_end_maybe_space ';' {
</span><span class="cx"> $$ = nullptr;
</span><span class="lines">@@ -612,7 +612,7 @@
</span><span class="cx">
</span><span class="cx"> supports:
</span><span class="cx"> before_supports_rule SUPPORTS_SYM maybe_space supports_condition at_supports_rule_header_end '{' at_rule_body_start maybe_space block_rule_list save_block {
</span><del>- $$ = parser->createSupportsRule($4, adoptPtr($9).get()).leakRef();
</del><ins>+ $$ = parser->createSupportsRule($4, std::unique_ptr<Vector<RefPtr<StyleRuleBase>>>($9).get()).leakRef();
</ins><span class="cx"> }
</span><span class="cx"> | before_supports_rule SUPPORTS_SYM supports_error {
</span><span class="cx"> $$ = nullptr;
</span><span class="lines">@@ -661,9 +661,9 @@
</span><span class="cx"> '(' maybe_space property ':' maybe_space expr priority ')' maybe_space {
</span><span class="cx"> $$ = false;
</span><span class="cx"> CSSParser* p = static_cast<CSSParser*>(parser);
</span><del>- OwnPtr<CSSParserExpression> propertyValue = adoptPtr($6);
</del><ins>+ std::unique_ptr<CSSParserExpression> propertyValue($6);
</ins><span class="cx"> if ($3 && propertyValue) {
</span><del>- p->m_valueList = propertyValue.release();
</del><ins>+ p->m_valueList = std::move(propertyValue);
</ins><span class="cx"> int oldParsedProperties = p->m_parsedProperties.size();
</span><span class="cx"> $$ = p->parseValue($3, $7);
</span><span class="cx"> // We just need to know if the declaration is supported as it is written. Rollback any additions.
</span><span class="lines">@@ -685,7 +685,7 @@
</span><span class="cx">
</span><span class="cx"> keyframes:
</span><span class="cx"> before_keyframes_rule WEBKIT_KEYFRAMES_SYM maybe_space keyframe_name at_rule_header_end_maybe_space '{' at_rule_body_start maybe_space keyframes_rule closing_brace {
</span><del>- $$ = parser->createKeyframesRule($4, adoptPtr($9)).leakRef();
</del><ins>+ $$ = parser->createKeyframesRule($4, std::unique_ptr<Vector<RefPtr<StyleKeyframe>>>($9)).leakRef();
</ins><span class="cx"> }
</span><span class="cx"> ;
</span><span class="cx">
</span><span class="lines">@@ -700,7 +700,7 @@
</span><span class="cx"> }
</span><span class="cx"> ;
</span><span class="cx">
</span><del>-keyframe_rule: key_list maybe_space '{' maybe_space declaration_list closing_brace { $$ = parser->createKeyframe(*adoptPtr($1)).leakRef(); } ;
</del><ins>+keyframe_rule: key_list maybe_space '{' maybe_space declaration_list closing_brace { $$ = parser->createKeyframe(*std::unique_ptr<CSSParserValueList>($1)).leakRef(); } ;
</ins><span class="cx">
</span><span class="cx"> key_list:
</span><span class="cx"> key {
</span><span class="lines">@@ -744,7 +744,7 @@
</span><span class="cx"> before_page_rule PAGE_SYM maybe_space page_selector at_rule_header_end_maybe_space
</span><span class="cx"> '{' at_rule_body_start maybe_space_before_declaration declarations_and_margins closing_brace {
</span><span class="cx"> if ($4)
</span><del>- $$ = parser->createPageRule(adoptPtr($4)).leakRef();
</del><ins>+ $$ = parser->createPageRule(std::unique_ptr<CSSParserSelector>($4)).leakRef();
</ins><span class="cx"> else {
</span><span class="cx"> // Clear properties in the invalid @page rule.
</span><span class="cx"> parser->clearProperties();
</span><span class="lines">@@ -904,9 +904,9 @@
</span><span class="cx">
</span><span class="cx"> region:
</span><span class="cx"> before_region_rule WEBKIT_REGION_RULE_SYM maybe_space selector_list at_rule_header_end '{' at_rule_body_start maybe_space block_valid_rule_list save_block {
</span><del>- OwnPtr<Vector<RefPtr<StyleRuleBase>>> ruleList = adoptPtr($9);
</del><ins>+ std::unique_ptr<Vector<RefPtr<StyleRuleBase>>> ruleList($9);
</ins><span class="cx"> if ($4)
</span><del>- $$ = parser->createRegionRule(adoptPtr($4).get(), ruleList.get()).leakRef();
</del><ins>+ $$ = parser->createRegionRule(std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>>($4).get(), ruleList.get()).leakRef();
</ins><span class="cx"> else {
</span><span class="cx"> $$ = nullptr;
</span><span class="cx"> parser->popRuleData();
</span><span class="lines">@@ -940,7 +940,7 @@
</span><span class="cx"> ruleset:
</span><span class="cx"> before_selector_list selector_list at_selector_end at_rule_header_end '{' at_rule_body_start maybe_space_before_declaration declaration_list closing_brace {
</span><span class="cx"> $$ = parser->createStyleRule($2).leakRef();
</span><del>- parser->recycleSelectorVector(adoptPtr($2));
</del><ins>+ parser->recycleSelectorVector(std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>>($2));
</ins><span class="cx"> }
</span><span class="cx"> ;
</span><span class="cx">
</span><span class="lines">@@ -950,18 +950,18 @@
</span><span class="cx"> selector %prec UNIMPORTANT_TOK {
</span><span class="cx"> $$ = nullptr;
</span><span class="cx"> if ($1) {
</span><del>- $$ = parser->createSelectorVector().leakPtr();
- $$->append(adoptPtr($1));
</del><ins>+ $$ = parser->createSelectorVector().release();
+ $$->append(std::unique_ptr<CSSParserSelector>($1));
</ins><span class="cx"> parser->updateLastSelectorLineAndPosition();
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> | selector_list at_selector_end ',' maybe_space before_selector_group_item selector %prec UNIMPORTANT_TOK {
</span><del>- OwnPtr<Vector<OwnPtr<CSSParserSelector>>> selectorList = adoptPtr($1);
- OwnPtr<CSSParserSelector> selector = adoptPtr($6);
</del><ins>+ std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>> selectorList($1);
+ std::unique_ptr<CSSParserSelector> selector($6);
</ins><span class="cx"> $$ = nullptr;
</span><span class="cx"> if (selectorList && selector) {
</span><del>- $$ = selectorList.leakPtr();
- $$->append(selector.release());
</del><ins>+ $$ = selectorList.release();
+ $$->append(std::move(selector));
</ins><span class="cx"> parser->updateLastSelectorLineAndPosition();
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -978,21 +978,21 @@
</span><span class="cx"> simple_selector
</span><span class="cx"> | selector_with_trailing_whitespace
</span><span class="cx"> | selector_with_trailing_whitespace simple_selector {
</span><del>- OwnPtr<CSSParserSelector> left = adoptPtr($1);
- OwnPtr<CSSParserSelector> right = adoptPtr($2);
</del><ins>+ std::unique_ptr<CSSParserSelector> left($1);
+ std::unique_ptr<CSSParserSelector> right($2);
</ins><span class="cx"> $$ = nullptr;
</span><span class="cx"> if (left && right) {
</span><del>- right->appendTagHistory(CSSSelector::Descendant, left.release());
- $$ = right.leakPtr();
</del><ins>+ right->appendTagHistory(CSSSelector::Descendant, std::move(left));
+ $$ = right.release();
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> | selector combinator simple_selector {
</span><del>- OwnPtr<CSSParserSelector> left = adoptPtr($1);
- OwnPtr<CSSParserSelector> right = adoptPtr($3);
</del><ins>+ std::unique_ptr<CSSParserSelector> left($1);
+ std::unique_ptr<CSSParserSelector> right($3);
</ins><span class="cx"> $$ = nullptr;
</span><span class="cx"> if (left && right) {
</span><del>- right->appendTagHistory($2, left.release());
- $$ = right.leakPtr();
</del><ins>+ right->appendTagHistory($2, std::move(left));
+ $$ = right.release();
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> | selector error {
</span><span class="lines">@@ -1040,17 +1040,17 @@
</span><span class="cx"> simple_selector %prec UNIMPORTANT_TOK {
</span><span class="cx"> $$ = nullptr;
</span><span class="cx"> if ($1) {
</span><del>- $$ = parser->createSelectorVector().leakPtr();
- $$->append(adoptPtr($1));
</del><ins>+ $$ = parser->createSelectorVector().release();
+ $$->append(std::unique_ptr<CSSParserSelector>($1));
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> | simple_selector_list maybe_space ',' maybe_space simple_selector %prec UNIMPORTANT_TOK {
</span><del>- OwnPtr<Vector<OwnPtr<CSSParserSelector>>> list = adoptPtr($1);
- OwnPtr<CSSParserSelector> selector = adoptPtr($5);
</del><ins>+ std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>> list($1);
+ std::unique_ptr<CSSParserSelector> selector($5);
</ins><span class="cx"> $$ = nullptr;
</span><span class="cx"> if (list && selector) {
</span><del>- $$ = list.leakPtr();
- $$->append(selector.release());
</del><ins>+ $$ = list.release();
+ $$->append(std::move(selector));
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> | simple_selector_list error {
</span><span class="lines">@@ -1074,11 +1074,11 @@
</span><span class="cx"> specifier_list:
</span><span class="cx"> specifier
</span><span class="cx"> | specifier_list specifier {
</span><del>- OwnPtr<CSSParserSelector> list = adoptPtr($1);
- OwnPtr<CSSParserSelector> specifier = adoptPtr($2);
</del><ins>+ std::unique_ptr<CSSParserSelector> list($1);
+ std::unique_ptr<CSSParserSelector> specifier($2);
</ins><span class="cx"> $$ = nullptr;
</span><span class="cx"> if (list && specifier)
</span><del>- $$ = parser->rewriteSpecifiers(list.release(), specifier.release()).leakPtr();
</del><ins>+ $$ = parser->rewriteSpecifiers(std::move(list), std::move(specifier)).release();
</ins><span class="cx"> }
</span><span class="cx"> | specifier_list error {
</span><span class="cx"> $$ = nullptr;
</span><span class="lines">@@ -1205,7 +1205,7 @@
</span><span class="cx"> if ($5) {
</span><span class="cx"> auto selector = std::make_unique<CSSParserSelector>();
</span><span class="cx"> selector->setMatch(CSSSelector::PseudoClass);
</span><del>- selector->adoptSelectorVector(*adoptPtr($5));
</del><ins>+ selector->adoptSelectorVector(*std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>>($5));
</ins><span class="cx"> selector->setValue($3);
</span><span class="cx"> if (selector->pseudoType() == CSSSelector::PseudoCue)
</span><span class="cx"> $$ = selector.release();
</span><span class="lines">@@ -1222,7 +1222,7 @@
</span><span class="cx"> if ($4) {
</span><span class="cx"> auto selector = std::make_unique<CSSParserSelector>();
</span><span class="cx"> selector->setMatch(CSSSelector::PseudoClass);
</span><del>- selector->adoptSelectorVector(*adoptPtr($4));
</del><ins>+ selector->adoptSelectorVector(*std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>>($4));
</ins><span class="cx"> $2.lower();
</span><span class="cx"> selector->setValue($2);
</span><span class="cx"> if (selector->pseudoType() == CSSSelector::PseudoAny)
</span><span class="lines">@@ -1270,14 +1270,14 @@
</span><span class="cx"> }
</span><span class="cx"> // used by :not
</span><span class="cx"> | ':' NOTFUNCTION maybe_space simple_selector maybe_space ')' {
</span><del>- OwnPtr<CSSParserSelector> selector = adoptPtr($4);
</del><ins>+ std::unique_ptr<CSSParserSelector> selector($4);
</ins><span class="cx"> $$ = nullptr;
</span><span class="cx"> if (selector && selector->isSimple()) {
</span><span class="cx"> $$ = new CSSParserSelector;
</span><span class="cx"> $$->setMatch(CSSSelector::PseudoClass);
</span><span class="cx">
</span><del>- Vector<OwnPtr<CSSParserSelector>> selectorVector;
- selectorVector.append(selector.release());
</del><ins>+ Vector<std::unique_ptr<CSSParserSelector>> selectorVector;
+ selectorVector.append(std::move(selector));
</ins><span class="cx"> $$->adoptSelectorVector(selectorVector);
</span><span class="cx">
</span><span class="cx"> $2.lower();
</span><span class="lines">@@ -1326,9 +1326,9 @@
</span><span class="cx"> property ':' maybe_space expr priority {
</span><span class="cx"> $$ = false;
</span><span class="cx"> bool isPropertyParsed = false;
</span><del>- OwnPtr<CSSParserValueList> propertyValue = adoptPtr($4);
</del><ins>+ std::unique_ptr<CSSParserValueList> propertyValue($4);
</ins><span class="cx"> if ($1 && propertyValue) {
</span><del>- parser->m_valueList = propertyValue.release();
</del><ins>+ parser->m_valueList = std::move(propertyValue);
</ins><span class="cx"> int oldParsedProperties = parser->m_parsedProperties.size();
</span><span class="cx"> $$ = parser->parseValue($1, $5);
</span><span class="cx"> if (!$$)
</span><span class="lines">@@ -1459,7 +1459,7 @@
</span><span class="cx"> FUNCTION maybe_space expr closing_parenthesis {
</span><span class="cx"> CSSParserFunction* f = new CSSParserFunction;
</span><span class="cx"> f->name = $1;
</span><del>- f->args = adoptPtr($3);
</del><ins>+ f->args = std::unique_ptr<CSSParserValueList>($3);
</ins><span class="cx"> $$.id = CSSValueInvalid;
</span><span class="cx"> $$.unit = CSSParserValue::Function;
</span><span class="cx"> $$.function = f;
</span><span class="lines">@@ -1467,7 +1467,7 @@
</span><span class="cx"> FUNCTION maybe_space closing_parenthesis {
</span><span class="cx"> CSSParserFunction* f = new CSSParserFunction;
</span><span class="cx"> f->name = $1;
</span><del>- f->args = adoptPtr(new CSSParserValueList);
</del><ins>+ f->args = std::unique_ptr<CSSParserValueList>(new CSSParserValueList);
</ins><span class="cx"> $$.id = CSSValueInvalid;
</span><span class="cx"> $$.unit = CSSParserValue::Function;
</span><span class="cx"> $$.function = f;
</span><span class="lines">@@ -1533,10 +1533,10 @@
</span><span class="cx"> $$->addValue($1);
</span><span class="cx"> }
</span><span class="cx"> | calc_func_expr calc_func_operator calc_func_term {
</span><del>- OwnPtr<CSSParserValueList> expression = adoptPtr($1);
</del><ins>+ std::unique_ptr<CSSParserValueList> expression($1);
</ins><span class="cx"> $$ = nullptr;
</span><span class="cx"> if (expression && $2) {
</span><del>- $$ = expression.leakPtr();
</del><ins>+ $$ = expression.release();
</ins><span class="cx"> CSSParserValue v;
</span><span class="cx"> v.id = CSSValueInvalid;
</span><span class="cx"> v.unit = CSSParserValue::Operator;
</span><span class="lines">@@ -1549,8 +1549,8 @@
</span><span class="cx">
</span><span class="cx"> }
</span><span class="cx"> | calc_func_expr calc_func_operator calc_func_paren_expr {
</span><del>- OwnPtr<CSSParserValueList> left = adoptPtr($1);
- OwnPtr<CSSParserValueList> right = adoptPtr($3);
</del><ins>+ std::unique_ptr<CSSParserValueList> left($1);
+ std::unique_ptr<CSSParserValueList> right($3);
</ins><span class="cx"> $$ = nullptr;
</span><span class="cx"> if (left && $2 && right) {
</span><span class="cx"> CSSParserValue v;
</span><span class="lines">@@ -1559,7 +1559,7 @@
</span><span class="cx"> v.iValue = $2;
</span><span class="cx"> left->addValue(v);
</span><span class="cx"> left->extend(*right);
</span><del>- $$ = left.leakPtr();
</del><ins>+ $$ = left.release();
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> | calc_func_paren_expr
</span><span class="lines">@@ -1568,11 +1568,11 @@
</span><span class="cx"> calc_func_expr_list:
</span><span class="cx"> calc_func_expr calc_maybe_space
</span><span class="cx"> | calc_func_expr_list ',' maybe_space calc_func_expr calc_maybe_space {
</span><del>- OwnPtr<CSSParserValueList> list = adoptPtr($1);
- OwnPtr<CSSParserValueList> expression = adoptPtr($4);
</del><ins>+ std::unique_ptr<CSSParserValueList> list($1);
+ std::unique_ptr<CSSParserValueList> expression($4);
</ins><span class="cx"> $$ = nullptr;
</span><span class="cx"> if (list && expression) {
</span><del>- $$ = list.leakPtr();
</del><ins>+ $$ = list.release();
</ins><span class="cx"> CSSParserValue v;
</span><span class="cx"> v.id = CSSValueInvalid;
</span><span class="cx"> v.unit = CSSParserValue::Operator;
</span><span class="lines">@@ -1587,7 +1587,7 @@
</span><span class="cx"> CALCFUNCTION maybe_space calc_func_expr calc_maybe_space closing_parenthesis {
</span><span class="cx"> CSSParserFunction* f = new CSSParserFunction;
</span><span class="cx"> f->name = $1;
</span><del>- f->args = adoptPtr($3);
</del><ins>+ f->args = std::unique_ptr<CSSParserValueList>($3);
</ins><span class="cx"> $$.id = CSSValueInvalid;
</span><span class="cx"> $$.unit = CSSParserValue::Function;
</span><span class="cx"> $$.function = f;
</span><span class="lines">@@ -1606,7 +1606,7 @@
</span><span class="cx"> min_or_max maybe_space calc_func_expr_list closing_parenthesis {
</span><span class="cx"> CSSParserFunction* f = new CSSParserFunction;
</span><span class="cx"> f->name = $1;
</span><del>- f->args = adoptPtr($3);
</del><ins>+ f->args = std::unique_ptr<CSSParserValueList>($3);
</ins><span class="cx"> $$.id = CSSValueInvalid;
</span><span class="cx"> $$.unit = CSSParserValue::Function;
</span><span class="cx"> $$.function = f;
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSParsercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSParser.cpp (163746 => 163747)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSParser.cpp 2014-02-09 08:33:19 UTC (rev 163746)
+++ trunk/Source/WebCore/css/CSSParser.cpp 2014-02-09 08:58:56 UTC (rev 163747)
</span><span class="lines">@@ -430,7 +430,7 @@
</span><span class="cx"> setStyleSheet(sheet);
</span><span class="cx"> m_defaultNamespace = starAtom; // Reset the default namespace.
</span><span class="cx"> if (ruleSourceDataResult)
</span><del>- m_currentRuleDataStack = adoptPtr(new RuleSourceDataList());
</del><ins>+ m_currentRuleDataStack = std::make_unique<RuleSourceDataList>();
</ins><span class="cx"> m_ruleSourceDataResult = ruleSourceDataResult;
</span><span class="cx">
</span><span class="cx"> m_logErrors = logErrors && sheet->singleOwnerDocument() && !sheet->baseURL().isEmpty() && sheet->singleOwnerDocument()->page();
</span><span class="lines">@@ -439,7 +439,7 @@
</span><span class="cx"> setupParser("", string, "");
</span><span class="cx"> cssyyparse(this);
</span><span class="cx"> sheet->shrinkToFit();
</span><del>- m_currentRuleDataStack.clear();
</del><ins>+ m_currentRuleDataStack.reset();
</ins><span class="cx"> m_ruleSourceDataResult = 0;
</span><span class="cx"> m_rule = 0;
</span><span class="cx"> m_ignoreErrorsInDeclaration = false;
</span><span class="lines">@@ -1421,7 +1421,7 @@
</span><span class="cx">
</span><span class="cx"> RefPtr<CSSRuleSourceData> ruleSourceData = prpRuleSourceData;
</span><span class="cx"> if (ruleSourceData) {
</span><del>- m_currentRuleDataStack = adoptPtr(new RuleSourceDataList());
</del><ins>+ m_currentRuleDataStack = std::make_unique<RuleSourceDataList>();
</ins><span class="cx"> m_currentRuleDataStack->append(ruleSourceData);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1449,7 +1449,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> fixUnparsedPropertyRanges(ruleSourceData.get());
</span><del>- m_currentRuleDataStack.clear();
</del><ins>+ m_currentRuleDataStack.reset();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> return ok;
</span><span class="lines">@@ -2061,12 +2061,12 @@
</span><span class="cx"> CSSPropertyID propId1, propId2;
</span><span class="cx"> bool result = false;
</span><span class="cx"> if (parseFillProperty(propId, propId1, propId2, val1, val2)) {
</span><del>- OwnPtr<ShorthandScope> shorthandScope;
</del><ins>+ std::unique_ptr<ShorthandScope> shorthandScope;
</ins><span class="cx"> if (propId == CSSPropertyBackgroundPosition ||
</span><span class="cx"> propId == CSSPropertyBackgroundRepeat ||
</span><span class="cx"> propId == CSSPropertyWebkitMaskPosition ||
</span><span class="cx"> propId == CSSPropertyWebkitMaskRepeat) {
</span><del>- shorthandScope = adoptPtr(new ShorthandScope(this, propId));
</del><ins>+ shorthandScope = std::make_unique<ShorthandScope>(this, propId);
</ins><span class="cx"> }
</span><span class="cx"> addProperty(propId1, val1.release(), important);
</span><span class="cx"> if (val2)
</span><span class="lines">@@ -11378,7 +11378,7 @@
</span><span class="cx"> void CSSParser::markSupportsRuleHeaderStart()
</span><span class="cx"> {
</span><span class="cx"> if (!m_supportsRuleDataStack)
</span><del>- m_supportsRuleDataStack = adoptPtr(new RuleSourceDataList());
</del><ins>+ m_supportsRuleDataStack = std::make_unique<RuleSourceDataList>();
</ins><span class="cx">
</span><span class="cx"> RefPtr<CSSRuleSourceData> data = CSSRuleSourceData::create(CSSRuleSourceData::SUPPORTS_RULE);
</span><span class="cx"> data->ruleHeaderRange.start = tokenStartOffset();
</span><span class="lines">@@ -11474,9 +11474,9 @@
</span><span class="cx"> console.addMessage(MessageSource::CSS, MessageLevel::Warning, message, m_styleSheet->baseURL().string(), lineNumber + 1, 0);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<StyleRuleKeyframes> CSSParser::createKeyframesRule(const String& name, PassOwnPtr<Vector<RefPtr<StyleKeyframe>>> popKeyframes)
</del><ins>+PassRefPtr<StyleRuleKeyframes> CSSParser::createKeyframesRule(const String& name, std::unique_ptr<Vector<RefPtr<StyleKeyframe>>> popKeyframes)
</ins><span class="cx"> {
</span><del>- OwnPtr<Vector<RefPtr<StyleKeyframe>>> keyframes = popKeyframes;
</del><ins>+ std::unique_ptr<Vector<RefPtr<StyleKeyframe>>> keyframes = std::move(popKeyframes);
</ins><span class="cx"> m_allowImportRules = m_allowNamespaceDeclarations = false;
</span><span class="cx"> RefPtr<StyleRuleKeyframes> rule = StyleRuleKeyframes::create();
</span><span class="cx"> for (size_t i = 0; i < keyframes->size(); ++i)
</span><span class="lines">@@ -11486,7 +11486,7 @@
</span><span class="cx"> return rule.release();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<StyleRuleBase> CSSParser::createStyleRule(Vector<OwnPtr<CSSParserSelector>>* selectors)
</del><ins>+PassRefPtr<StyleRuleBase> CSSParser::createStyleRule(Vector<std::unique_ptr<CSSParserSelector>>* selectors)
</ins><span class="cx"> {
</span><span class="cx"> RefPtr<StyleRule> rule;
</span><span class="cx"> if (selectors) {
</span><span class="lines">@@ -11580,11 +11580,11 @@
</span><span class="cx">
</span><span class="cx"> // For shadow-ID pseudo-elements to be correctly matched, the ShadowDescendant combinator has to be used.
</span><span class="cx"> // We therefore create a new Selector with that combinator here in any case, even if matching any (host) element in any namespace (i.e. '*').
</span><del>- lastShadowDescendant->setTagHistory(adoptPtr(new CSSParserSelector(tag)));
</del><ins>+ lastShadowDescendant->setTagHistory(std::make_unique<CSSParserSelector>(tag));
</ins><span class="cx"> lastShadowDescendant->setRelation(CSSSelector::ShadowDescendant);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-OwnPtr<CSSParserSelector> CSSParser::rewriteSpecifiers(OwnPtr<CSSParserSelector> specifiers, OwnPtr<CSSParserSelector> newSpecifier)
</del><ins>+std::unique_ptr<CSSParserSelector> CSSParser::rewriteSpecifiers(std::unique_ptr<CSSParserSelector> specifiers, std::unique_ptr<CSSParserSelector> newSpecifier)
</ins><span class="cx"> {
</span><span class="cx"> #if ENABLE(VIDEO_TRACK)
</span><span class="cx"> if (newSpecifier->isCustomPseudoElement() || newSpecifier->pseudoType() == CSSSelector::PseudoCue) {
</span><span class="lines">@@ -11592,27 +11592,27 @@
</span><span class="cx"> if (newSpecifier->isCustomPseudoElement()) {
</span><span class="cx"> #endif
</span><span class="cx"> // Unknown pseudo element always goes at the top of selector chain.
</span><del>- newSpecifier->appendTagHistory(CSSSelector::ShadowDescendant, specifiers.release());
</del><ins>+ newSpecifier->appendTagHistory(CSSSelector::ShadowDescendant, std::move(specifiers));
</ins><span class="cx"> return newSpecifier;
</span><span class="cx"> }
</span><span class="cx"> if (specifiers->isCustomPseudoElement()) {
</span><span class="cx"> // Specifiers for unknown pseudo element go right behind it in the chain.
</span><del>- specifiers->insertTagHistory(CSSSelector::SubSelector, newSpecifier.release(), CSSSelector::ShadowDescendant);
</del><ins>+ specifiers->insertTagHistory(CSSSelector::SubSelector, std::move(newSpecifier), CSSSelector::ShadowDescendant);
</ins><span class="cx"> return specifiers;
</span><span class="cx"> }
</span><del>- specifiers->appendTagHistory(CSSSelector::SubSelector, newSpecifier.release());
</del><ins>+ specifiers->appendTagHistory(CSSSelector::SubSelector, std::move(newSpecifier));
</ins><span class="cx"> return specifiers;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<StyleRuleBase> CSSParser::createPageRule(PassOwnPtr<CSSParserSelector> pageSelector)
</del><ins>+PassRefPtr<StyleRuleBase> CSSParser::createPageRule(std::unique_ptr<CSSParserSelector> pageSelector)
</ins><span class="cx"> {
</span><span class="cx"> // FIXME: Margin at-rules are ignored.
</span><span class="cx"> m_allowImportRules = m_allowNamespaceDeclarations = false;
</span><span class="cx"> RefPtr<StyleRulePage> rule;
</span><span class="cx"> if (pageSelector) {
</span><span class="cx"> rule = StyleRulePage::create(createStyleProperties());
</span><del>- Vector<OwnPtr<CSSParserSelector>> selectorVector;
- selectorVector.append(pageSelector);
</del><ins>+ Vector<std::unique_ptr<CSSParserSelector>> selectorVector;
+ selectorVector.append(std::move(pageSelector));
</ins><span class="cx"> rule->parserAdoptSelectorVector(selectorVector);
</span><span class="cx"> processAndAddNewRuleToSourceTreeIfNeeded();
</span><span class="cx"> } else
</span><span class="lines">@@ -11621,22 +11621,22 @@
</span><span class="cx"> return rule.release();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-OwnPtr<Vector<OwnPtr<CSSParserSelector>>> CSSParser::createSelectorVector()
</del><ins>+std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>> CSSParser::createSelectorVector()
</ins><span class="cx"> {
</span><span class="cx"> if (m_recycledSelectorVector) {
</span><span class="cx"> m_recycledSelectorVector->shrink(0);
</span><span class="cx"> return std::move(m_recycledSelectorVector);
</span><span class="cx"> }
</span><del>- return adoptPtr(new Vector<OwnPtr<CSSParserSelector>>);
</del><ins>+ return std::make_unique<Vector<std::unique_ptr<CSSParserSelector>>>();
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void CSSParser::recycleSelectorVector(OwnPtr<Vector<OwnPtr<CSSParserSelector>>> vector)
</del><ins>+void CSSParser::recycleSelectorVector(std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>> vector)
</ins><span class="cx"> {
</span><span class="cx"> if (vector && !m_recycledSelectorVector)
</span><span class="cx"> m_recycledSelectorVector = std::move(vector);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-PassRefPtr<StyleRuleBase> CSSParser::createRegionRule(Vector<OwnPtr<CSSParserSelector>>* regionSelector, RuleList* rules)
</del><ins>+PassRefPtr<StyleRuleBase> CSSParser::createRegionRule(Vector<std::unique_ptr<CSSParserSelector>>* regionSelector, RuleList* rules)
</ins><span class="cx"> {
</span><span class="cx"> if (!cssRegionsEnabled() || !regionSelector || !rules) {
</span><span class="cx"> popRuleData();
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSParserh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSParser.h (163746 => 163747)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSParser.h 2014-02-09 08:33:19 UTC (rev 163746)
+++ trunk/Source/WebCore/css/CSSParser.h 2014-02-09 08:58:56 UTC (rev 163747)
</span><span class="lines">@@ -287,20 +287,20 @@
</span><span class="cx"> bool parseFontVariantLigatures(bool important);
</span><span class="cx">
</span><span class="cx"> // Faster than doing a new/delete each time since it keeps one vector.
</span><del>- OwnPtr<Vector<OwnPtr<CSSParserSelector>>> createSelectorVector();
- void recycleSelectorVector(OwnPtr<Vector<OwnPtr<CSSParserSelector>>>);
</del><ins>+ std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>> createSelectorVector();
+ void recycleSelectorVector(std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>>);
</ins><span class="cx">
</span><span class="cx"> PassRefPtr<StyleRuleBase> createImportRule(const CSSParserString&, PassRefPtr<MediaQuerySet>);
</span><span class="cx"> PassRefPtr<StyleKeyframe> createKeyframe(CSSParserValueList&);
</span><del>- PassRefPtr<StyleRuleKeyframes> createKeyframesRule(const String&, PassOwnPtr<Vector<RefPtr<StyleKeyframe>>>);
</del><ins>+ PassRefPtr<StyleRuleKeyframes> createKeyframesRule(const String&, std::unique_ptr<Vector<RefPtr<StyleKeyframe>>>);
</ins><span class="cx">
</span><span class="cx"> typedef Vector<RefPtr<StyleRuleBase>> RuleList;
</span><span class="cx"> PassRefPtr<StyleRuleBase> createMediaRule(PassRefPtr<MediaQuerySet>, RuleList*);
</span><span class="cx"> PassRefPtr<StyleRuleBase> createEmptyMediaRule(RuleList*);
</span><del>- PassRefPtr<StyleRuleBase> createStyleRule(Vector<OwnPtr<CSSParserSelector>>* selectors);
</del><ins>+ PassRefPtr<StyleRuleBase> createStyleRule(Vector<std::unique_ptr<CSSParserSelector>>* selectors);
</ins><span class="cx"> PassRefPtr<StyleRuleBase> createFontFaceRule();
</span><del>- PassRefPtr<StyleRuleBase> createPageRule(PassOwnPtr<CSSParserSelector> pageSelector);
- PassRefPtr<StyleRuleBase> createRegionRule(Vector<OwnPtr<CSSParserSelector>>* regionSelector, RuleList* rules);
</del><ins>+ PassRefPtr<StyleRuleBase> createPageRule(std::unique_ptr<CSSParserSelector> pageSelector);
+ PassRefPtr<StyleRuleBase> createRegionRule(Vector<std::unique_ptr<CSSParserSelector>>* regionSelector, RuleList* rules);
</ins><span class="cx"> void createMarginAtRule(CSSSelector::MarginBoxType);
</span><span class="cx"> #if ENABLE(CSS3_CONDITIONAL_RULES)
</span><span class="cx"> PassRefPtr<StyleRuleBase> createSupportsRule(bool conditionIsSupported, RuleList*);
</span><span class="lines">@@ -317,7 +317,7 @@
</span><span class="cx">
</span><span class="cx"> void rewriteSpecifiersWithElementName(const AtomicString& namespacePrefix, const AtomicString& elementName, CSSParserSelector&, bool isNamespacePlaceholder = false);
</span><span class="cx"> void rewriteSpecifiersWithNamespaceIfNeeded(CSSParserSelector&);
</span><del>- OwnPtr<CSSParserSelector> rewriteSpecifiers(OwnPtr<CSSParserSelector>, OwnPtr<CSSParserSelector>);
</del><ins>+ std::unique_ptr<CSSParserSelector> rewriteSpecifiers(std::unique_ptr<CSSParserSelector>, std::unique_ptr<CSSParserSelector>);
</ins><span class="cx">
</span><span class="cx"> void invalidBlockHit();
</span><span class="cx">
</span><span class="lines">@@ -336,7 +336,7 @@
</span><span class="cx"> RefPtr<StyleRuleBase> m_rule;
</span><span class="cx"> RefPtr<StyleKeyframe> m_keyframe;
</span><span class="cx"> std::unique_ptr<MediaQuery> m_mediaQuery;
</span><del>- OwnPtr<CSSParserValueList> m_valueList;
</del><ins>+ std::unique_ptr<CSSParserValueList> m_valueList;
</ins><span class="cx"> #if ENABLE(CSS3_CONDITIONAL_RULES)
</span><span class="cx"> bool m_supportsCondition;
</span><span class="cx"> #endif
</span><span class="lines">@@ -362,7 +362,7 @@
</span><span class="cx"> size_t m_parsedTextPrefixLength;
</span><span class="cx"> SourceRange m_selectorRange;
</span><span class="cx"> SourceRange m_propertyRange;
</span><del>- OwnPtr<RuleSourceDataList> m_currentRuleDataStack;
</del><ins>+ std::unique_ptr<RuleSourceDataList> m_currentRuleDataStack;
</ins><span class="cx"> RefPtr<CSSRuleSourceData> m_currentRuleData;
</span><span class="cx"> RuleSourceDataList* m_ruleSourceDataResult;
</span><span class="cx">
</span><span class="lines">@@ -559,12 +559,12 @@
</span><span class="cx">
</span><span class="cx"> int (CSSParser::*m_lexFunc)(void*);
</span><span class="cx">
</span><del>- OwnPtr<Vector<OwnPtr<CSSParserSelector>>> m_recycledSelectorVector;
</del><ins>+ std::unique_ptr<Vector<std::unique_ptr<CSSParserSelector>>> m_recycledSelectorVector;
</ins><span class="cx">
</span><span class="cx"> RefPtr<CSSCalcValue> m_parsedCalculation;
</span><span class="cx">
</span><span class="cx"> #if ENABLE(CSS3_CONDITIONAL_RULES)
</span><del>- OwnPtr<RuleSourceDataList> m_supportsRuleDataStack;
</del><ins>+ std::unique_ptr<RuleSourceDataList> m_supportsRuleDataStack;
</ins><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> // defines units allowed for a certain property, used in parseUnit
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSParserValuescpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSParserValues.cpp (163746 => 163747)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSParserValues.cpp 2014-02-09 08:33:19 UTC (rev 163746)
+++ trunk/Source/WebCore/css/CSSParserValues.cpp 2014-02-09 08:58:56 UTC (rev 163747)
</span><span class="lines">@@ -147,12 +147,12 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> CSSParserSelector::CSSParserSelector()
</span><del>- : m_selector(adoptPtr(new CSSSelector))
</del><ins>+ : m_selector(std::make_unique<CSSSelector>())
</ins><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> CSSParserSelector::CSSParserSelector(const QualifiedName& tagQName)
</span><del>- : m_selector(adoptPtr(new CSSSelector(tagQName)))
</del><ins>+ : m_selector(std::make_unique<CSSSelector>(tagQName))
</ins><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -160,22 +160,22 @@
</span><span class="cx"> {
</span><span class="cx"> if (!m_tagHistory)
</span><span class="cx"> return;
</span><del>- Vector<OwnPtr<CSSParserSelector>, 16> toDelete;
- OwnPtr<CSSParserSelector> selector = m_tagHistory.release();
</del><ins>+ Vector<std::unique_ptr<CSSParserSelector>, 16> toDelete;
+ std::unique_ptr<CSSParserSelector> selector = std::move(m_tagHistory);
</ins><span class="cx"> while (true) {
</span><del>- OwnPtr<CSSParserSelector> next = selector->m_tagHistory.release();
- toDelete.append(selector.release());
</del><ins>+ std::unique_ptr<CSSParserSelector> next = std::move(selector->m_tagHistory);
+ toDelete.append(std::move(selector));
</ins><span class="cx"> if (!next)
</span><span class="cx"> break;
</span><del>- selector = next.release();
</del><ins>+ selector = std::move(next);
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void CSSParserSelector::adoptSelectorVector(Vector<OwnPtr<CSSParserSelector>>& selectorVector)
</del><ins>+void CSSParserSelector::adoptSelectorVector(Vector<std::unique_ptr<CSSParserSelector>>& selectorVector)
</ins><span class="cx"> {
</span><del>- OwnPtr<CSSSelectorList> selectorList = adoptPtr(new CSSSelectorList);
</del><ins>+ auto selectorList = std::make_unique<CSSSelectorList>();
</ins><span class="cx"> selectorList->adoptSelectorVector(selectorVector);
</span><del>- m_selector->setSelectorList(selectorList.release());
</del><ins>+ m_selector->setSelectorList(std::move(selectorList));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool CSSParserSelector::isSimple() const
</span><span class="lines">@@ -198,32 +198,32 @@
</span><span class="cx"> return false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void CSSParserSelector::insertTagHistory(CSSSelector::Relation before, PassOwnPtr<CSSParserSelector> selector, CSSSelector::Relation after)
</del><ins>+void CSSParserSelector::insertTagHistory(CSSSelector::Relation before, std::unique_ptr<CSSParserSelector> selector, CSSSelector::Relation after)
</ins><span class="cx"> {
</span><span class="cx"> if (m_tagHistory)
</span><del>- selector->setTagHistory(m_tagHistory.release());
</del><ins>+ selector->setTagHistory(std::move(m_tagHistory));
</ins><span class="cx"> setRelation(before);
</span><span class="cx"> selector->setRelation(after);
</span><del>- m_tagHistory = selector;
</del><ins>+ m_tagHistory = std::move(selector);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void CSSParserSelector::appendTagHistory(CSSSelector::Relation relation, PassOwnPtr<CSSParserSelector> selector)
</del><ins>+void CSSParserSelector::appendTagHistory(CSSSelector::Relation relation, std::unique_ptr<CSSParserSelector> selector)
</ins><span class="cx"> {
</span><span class="cx"> CSSParserSelector* end = this;
</span><span class="cx"> while (end->tagHistory())
</span><span class="cx"> end = end->tagHistory();
</span><span class="cx"> end->setRelation(relation);
</span><del>- end->setTagHistory(selector);
</del><ins>+ end->setTagHistory(std::move(selector));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void CSSParserSelector::prependTagSelector(const QualifiedName& tagQName, bool tagIsForNamespaceRule)
</span><span class="cx"> {
</span><del>- OwnPtr<CSSParserSelector> second = adoptPtr(new CSSParserSelector);
- second->m_selector = m_selector.release();
- second->m_tagHistory = m_tagHistory.release();
- m_tagHistory = second.release();
</del><ins>+ auto second = std::make_unique<CSSParserSelector>();
+ second->m_selector = std::move(m_selector);
+ second->m_tagHistory = std::move(m_tagHistory);
+ m_tagHistory = std::move(second);
</ins><span class="cx">
</span><del>- m_selector = adoptPtr(new CSSSelector(tagQName, tagIsForNamespaceRule));
</del><ins>+ m_selector = std::make_unique<CSSSelector>(tagQName, tagIsForNamespaceRule);
</ins><span class="cx"> m_selector->m_relation = CSSSelector::SubSelector;
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSParserValuesh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSParserValues.h (163746 => 163747)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSParserValues.h 2014-02-09 08:33:19 UTC (rev 163746)
+++ trunk/Source/WebCore/css/CSSParserValues.h 2014-02-09 08:58:56 UTC (rev 163747)
</span><span class="lines">@@ -165,7 +165,7 @@
</span><span class="cx"> WTF_MAKE_FAST_ALLOCATED;
</span><span class="cx"> public:
</span><span class="cx"> CSSParserString name;
</span><del>- OwnPtr<CSSParserValueList> args;
</del><ins>+ std::unique_ptr<CSSParserValueList> args;
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> class CSSParserSelector {
</span><span class="lines">@@ -175,7 +175,7 @@
</span><span class="cx"> explicit CSSParserSelector(const QualifiedName&);
</span><span class="cx"> ~CSSParserSelector();
</span><span class="cx">
</span><del>- PassOwnPtr<CSSSelector> releaseSelector() { return m_selector.release(); }
</del><ins>+ std::unique_ptr<CSSSelector> releaseSelector() { return std::move(m_selector); }
</ins><span class="cx">
</span><span class="cx"> void setValue(const AtomicString& value) { m_selector->setValue(value); }
</span><span class="cx"> void setAttribute(const QualifiedName& value, bool isCaseInsensitive) { m_selector->setAttribute(value, isCaseInsensitive); }
</span><span class="lines">@@ -184,7 +184,7 @@
</span><span class="cx"> void setRelation(CSSSelector::Relation value) { m_selector->m_relation = value; }
</span><span class="cx"> void setForPage() { m_selector->setForPage(); }
</span><span class="cx">
</span><del>- void adoptSelectorVector(Vector<OwnPtr<CSSParserSelector>>& selectorVector);
</del><ins>+ void adoptSelectorVector(Vector<std::unique_ptr<CSSParserSelector>>& selectorVector);
</ins><span class="cx">
</span><span class="cx"> CSSSelector::PseudoType pseudoType() const { return m_selector->pseudoType(); }
</span><span class="cx"> bool isCustomPseudoElement() const { return m_selector->isCustomPseudoElement(); }
</span><span class="lines">@@ -193,15 +193,15 @@
</span><span class="cx"> bool hasShadowDescendant() const;
</span><span class="cx">
</span><span class="cx"> CSSParserSelector* tagHistory() const { return m_tagHistory.get(); }
</span><del>- void setTagHistory(PassOwnPtr<CSSParserSelector> selector) { m_tagHistory = selector; }
- void clearTagHistory() { m_tagHistory.clear(); }
- void insertTagHistory(CSSSelector::Relation before, PassOwnPtr<CSSParserSelector>, CSSSelector::Relation after);
- void appendTagHistory(CSSSelector::Relation, PassOwnPtr<CSSParserSelector>);
</del><ins>+ void setTagHistory(std::unique_ptr<CSSParserSelector> selector) { m_tagHistory = std::move(selector); }
+ void clearTagHistory() { m_tagHistory.reset(); }
+ void insertTagHistory(CSSSelector::Relation before, std::unique_ptr<CSSParserSelector>, CSSSelector::Relation after);
+ void appendTagHistory(CSSSelector::Relation, std::unique_ptr<CSSParserSelector>);
</ins><span class="cx"> void prependTagSelector(const QualifiedName&, bool tagIsForNamespaceRule = false);
</span><span class="cx">
</span><span class="cx"> private:
</span><del>- OwnPtr<CSSSelector> m_selector;
- OwnPtr<CSSParserSelector> m_tagHistory;
</del><ins>+ std::unique_ptr<CSSSelector> m_selector;
+ std::unique_ptr<CSSParserSelector> m_tagHistory;
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> inline bool CSSParserSelector::hasShadowDescendant() const
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSSelectorcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSSelector.cpp (163746 => 163747)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSSelector.cpp 2014-02-09 08:33:19 UTC (rev 163746)
+++ trunk/Source/WebCore/css/CSSSelector.cpp 2014-02-09 08:58:56 UTC (rev 163747)
</span><span class="lines">@@ -653,10 +653,10 @@
</span><span class="cx"> m_data.m_rareData->m_argument = value;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void CSSSelector::setSelectorList(PassOwnPtr<CSSSelectorList> selectorList)
</del><ins>+void CSSSelector::setSelectorList(std::unique_ptr<CSSSelectorList> selectorList)
</ins><span class="cx"> {
</span><span class="cx"> createRareData();
</span><del>- m_data.m_rareData->m_selectorList = selectorList;
</del><ins>+ m_data.m_rareData->m_selectorList = std::move(selectorList);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool CSSSelector::parseNth() const
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSSelectorh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSSelector.h (163746 => 163747)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSSelector.h 2014-02-09 08:33:19 UTC (rev 163746)
+++ trunk/Source/WebCore/css/CSSSelector.h 2014-02-09 08:58:56 UTC (rev 163747)
</span><span class="lines">@@ -25,8 +25,6 @@
</span><span class="cx"> #include "QualifiedName.h"
</span><span class="cx"> #include "RenderStyleConstants.h"
</span><span class="cx"> #include <wtf/Noncopyable.h>
</span><del>-#include <wtf/OwnPtr.h>
-#include <wtf/PassOwnPtr.h>
</del><span class="cx">
</span><span class="cx"> namespace WebCore {
</span><span class="cx"> class CSSSelectorList;
</span><span class="lines">@@ -208,7 +206,7 @@
</span><span class="cx"> void setValue(const AtomicString&);
</span><span class="cx"> void setAttribute(const QualifiedName&, bool isCaseInsensitive);
</span><span class="cx"> void setArgument(const AtomicString&);
</span><del>- void setSelectorList(PassOwnPtr<CSSSelectorList>);
</del><ins>+ void setSelectorList(std::unique_ptr<CSSSelectorList>);
</ins><span class="cx">
</span><span class="cx"> bool parseNth() const;
</span><span class="cx"> bool matchNth(int count) const;
</span><span class="lines">@@ -263,7 +261,7 @@
</span><span class="cx"> QualifiedName m_attribute; // used for attribute selector
</span><span class="cx"> AtomicString m_attributeCanonicalLocalName;
</span><span class="cx"> AtomicString m_argument; // Used for :contains, :lang and :nth-*
</span><del>- OwnPtr<CSSSelectorList> m_selectorList; // Used for :-webkit-any and :not
</del><ins>+ std::unique_ptr<CSSSelectorList> m_selectorList; // Used for :-webkit-any and :not
</ins><span class="cx">
</span><span class="cx"> private:
</span><span class="cx"> RareData(PassRefPtr<AtomicStringImpl> value);
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSSelectorListcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSSelectorList.cpp (163746 => 163747)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSSelectorList.cpp 2014-02-09 08:33:19 UTC (rev 163746)
+++ trunk/Source/WebCore/css/CSSSelectorList.cpp 2014-02-09 08:58:56 UTC (rev 163747)
</span><span class="lines">@@ -52,7 +52,7 @@
</span><span class="cx"> list.m_selectorArray = 0;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void CSSSelectorList::adoptSelectorVector(Vector<OwnPtr<CSSParserSelector>>& selectorVector)
</del><ins>+void CSSSelectorList::adoptSelectorVector(Vector<std::unique_ptr<CSSParserSelector>>& selectorVector)
</ins><span class="cx"> {
</span><span class="cx"> deleteSelectors();
</span><span class="cx"> size_t flattenedSize = 0;
</span><span class="lines">@@ -68,7 +68,7 @@
</span><span class="cx"> while (current) {
</span><span class="cx"> {
</span><span class="cx"> // Move item from the parser selector vector into m_selectorArray without invoking destructor (Ugh.)
</span><del>- CSSSelector* currentSelector = current->releaseSelector().leakPtr();
</del><ins>+ CSSSelector* currentSelector = current->releaseSelector().release();
</ins><span class="cx"> memcpy(&m_selectorArray[arrayIndex], currentSelector, sizeof(CSSSelector));
</span><span class="cx">
</span><span class="cx"> // Free the underlying memory without invoking the destructor.
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSSelectorListh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSSelectorList.h (163746 => 163747)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSSelectorList.h 2014-02-09 08:33:19 UTC (rev 163746)
+++ trunk/Source/WebCore/css/CSSSelectorList.h 2014-02-09 08:58:56 UTC (rev 163747)
</span><span class="lines">@@ -27,6 +27,7 @@
</span><span class="cx"> #define CSSSelectorList_h
</span><span class="cx">
</span><span class="cx"> #include "CSSSelector.h"
</span><ins>+#include <memory>
</ins><span class="cx">
</span><span class="cx"> namespace WebCore {
</span><span class="cx">
</span><span class="lines">@@ -41,7 +42,7 @@
</span><span class="cx"> ~CSSSelectorList();
</span><span class="cx">
</span><span class="cx"> void adopt(CSSSelectorList& list);
</span><del>- void adoptSelectorVector(Vector<OwnPtr<CSSParserSelector>>& selectorVector);
</del><ins>+ void adoptSelectorVector(Vector<std::unique_ptr<CSSParserSelector>>& selectorVector);
</ins><span class="cx"> void adoptSelectorArray(CSSSelector* selectors) { ASSERT(!m_selectorArray); m_selectorArray = selectors; }
</span><span class="cx">
</span><span class="cx"> bool isValid() const { return !!m_selectorArray; }
</span></span></pre></div>
<a id="trunkSourceWebCorecssCSSValueListcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/CSSValueList.cpp (163746 => 163747)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/CSSValueList.cpp 2014-02-09 08:33:19 UTC (rev 163746)
+++ trunk/Source/WebCore/css/CSSValueList.cpp 2014-02-09 08:58:56 UTC (rev 163747)
</span><span class="lines">@@ -22,7 +22,6 @@
</span><span class="cx"> #include "CSSValueList.h"
</span><span class="cx">
</span><span class="cx"> #include "CSSParserValues.h"
</span><del>-#include <wtf/PassOwnPtr.h>
</del><span class="cx"> #include <wtf/text/StringBuilder.h>
</span><span class="cx">
</span><span class="cx"> namespace WebCore {
</span></span></pre></div>
<a id="trunkSourceWebCorecssStyleRulecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/StyleRule.cpp (163746 => 163747)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/StyleRule.cpp 2014-02-09 08:33:19 UTC (rev 163746)
+++ trunk/Source/WebCore/css/StyleRule.cpp 2014-02-09 08:58:56 UTC (rev 163747)
</span><span class="lines">@@ -364,7 +364,7 @@
</span><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>-StyleRuleRegion::StyleRuleRegion(Vector<OwnPtr<CSSParserSelector>>* selectors, Vector<RefPtr<StyleRuleBase>>& adoptRules)
</del><ins>+StyleRuleRegion::StyleRuleRegion(Vector<std::unique_ptr<CSSParserSelector>>* selectors, Vector<RefPtr<StyleRuleBase>>& adoptRules)
</ins><span class="cx"> : StyleRuleGroup(Region, adoptRules)
</span><span class="cx"> {
</span><span class="cx"> m_selectorList.adoptSelectorVector(*selectors);
</span></span></pre></div>
<a id="trunkSourceWebCorecssStyleRuleh"></a>
<div class="modfile"><h4>Modified: trunk/Source/WebCore/css/StyleRule.h (163746 => 163747)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/WebCore/css/StyleRule.h 2014-02-09 08:33:19 UTC (rev 163746)
+++ trunk/Source/WebCore/css/StyleRule.h 2014-02-09 08:58:56 UTC (rev 163747)
</span><span class="lines">@@ -117,7 +117,7 @@
</span><span class="cx"> const StyleProperties& properties() const { return m_properties.get(); }
</span><span class="cx"> MutableStyleProperties& mutableProperties();
</span><span class="cx">
</span><del>- void parserAdoptSelectorVector(Vector<OwnPtr<CSSParserSelector>>& selectors) { m_selectorList.adoptSelectorVector(selectors); }
</del><ins>+ void parserAdoptSelectorVector(Vector<std::unique_ptr<CSSParserSelector>>& selectors) { m_selectorList.adoptSelectorVector(selectors); }
</ins><span class="cx"> void wrapperAdoptSelectorList(CSSSelectorList& selectors) { m_selectorList.adopt(selectors); }
</span><span class="cx"> void parserAdoptSelectorArray(CSSSelector* selectors) { m_selectorList.adoptSelectorArray(selectors); }
</span><span class="cx">
</span><span class="lines">@@ -172,7 +172,7 @@
</span><span class="cx"> const StyleProperties& properties() const { return m_properties.get(); }
</span><span class="cx"> MutableStyleProperties& mutableProperties();
</span><span class="cx">
</span><del>- void parserAdoptSelectorVector(Vector<OwnPtr<CSSParserSelector>>& selectors) { m_selectorList.adoptSelectorVector(selectors); }
</del><ins>+ void parserAdoptSelectorVector(Vector<std::unique_ptr<CSSParserSelector>>& selectors) { m_selectorList.adoptSelectorVector(selectors); }
</ins><span class="cx"> void wrapperAdoptSelectorList(CSSSelectorList& selectors) { m_selectorList.adopt(selectors); }
</span><span class="cx">
</span><span class="cx"> PassRef<StyleRulePage> copy() const { return adoptRef(*new StyleRulePage(*this)); }
</span><span class="lines">@@ -241,7 +241,7 @@
</span><span class="cx">
</span><span class="cx"> class StyleRuleRegion : public StyleRuleGroup {
</span><span class="cx"> public:
</span><del>- static PassRef<StyleRuleRegion> create(Vector<OwnPtr<CSSParserSelector>>* selectors, Vector<RefPtr<StyleRuleBase>>& adoptRules)
</del><ins>+ static PassRef<StyleRuleRegion> create(Vector<std::unique_ptr<CSSParserSelector>>* selectors, Vector<RefPtr<StyleRuleBase>>& adoptRules)
</ins><span class="cx"> {
</span><span class="cx"> return adoptRef(*new StyleRuleRegion(selectors, adoptRules));
</span><span class="cx"> }
</span><span class="lines">@@ -251,7 +251,7 @@
</span><span class="cx"> PassRef<StyleRuleRegion> copy() const { return adoptRef(*new StyleRuleRegion(*this)); }
</span><span class="cx">
</span><span class="cx"> private:
</span><del>- StyleRuleRegion(Vector<OwnPtr<CSSParserSelector>>*, Vector<RefPtr<StyleRuleBase>>& adoptRules);
</del><ins>+ StyleRuleRegion(Vector<std::unique_ptr<CSSParserSelector>>*, Vector<RefPtr<StyleRuleBase>>& adoptRules);
</ins><span class="cx"> StyleRuleRegion(const StyleRuleRegion&);
</span><span class="cx">
</span><span class="cx"> CSSSelectorList m_selectorList;
</span></span></pre>
</div>
</div>
</body>
</html>