Remove RawPtr from core/css

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

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 31 matching lines @@
 #include "core/style/StyleInheritedData.h"
 #include "platform/Histogram.h"
 
 namespace blink {
 
 static const int defaultFontSize = 10;
 static const char defaultFontFamily[] = "sans-serif";
 
 class LoadFontPromiseResolver final : public FontFace::LoadFontCallback {
 public:
-    static RawPtr<LoadFontPromiseResolver> create(FontFaceArray faces, ScriptState* scriptState)
+    static LoadFontPromiseResolver* create(FontFaceArray faces, ScriptState* scriptState)
     {
         return new LoadFontPromiseResolver(faces, scriptState);
     }
 
     void loadFonts(ExecutionContext*);
     ScriptPromise promise() { return m_resolver->promise(); }
 
     void notifyLoaded(FontFace*) override;
     void notifyError(FontFace*) override;
 
@@ skipping 165 matching lines @@
     removeFromLoadingFonts(fontFace);
 }
 
 void FontFaceSet::loadError(FontFace* fontFace)
 {
     m_histogram.updateStatus(fontFace);
     m_failedFonts.append(fontFace);
     removeFromLoadingFonts(fontFace);
 }
 
-void FontFaceSet::addToLoadingFonts(RawPtr<FontFace> fontFace)
+void FontFaceSet::addToLoadingFonts(FontFace* fontFace)
 {
     if (!m_isLoading) {
         m_isLoading = true;
         m_shouldFireLoadingEvent = true;
         if (m_ready->getState() != ReadyProperty::Pending)
             m_ready->reset();
         handlePendingEventsAndPromisesSoon();
     }
     m_loadingFonts.add(fontFace);
 }
 
-void FontFaceSet::removeFromLoadingFonts(RawPtr<FontFace> fontFace)
+void FontFaceSet::removeFromLoadingFonts(FontFace* fontFace)
 {
     m_loadingFonts.remove(fontFace);
     if (m_loadingFonts.isEmpty())
         handlePendingEventsAndPromisesSoon();
 }
 
 ScriptPromise FontFaceSet::ready(ScriptState* scriptState)
 {
     return m_ready->promise(scriptState->world());
 }
 
-RawPtr<FontFaceSet> FontFaceSet::addForBinding(ScriptState*, FontFace* fontFace, ExceptionState&)
+FontFaceSet* FontFaceSet::addForBinding(ScriptState*, FontFace* fontFace, ExceptionState&)
 {
     ASSERT(fontFace);
     if (!inActiveDocumentContext())
         return this;
     if (m_nonCSSConnectedFaces.contains(fontFace))
         return this;
     if (isCSSConnectedFontFace(fontFace))
         return this;
     CSSFontSelector* fontSelector = document()->styleEngine().fontSelector();
     m_nonCSSConnectedFaces.add(fontFace);
@@ skipping 72 matching lines @@
         return;
 
     // If the layout was invalidated in between when we thought layout
     // was updated and when we're ready to fire the event, just wait
     // until after the next layout before firing events.
     Document* d = document();
     if (!d->view() || d->view()->needsLayout())
         return;
 
     if (m_isLoading) {
-        RawPtr<FontFaceSetLoadEvent> doneEvent = nullptr;
-        RawPtr<FontFaceSetLoadEvent> errorEvent = nullptr;
+        FontFaceSetLoadEvent* doneEvent = nullptr;
+        FontFaceSetLoadEvent* errorEvent = nullptr;
         doneEvent = FontFaceSetLoadEvent::createForFontFaces(EventTypeNames::loadingdone, m_loadedFonts);
         m_loadedFonts.clear();
         if (!m_failedFonts.isEmpty()) {
             errorEvent = FontFaceSetLoadEvent::createForFontFaces(EventTypeNames::loadingerror, m_failedFonts);
             m_failedFonts.clear();
         }
         m_isLoading = false;
         dispatchEvent(doneEvent);
         if (errorEvent)
             dispatchEvent(errorEvent);
@@ skipping 17 matching lines @@
     }
 
     FontFaceCache* fontFaceCache = document()->styleEngine().fontSelector()->fontFaceCache();
     FontFaceArray faces;
     for (const FontFamily* f = &font.getFontDescription().family(); f; f = f->next()) {
         CSSSegmentedFontFace* segmentedFontFace = fontFaceCache->get(font.getFontDescription(), f->family());
         if (segmentedFontFace)
             segmentedFontFace->match(text, faces);
     }
 
-    RawPtr<LoadFontPromiseResolver> resolver = LoadFontPromiseResolver::create(faces, scriptState);
+    LoadFontPromiseResolver* resolver = LoadFontPromiseResolver::create(faces, scriptState);
     ScriptPromise promise = resolver->promise();
     resolver->loadFonts(getExecutionContext()); // After this, resolver->promise() may return null.
     return promise;
 }
 
 bool FontFaceSet::check(const String& fontString, const String& text, ExceptionState& exceptionState)
 {
     if (!inActiveDocumentContext())
         return false;
 
@@ skipping 23 matching lines @@
     }
     return false;
 }
 
 bool FontFaceSet::resolveFontStyle(const String& fontString, Font& font)
 {
     if (fontString.isEmpty())
         return false;
 
     // Interpret fontString in the same way as the 'font' attribute of CanvasRenderingContext2D.
-    RawPtr<MutableStylePropertySet> parsedStyle = MutableStylePropertySet::create(HTMLStandardMode);
-    CSSParser::parseValue(parsedStyle.get(), CSSPropertyFont, fontString, true, 0);
+    MutableStylePropertySet* parsedStyle = MutableStylePropertySet::create(HTMLStandardMode);
+    CSSParser::parseValue(parsedStyle, CSSPropertyFont, fontString, true, 0);
     if (parsedStyle->isEmpty())
         return false;
 
     String fontValue = parsedStyle->getPropertyValue(CSSPropertyFont);
     if (fontValue == "inherit" || fontValue == "initial")
         return false;
 
     RefPtr<ComputedStyle> style = ComputedStyle::create();
 
     FontFamily fontFamily;
@@ skipping 37 matching lines @@
         hadBlankTextHistogram.count(m_status == HadBlankText ? 1 : 0);
         m_status = Reported;
     }
 }
 
 static const char* supplementName()
 {
     return "FontFaceSet";
 }
 
-RawPtr<FontFaceSet> FontFaceSet::from(Document& document)
+FontFaceSet* FontFaceSet::from(Document& document)
 {
-    RawPtr<FontFaceSet> fonts = static_cast<FontFaceSet*>(Supplement<Document>::from(document, supplementName()));
+    FontFaceSet* fonts = static_cast<FontFaceSet*>(Supplement<Document>::from(document, supplementName()));
     if (!fonts) {
         fonts = FontFaceSet::create(document);
         Supplement<Document>::provideTo(document, supplementName(), fonts);
     }
 
-    return fonts.release();
+    return fonts;
 }
 
 void FontFaceSet::didLayout(Document& document)
 {
     if (FontFaceSet* fonts = static_cast<FontFaceSet*>(Supplement<Document>::from(document, supplementName())))
         fonts->didLayout();
 }
 
 FontFaceSetIterable::IterationSource* FontFaceSet::startIteration(ScriptState*, ExceptionState&)
 {
@@ skipping 27 matching lines @@
     visitor->trace(m_loadedFonts);
     visitor->trace(m_failedFonts);
     visitor->trace(m_nonCSSConnectedFaces);
     visitor->trace(m_asyncRunner);
     EventTargetWithInlineData::trace(visitor);
     Supplement<Document>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink