Oilpan: Remove WillBe types (part 5)

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

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2006, 2007, 2012 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 28 matching lines @@
 #include "core/html/HTMLStyleElement.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/svg/SVGStyleElement.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 class StyleSheetCSSRuleList final : public CSSRuleList {
 public:
-    static PassOwnPtrWillBeRawPtr<StyleSheetCSSRuleList> create(CSSStyleSheet* sheet)
+    static RawPtr<StyleSheetCSSRuleList> create(CSSStyleSheet* sheet)
     {
-        return adoptPtrWillBeNoop(new StyleSheetCSSRuleList(sheet));
+        return new StyleSheetCSSRuleList(sheet);
     }
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_styleSheet);
         CSSRuleList::trace(visitor);
     }
 
 private:
     StyleSheetCSSRuleList(CSSStyleSheet* sheet) : m_styleSheet(sheet) { }
 
 #if !ENABLE(OILPAN)
     void ref() override { m_styleSheet->ref(); }
     void deref() override { m_styleSheet->deref(); }
 #endif
 
     unsigned length() const override { return m_styleSheet->length(); }
     CSSRule* item(unsigned index) const override { return m_styleSheet->item(index); }
 
     CSSStyleSheet* styleSheet() const override { return m_styleSheet; }
 
-    RawPtrWillBeMember<CSSStyleSheet> m_styleSheet;
+    Member<CSSStyleSheet> m_styleSheet;
 };
 
 #if ENABLE(ASSERT)
 static bool isAcceptableCSSStyleSheetParent(Node* parentNode)
 {
     // Only these nodes can be parents of StyleSheets, and they need to call
     // clearOwnerNode() when moved out of document.
     // Destruction of the style sheet counts as being "moved out of the
     // document", but only in the non-oilpan version of blink. I.e. don't call
     // clearOwnerNode() in the owner's destructor in oilpan.
     return !parentNode
         || parentNode->isDocumentNode()
         || isHTMLLinkElement(*parentNode)
         || isHTMLStyleElement(*parentNode)
         || isSVGStyleElement(*parentNode)
         || parentNode->getNodeType() == Node::PROCESSING_INSTRUCTION_NODE;
 }
 #endif
 
-PassRefPtrWillBeRawPtr<CSSStyleSheet> CSSStyleSheet::create(PassRefPtrWillBeRawPtr<StyleSheetContents> sheet, CSSImportRule* ownerRule)
+RawPtr<CSSStyleSheet> CSSStyleSheet::create(RawPtr<StyleSheetContents> sheet, CSSImportRule* ownerRule)
 {
-    return adoptRefWillBeNoop(new CSSStyleSheet(sheet, ownerRule));
+    return new CSSStyleSheet(sheet, ownerRule);
 }
 
-PassRefPtrWillBeRawPtr<CSSStyleSheet> CSSStyleSheet::create(PassRefPtrWillBeRawPtr<StyleSheetContents> sheet, Node* ownerNode)
+RawPtr<CSSStyleSheet> CSSStyleSheet::create(RawPtr<StyleSheetContents> sheet, Node* ownerNode)
 {
-    return adoptRefWillBeNoop(new CSSStyleSheet(sheet, ownerNode, false, TextPosition::minimumPosition()));
+    return new CSSStyleSheet(sheet, ownerNode, false, TextPosition::minimumPosition());
 }
 
-PassRefPtrWillBeRawPtr<CSSStyleSheet> CSSStyleSheet::createInline(PassRefPtrWillBeRawPtr<StyleSheetContents> sheet, Node* ownerNode, const TextPosition& startPosition)
+RawPtr<CSSStyleSheet> CSSStyleSheet::createInline(RawPtr<StyleSheetContents> sheet, Node* ownerNode, const TextPosition& startPosition)
 {
     ASSERT(sheet);
-    return adoptRefWillBeNoop(new CSSStyleSheet(sheet, ownerNode, true, startPosition));
+    return new CSSStyleSheet(sheet, ownerNode, true, startPosition);
 }
 
-PassRefPtrWillBeRawPtr<CSSStyleSheet> CSSStyleSheet::createInline(Node* ownerNode, const KURL& baseURL, const TextPosition& startPosition, const String& encoding)
+RawPtr<CSSStyleSheet> CSSStyleSheet::createInline(Node* ownerNode, const KURL& baseURL, const TextPosition& startPosition, const String& encoding)
 {
     CSSParserContext parserContext(ownerNode->document(), 0, baseURL, encoding);
-    RefPtrWillBeRawPtr<StyleSheetContents> sheet = StyleSheetContents::create(baseURL.getString(), parserContext);
-    return adoptRefWillBeNoop(new CSSStyleSheet(sheet.release(), ownerNode, true, startPosition));
+    RawPtr<StyleSheetContents> sheet = StyleSheetContents::create(baseURL.getString(), parserContext);
+    return new CSSStyleSheet(sheet.release(), ownerNode, true, startPosition);
 }
 
-CSSStyleSheet::CSSStyleSheet(PassRefPtrWillBeRawPtr<StyleSheetContents> contents, CSSImportRule* ownerRule)
+CSSStyleSheet::CSSStyleSheet(RawPtr<StyleSheetContents> contents, CSSImportRule* ownerRule)
     : m_contents(contents)
     , m_isInlineStylesheet(false)
     , m_isDisabled(false)
     , m_ownerNode(nullptr)
     , m_ownerRule(ownerRule)
     , m_startPosition(TextPosition::minimumPosition())
     , m_loadCompleted(false)
 {
     m_contents->registerClient(this);
 }
 
-CSSStyleSheet::CSSStyleSheet(PassRefPtrWillBeRawPtr<StyleSheetContents> contents, Node* ownerNode, bool isInlineStylesheet, const TextPosition& startPosition)
+CSSStyleSheet::CSSStyleSheet(RawPtr<StyleSheetContents> contents, Node* ownerNode, bool isInlineStylesheet, const TextPosition& startPosition)
     : m_contents(contents)
     , m_isInlineStylesheet(isInlineStylesheet)
     , m_isDisabled(false)
     , m_ownerNode(ownerNode)
     , m_ownerRule(nullptr)
     , m_startPosition(startPosition)
     , m_loadCompleted(false)
 {
     ASSERT(isAcceptableCSSStyleSheetParent(ownerNode));
     m_contents->registerClient(this);
@@ skipping 76 matching lines @@
 
 void CSSStyleSheet::setDisabled(bool disabled)
 {
     if (disabled == m_isDisabled)
         return;
     m_isDisabled = disabled;
 
     didMutate();
 }
 
-void CSSStyleSheet::setMediaQueries(PassRefPtrWillBeRawPtr<MediaQuerySet> mediaQueries)
+void CSSStyleSheet::setMediaQueries(RawPtr<MediaQuerySet> mediaQueries)
 {
     m_mediaQueries = mediaQueries;
     if (m_mediaCSSOMWrapper && m_mediaQueries)
         m_mediaCSSOMWrapper->reattach(m_mediaQueries.get());
 
 }
 
 unsigned CSSStyleSheet::length() const
 {
     return m_contents->ruleCount();
 }
 
 CSSRule* CSSStyleSheet::item(unsigned index)
 {
     unsigned ruleCount = length();
     if (index >= ruleCount)
         return nullptr;
 
     if (m_childRuleCSSOMWrappers.isEmpty())
         m_childRuleCSSOMWrappers.grow(ruleCount);
     ASSERT(m_childRuleCSSOMWrappers.size() == ruleCount);
 
-    RefPtrWillBeMember<CSSRule>& cssRule = m_childRuleCSSOMWrappers[index];
+    Member<CSSRule>& cssRule = m_childRuleCSSOMWrappers[index];
     if (!cssRule)
         cssRule = m_contents->ruleAt(index)->createCSSOMWrapper(this);
     return cssRule.get();
 }
 
 void CSSStyleSheet::clearOwnerNode()
 {
     didMutate(EntireStyleSheetUpdate);
     if (m_ownerNode)
         m_contents->unregisterClient(this);
@@ skipping 10 matching lines @@
     Document* document = ownerDocument();
     if (!document)
         return true;
     if (document->getSecurityOrigin()->canRequestNoSuborigin(baseURL))
         return true;
     if (m_allowRuleAccessFromOrigin && document->getSecurityOrigin()->canAccessCheckSuborigins(m_allowRuleAccessFromOrigin.get()))
         return true;
     return false;
 }
 
-PassRefPtrWillBeRawPtr<CSSRuleList> CSSStyleSheet::rules()
+RawPtr<CSSRuleList> CSSStyleSheet::rules()
 {
     return cssRules();
 }
 
 unsigned CSSStyleSheet::insertRule(const String& ruleString, unsigned index, ExceptionState& exceptionState)
 {
     ASSERT(m_childRuleCSSOMWrappers.isEmpty() || m_childRuleCSSOMWrappers.size() == m_contents->ruleCount());
 
     if (index > length()) {
         exceptionState.throwDOMException(IndexSizeError, "The index provided (" + String::number(index) + ") is larger than the maximum index (" + String::number(length()) + ").");
         return 0;
     }
     CSSParserContext context(m_contents->parserContext(), UseCounter::getFrom(this));
-    RefPtrWillBeRawPtr<StyleRuleBase> rule = CSSParser::parseRule(context, m_contents.get(), ruleString);
+    RawPtr<StyleRuleBase> rule = CSSParser::parseRule(context, m_contents.get(), ruleString);
 
     if (!rule) {
         exceptionState.throwDOMException(SyntaxError, "Failed to parse the rule '" + ruleString + "'.");
         return 0;
     }
     RuleMutationScope mutationScope(this);
 
     bool success = m_contents->wrapperInsertRule(rule, index);
     if (!success) {
         if (rule->isNamespaceRule())
             exceptionState.throwDOMException(InvalidStateError, "Failed to insert the rule");
         else
             exceptionState.throwDOMException(HierarchyRequestError, "Failed to insert the rule.");
         return 0;
     }
     if (!m_childRuleCSSOMWrappers.isEmpty())
-        m_childRuleCSSOMWrappers.insert(index, RefPtrWillBeMember<CSSRule>(nullptr));
+        m_childRuleCSSOMWrappers.insert(index, Member<CSSRule>(nullptr));
 
     return index;
 }
 
 unsigned CSSStyleSheet::insertRule(const String& rule, ExceptionState& exceptionState)
 {
     Deprecation::countDeprecation(currentExecutionContext(V8PerIsolateData::mainThreadIsolate()), UseCounter::CSSStyleSheetInsertRuleOptionalArg);
     return insertRule(rule, 0, exceptionState);
 }
 
@@ skipping 34 matching lines @@
     // As per Microsoft documentation, always return -1.
     return -1;
 }
 
 int CSSStyleSheet::addRule(const String& selector, const String& style, ExceptionState& exceptionState)
 {
     return addRule(selector, style, length(), exceptionState);
 }
 
 
-PassRefPtrWillBeRawPtr<CSSRuleList> CSSStyleSheet::cssRules()
+RawPtr<CSSRuleList> CSSStyleSheet::cssRules()
 {
     if (!canAccessRules())
         return nullptr;
     if (!m_ruleListCSSOMWrapper)
         m_ruleListCSSOMWrapper = StyleSheetCSSRuleList::create(this);
     return m_ruleListCSSOMWrapper.get();
 }
 
 String CSSStyleSheet::href() const
 {
@@ skipping 79 matching lines @@
     visitor->trace(m_mediaQueries);
     visitor->trace(m_ownerNode);
     visitor->trace(m_ownerRule);
     visitor->trace(m_mediaCSSOMWrapper);
     visitor->trace(m_childRuleCSSOMWrappers);
     visitor->trace(m_ruleListCSSOMWrapper);
     StyleSheet::trace(visitor);
 }
 
 } // namespace blink