Oilpan: Remove most WillBe types from the code base

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 PassRefPtrWillBeRawPtr<LoadFontPromiseResolver> create(FontFaceArray faces, ScriptState* scriptState)
+    static RawPtr<LoadFontPromiseResolver> create(FontFaceArray faces, ScriptState* scriptState)
     {
-        return adoptRefWillBeNoop(new LoadFontPromiseResolver(faces, scriptState));
+        return (new LoadFontPromiseResolver(faces, scriptState));
     }
 
     void loadFonts(ExecutionContext*);
     ScriptPromise promise() { return m_resolver->promise(); }
 
     void notifyLoaded(FontFace*) override;
     void notifyError(FontFace*) override;
 
     DECLARE_VIRTUAL_TRACE();
 
 private:
     LoadFontPromiseResolver(FontFaceArray faces, ScriptState* scriptState)
         : m_numLoading(faces.size())
         , m_errorOccured(false)
         , m_resolver(ScriptPromiseResolver::create(scriptState))
     {
         m_fontFaces.swap(faces);
     }
 
-    WillBeHeapVector<RefPtrWillBeMember<FontFace>> m_fontFaces;
+    HeapVector<Member<FontFace>> m_fontFaces;
     int m_numLoading;
     bool m_errorOccured;
-    PersistentWillBeMember<ScriptPromiseResolver> m_resolver;
+    Member<ScriptPromiseResolver> m_resolver;
 };
 
 void LoadFontPromiseResolver::loadFonts(ExecutionContext* context)
 {
     if (!m_numLoading) {
         m_resolver->resolve(m_fontFaces);
         return;
     }
 
     for (size_t i = 0; i < m_fontFaces.size(); i++)
@@ skipping 140 matching lines @@
     removeFromLoadingFonts(fontFace);
 }
 
 void FontFaceSet::loadError(FontFace* fontFace)
 {
     m_histogram.updateStatus(fontFace);
     m_failedFonts.append(fontFace);
     removeFromLoadingFonts(fontFace);
 }
 
-void FontFaceSet::addToLoadingFonts(PassRefPtrWillBeRawPtr<FontFace> fontFace)
+void FontFaceSet::addToLoadingFonts(RawPtr<FontFace> fontFace)
 {
     if (!m_isLoading) {
         m_isLoading = true;
         m_shouldFireLoadingEvent = true;
         if (m_ready->state() != ReadyProperty::Pending)
             m_ready->reset();
         handlePendingEventsAndPromisesSoon();
     }
     m_loadingFonts.add(fontFace);
 }
 
-void FontFaceSet::removeFromLoadingFonts(PassRefPtrWillBeRawPtr<FontFace> fontFace)
+void FontFaceSet::removeFromLoadingFonts(RawPtr<FontFace> fontFace)
 {
     m_loadingFonts.remove(fontFace);
     if (m_loadingFonts.isEmpty())
         handlePendingEventsAndPromisesSoon();
 }
 
 ScriptPromise FontFaceSet::ready(ScriptState* scriptState)
 {
     return m_ready->promise(scriptState->world());
 }
 
-PassRefPtrWillBeRawPtr<FontFaceSet> FontFaceSet::addForBinding(ScriptState*, FontFace* fontFace, ExceptionState&)
+RawPtr<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 17 matching lines @@
     }
     m_nonCSSConnectedFaces.clear();
     fontSelector->fontFaceInvalidated();
 }
 
 bool FontFaceSet::deleteForBinding(ScriptState*, FontFace* fontFace, ExceptionState&)
 {
     ASSERT(fontFace);
     if (!inActiveDocumentContext())
         return false;
-    WillBeHeapListHashSet<RefPtrWillBeMember<FontFace>>::iterator it = m_nonCSSConnectedFaces.find(fontFace);
+    HeapListHashSet<Member<FontFace>>::iterator it = m_nonCSSConnectedFaces.find(fontFace);
     if (it != m_nonCSSConnectedFaces.end()) {
         m_nonCSSConnectedFaces.remove(it);
         CSSFontSelector* fontSelector = document()->styleEngine().fontSelector();
         fontSelector->fontFaceCache()->removeFontFace(fontFace, false);
         if (fontFace->loadStatus() == FontFace::Loading)
             removeFromLoadingFonts(fontFace);
         fontSelector->fontFaceInvalidated();
         return true;
     }
     return false;
 }
 
 bool FontFaceSet::hasForBinding(ScriptState*, FontFace* fontFace, ExceptionState&) const
 {
     ASSERT(fontFace);
     if (!inActiveDocumentContext())
         return false;
     return m_nonCSSConnectedFaces.contains(fontFace) || isCSSConnectedFontFace(fontFace);
 }
 
-const WillBeHeapListHashSet<RefPtrWillBeMember<FontFace>>& FontFaceSet::cssConnectedFontFaceList() const
+const HeapListHashSet<Member<FontFace>>& FontFaceSet::cssConnectedFontFaceList() const
 {
     Document* d = document();
     d->ensureStyleResolver(); // Flush pending style changes.
     return d->styleEngine().fontSelector()->fontFaceCache()->cssConnectedFontFaces();
 }
 
 bool FontFaceSet::isCSSConnectedFontFace(FontFace* fontFace) const
 {
     return cssConnectedFontFaceList().contains(fontFace);
 }
@@ skipping 13 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) {
-        RefPtrWillBeRawPtr<FontFaceSetLoadEvent> doneEvent = nullptr;
-        RefPtrWillBeRawPtr<FontFaceSetLoadEvent> errorEvent = nullptr;
+        RawPtr<FontFaceSetLoadEvent> doneEvent = nullptr;
+        RawPtr<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.fontDescription().family(); f; f = f->next()) {
         CSSSegmentedFontFace* segmentedFontFace = fontFaceCache->get(font.fontDescription(), f->family());
         if (segmentedFontFace)
             segmentedFontFace->match(text, faces);
     }
 
-    RefPtrWillBeRawPtr<LoadFontPromiseResolver> resolver = LoadFontPromiseResolver::create(faces, scriptState);
+    RawPtr<LoadFontPromiseResolver> resolver = LoadFontPromiseResolver::create(faces, scriptState);
     ScriptPromise promise = resolver->promise();
     resolver->loadFonts(executionContext()); // 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.
-    RefPtrWillBeRawPtr<MutableStylePropertySet> parsedStyle = MutableStylePropertySet::create(HTMLStandardMode);
+    RawPtr<MutableStylePropertySet> parsedStyle = MutableStylePropertySet::create(HTMLStandardMode);
     CSSParser::parseValue(parsedStyle.get(), 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();
 
@@ skipping 38 matching lines @@
         hadBlankTextHistogram.count(m_status == HadBlankText ? 1 : 0);
         m_status = Reported;
     }
 }
 
 static const char* supplementName()
 {
     return "FontFaceSet";
 }
 
-PassRefPtrWillBeRawPtr<FontFaceSet> FontFaceSet::from(Document& document)
+RawPtr<FontFaceSet> FontFaceSet::from(Document& document)
 {
-    RefPtrWillBeRawPtr<FontFaceSet> fonts = static_cast<FontFaceSet*>(SupplementType::from(document, supplementName()));
+    RawPtr<FontFaceSet> fonts = static_cast<FontFaceSet*>(SupplementType::from(document, supplementName()));
     if (!fonts) {
         fonts = FontFaceSet::create(document);
         SupplementType::provideTo(document, supplementName(), fonts);
     }
 
     return fonts.release();
 }
 
 void FontFaceSet::didLayout(Document& document)
 {
     if (FontFaceSet* fonts = static_cast<FontFaceSet*>(SupplementType::from(document, supplementName())))
         fonts->didLayout();
 }
 
 FontFaceSetIterable::IterationSource* FontFaceSet::startIteration(ScriptState*, ExceptionState&)
 {
     // Setlike should iterate each item in insertion order, and items should
     // be keep on up to date. But since blink does not have a way to hook up CSS
     // modification, take a snapshot here, and make it ordered as follows.
-    WillBeHeapVector<RefPtrWillBeMember<FontFace>> fontFaces;
+    HeapVector<Member<FontFace>> fontFaces;
     if (inActiveDocumentContext()) {
-        const WillBeHeapListHashSet<RefPtrWillBeMember<FontFace>>& cssConnectedFaces = cssConnectedFontFaceList();
+        const HeapListHashSet<Member<FontFace>>& cssConnectedFaces = cssConnectedFontFaceList();
         fontFaces.reserveInitialCapacity(cssConnectedFaces.size() + m_nonCSSConnectedFaces.size());
         for (const auto& fontFace : cssConnectedFaces)
             fontFaces.append(fontFace);
         for (const auto& fontFace : m_nonCSSConnectedFaces)
             fontFaces.append(fontFace);
     }
     return new IterationSource(fontFaces);
 }
 
-bool FontFaceSet::IterationSource::next(ScriptState*, RefPtrWillBeMember<FontFace>& key, RefPtrWillBeMember<FontFace>& value, ExceptionState&)
+bool FontFaceSet::IterationSource::next(ScriptState*, Member<FontFace>& key, Member<FontFace>& value, ExceptionState&)
 {
     if (m_fontFaces.size() <= m_index)
         return false;
     key = value = m_fontFaces[m_index++];
     return true;
 }
 
 DEFINE_TRACE(FontFaceSet)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_ready);
     visitor->trace(m_loadingFonts);
     visitor->trace(m_loadedFonts);
     visitor->trace(m_failedFonts);
     visitor->trace(m_nonCSSConnectedFaces);
     visitor->trace(m_asyncRunner);
     HeapSupplement<Document>::trace(visitor);
 #endif
     EventTargetWithInlineData::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink