Backed out changeset e4cd98b5984d (bug 1779519) for causing build bustages. CLOSED TREE

Author: crisscozmuta

accessible/base/TextAttrs.cpp

@@ -410,7 +410,7 @@ bool TextAttrsMgr::FontFamilyTextAttr::GetFontFamily(nsIFrame* aFrame,
       nsLayoutUtils::GetFontMetricsForFrame(aFrame, 1.0f);
 
   gfxFontGroup* fontGroup = fm->GetThebesFontGroup();
-  RefPtr<gfxFont> font = fontGroup->GetFirstValidFont();
+  gfxFont* font = fontGroup->GetFirstValidFont();
   gfxFontEntry* fontEntry = font->GetFontEntry();
   aFamily.Append(NS_ConvertUTF8toUTF16(fontEntry->FamilyName()));
   return true;
@@ -551,7 +551,7 @@ FontWeight TextAttrsMgr::FontWeightTextAttr::GetFontWeight(nsIFrame* aFrame) {
       nsLayoutUtils::GetFontMetricsForFrame(aFrame, 1.0f);
 
   gfxFontGroup* fontGroup = fm->GetThebesFontGroup();
-  RefPtr<gfxFont> font = fontGroup->GetFirstValidFont();
+  gfxFont* font = fontGroup->GetFirstValidFont();
 
   // When there doesn't exist a bold font in the family and so the rendering of
   // a non-bold font face is changed so that the user sees what looks like a

dom/canvas/CanvasRenderingContext2D.cpp

@@ -4245,9 +4245,9 @@ TextMetrics* CanvasRenderingContext2D::DrawOrMeasureText(
 
   processor.mFontgrp
       ->UpdateUserFonts();  // ensure user font generation is current
-  RefPtr<gfxFont> font = processor.mFontgrp->GetFirstValidFont();
   const gfxFont::Metrics& fontMetrics =
-      font->GetMetrics(nsFontMetrics::eHorizontal);
+      processor.mFontgrp->GetFirstValidFont()->GetMetrics(
+          nsFontMetrics::eHorizontal);
 
   // calls bidi algo twice since it needs the full text width and the
   // bounding boxes before rendering anything

gfx/src/nsFontMetrics.cpp

@@ -159,9 +159,8 @@ void nsFontMetrics::Destroy() { mPresContext = nullptr; }
 
 static const gfxFont::Metrics& GetMetrics(
     nsFontMetrics* aFontMetrics, nsFontMetrics::FontOrientation aOrientation) {
-  RefPtr<gfxFont> font =
-      aFontMetrics->GetThebesFontGroup()->GetFirstValidFont();
-  return font->GetMetrics(aOrientation);
+  return aFontMetrics->GetThebesFontGroup()->GetFirstValidFont()->GetMetrics(
+      aOrientation);
 }
 
 static const gfxFont::Metrics& GetMetrics(nsFontMetrics* aFontMetrics) {

gfx/thebes/gfxFont.cpp

@@ -231,29 +231,21 @@ bool gfxFontCache::HashEntry::KeyEquals(const KeyTypePointer aKey) const {
            aKey->mUnicodeRangeMap->Equals(fontUnicodeRangeMap)));
 }
 
-already_AddRefed<gfxFont> gfxFontCache::Lookup(
-    const gfxFontEntry* aFontEntry, const gfxFontStyle* aStyle,
-    const gfxCharacterMap* aUnicodeRangeMap) {
+gfxFont* gfxFontCache::Lookup(const gfxFontEntry* aFontEntry,
+                              const gfxFontStyle* aStyle,
+                              const gfxCharacterMap* aUnicodeRangeMap) {
   MutexAutoLock lock(mMutex);
 
   Key key(aFontEntry, aStyle, aUnicodeRangeMap);
   HashEntry* entry = mFonts.GetEntry(key);
 
   Telemetry::Accumulate(Telemetry::FONT_CACHE_HIT, entry != nullptr);
 
-  if (!entry) {
-    return nullptr;
-  }
-
-  RefPtr<gfxFont> font = entry->mFont;
-  if (font->GetExpirationState()->IsTracked()) {
-    RemoveObjectLocked(font, lock);
-  }
-  return font.forget();
+  return entry ? entry->mFont : nullptr;
 }
 
 void gfxFontCache::AddNew(gfxFont* aFont) {
-  nsTArray<gfxFont*> discard;
+  gfxFont* oldFont;
   {
     MutexAutoLock lock(mMutex);
 
@@ -263,39 +255,28 @@ void gfxFontCache::AddNew(gfxFont* aFont) {
     if (!entry) {
       return;
     }
-    gfxFont* oldFont = entry->mFont;
+    oldFont = entry->mFont;
     entry->mFont = aFont;
     // Assert that we can find the entry we just put in (this fails if the key
     // has a NaN float value in it, e.g. 'sizeAdjust').
     MOZ_ASSERT(entry == mFonts.GetEntry(key));
+  }
 
-    // If someone's asked us to replace an existing font entry, then that's a
-    // bit weird, but let it happen, and expire the old font if it's not used.
-    if (oldFont && oldFont->GetExpirationState()->IsTracked()) {
-      // if oldFont == aFont, recount should be > 0,
-      // so we shouldn't be here.
-      NS_ASSERTION(aFont != oldFont, "new font is tracked for expiry!");
-      NotifyExpiredLocked(oldFont, lock);
-      discard = std::move(mTrackerDiscard);
-    }
+  // If someone's asked us to replace an existing font entry, then that's a
+  // bit weird, but let it happen, and expire the old font if it's not used.
+  if (oldFont && oldFont->GetExpirationState()->IsTracked()) {
+    // if oldFont == aFont, recount should be > 0,
+    // so we shouldn't be here.
+    NS_ASSERTION(aFont != oldFont, "new font is tracked for expiry!");
+    NotifyExpired(oldFont);
   }
-  DestroyDiscard(discard);
 }
 
 void gfxFontCache::NotifyReleased(gfxFont* aFont) {
-  nsTArray<gfxFont*> discard;
-  {
-    MutexAutoLock lock(mMutex);
-    if (NS_SUCCEEDED(AddObjectLocked(aFont, lock))) {
-      return;
-    }
-
+  if (NS_FAILED(AddObject(aFont))) {
     // We couldn't track it for some reason. Kill it now.
-    DestroyFontLocked(aFont);
-    discard = std::move(mTrackerDiscard);
+    DestroyFont(aFont);
   }
-
-  DestroyDiscard(discard);
   // Note that we might have fonts that aren't in the hashtable, perhaps because
   // of OOM adding to the hashtable or because someone did an AddNew where
   // we already had a font. These fonts are added to the expiration tracker
@@ -304,17 +285,15 @@ void gfxFontCache::NotifyReleased(gfxFont* aFont) {
 }
 
 void gfxFontCache::NotifyExpiredLocked(gfxFont* aFont, const AutoLock& aLock) {
+  aFont->ClearCachedWords();
   RemoveObjectLocked(aFont, aLock);
   DestroyFontLocked(aFont);
 }
 
-void gfxFontCache::NotifyHandlerEnd() {
-  nsTArray<gfxFont*> discard;
-  {
-    MutexAutoLock lock(mMutex);
-    discard = std::move(mTrackerDiscard);
-  }
-  DestroyDiscard(discard);
+void gfxFontCache::NotifyExpired(gfxFont* aFont) {
+  aFont->ClearCachedWords();
+  RemoveObject(aFont);
+  DestroyFont(aFont);
 }
 
 void gfxFontCache::DestroyFontLocked(gfxFont* aFont) {
@@ -326,38 +305,23 @@ void gfxFontCache::DestroyFontLocked(gfxFont* aFont) {
   }
   NS_ASSERTION(aFont->GetRefCount() == 0,
                "Destroying with non-zero ref count!");
-  mTrackerDiscard.AppendElement(aFont);
-}
-
-void gfxFontCache::DestroyDiscard(nsTArray<gfxFont*>& aDiscard) {
-  for (auto* font : aDiscard) {
-    NS_ASSERTION(font->GetRefCount() == 0,
-                 "Destroying with non-zero ref count!");
-    font->ClearCachedWords();
-    delete font;
-  }
-  aDiscard.Clear();
-}
-
-void gfxFontCache::Flush() {
-  nsTArray<gfxFont*> discard;
-  {
-    MutexAutoLock lock(mMutex);
-    mFonts.Clear();
-    AgeAllGenerationsLocked(lock);
-    discard = std::move(mTrackerDiscard);
-  }
-  DestroyDiscard(discard);
+  MutexAutoUnlock unlock(mMutex);
+  delete aFont;
 }
 
-void gfxFontCache::AgeAllGenerations() {
-  nsTArray<gfxFont*> discard;
+void gfxFontCache::DestroyFont(gfxFont* aFont) {
   {
     MutexAutoLock lock(mMutex);
-    AgeAllGenerationsLocked(lock);
-    discard = std::move(mTrackerDiscard);
+    Key key(aFont->GetFontEntry(), aFont->GetStyle(),
+            aFont->GetUnicodeRangeMap());
+    HashEntry* entry = mFonts.GetEntry(key);
+    if (entry && entry->mFont == aFont) {
+      mFonts.RemoveEntry(entry);
+    }
   }
-  DestroyDiscard(discard);
+  NS_ASSERTION(aFont->GetRefCount() == 0,
+               "Destroying with non-zero ref count!");
+  delete aFont;
 }
 
 /*static*/
@@ -3617,16 +3581,15 @@ bool gfxFont::InitFakeSmallCapsRun(
                               aSyntheticUpper);
 }
 
-already_AddRefed<gfxFont> gfxFont::GetSmallCapsFont() const {
+gfxFont* gfxFont::GetSmallCapsFont() const {
   gfxFontStyle style(*GetStyle());
   style.size *= SMALL_CAPS_SCALE_FACTOR;
   style.variantCaps = NS_FONT_VARIANT_CAPS_NORMAL;
   gfxFontEntry* fe = GetFontEntry();
   return fe->FindOrMakeFont(&style, mUnicodeRangeMap);
 }
 
-already_AddRefed<gfxFont> gfxFont::GetSubSuperscriptFont(
-    int32_t aAppUnitsPerDevPixel) const {
+gfxFont* gfxFont::GetSubSuperscriptFont(int32_t aAppUnitsPerDevPixel) const {
   gfxFontStyle style(*GetStyle());
   style.AdjustForSubSuperscript(aAppUnitsPerDevPixel);
   gfxFontEntry* fe = GetFontEntry();

gfx/thebes/gfxFont.h

@@ -317,9 +317,8 @@ class gfxFontCache final
 
   // Look up a font in the cache. Returns null if there's nothing matching
   // in the cache
-  already_AddRefed<gfxFont> Lookup(const gfxFontEntry* aFontEntry,
-                                   const gfxFontStyle* aStyle,
-                                   const gfxCharacterMap* aUnicodeRangeMap);
+  gfxFont* Lookup(const gfxFontEntry* aFontEntry, const gfxFontStyle* aStyle,
+                  const gfxCharacterMap* aUnicodeRangeMap);
 
   // We created a new font (presumably because Lookup returned null);
   // put it in the cache. The font's refcount should be nonzero. It is
@@ -335,7 +334,13 @@ class gfxFontCache final
   // Cleans out the hashtable and removes expired fonts waiting for cleanup.
   // Other gfxFont objects may be still in use but they will be pushed
   // into the expiration queues and removed.
-  void Flush();
+  void Flush() {
+    {
+      mozilla::MutexAutoLock lock(mMutex);
+      mFonts.Clear();
+    }
+    AgeAllGenerations();
+  }
 
   void FlushShapedWordCaches();
   void NotifyGlyphsChanged();
@@ -369,7 +374,15 @@ class gfxFontCache final
   void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
                               FontCacheSizes* aSizes) const;
 
-  void AgeAllGenerations();
+  void AgeAllGenerations() {
+    AutoLock lock(mMutex);
+    AgeAllGenerationsLocked(lock);
+  }
+
+  void RemoveObject(gfxFont* aFont) {
+    AutoLock lock(mMutex);
+    RemoveObjectLocked(aFont, lock);
+  }
 
  protected:
   class MemoryReporter final : public nsIMemoryReporter {
@@ -398,10 +411,10 @@ class gfxFontCache final
   // font; we just delete it.
   void NotifyExpiredLocked(gfxFont* aFont, const AutoLock&)
       REQUIRES(mMutex) override;
-  void NotifyHandlerEnd() override;
+  void NotifyExpired(gfxFont* aFont);
 
+  void DestroyFont(gfxFont* aFont);
   void DestroyFontLocked(gfxFont* aFont) REQUIRES(mMutex);
-  void DestroyDiscard(nsTArray<gfxFont*>& aDiscard);
 
   static gfxFontCache* gGlobalCache;
 
@@ -442,8 +455,6 @@ class gfxFontCache final
 
   nsTHashtable<HashEntry> mFonts GUARDED_BY(mMutex);
 
-  nsTArray<gfxFont*> mTrackerDiscard GUARDED_BY(mMutex);
-
   static void WordCacheExpirationTimerCallback(nsITimer* aTimer, void* aCache);
 
   nsCOMPtr<nsITimer> mWordCacheExpirationTimer GUARDED_BY(mMutex);
@@ -1428,6 +1439,14 @@ class gfxFont {
 
   nsrefcnt AddRef(void) {
     MOZ_ASSERT(int32_t(mRefCnt) >= 0, "illegal refcnt");
+    nsExpirationState state;
+    {
+      mozilla::AutoReadLock lock(mLock);
+      state = mExpirationState;
+    }
+    if (state.IsTracked()) {
+      gfxFontCache::GetCache()->RemoveObject(this);
+    }
     ++mRefCnt;
     NS_LOG_ADDREF(this, mRefCnt, "gfxFont", sizeof(*this));
     return mRefCnt;
@@ -1947,8 +1966,7 @@ class gfxFont {
 
   // Return a cloned font resized and offset to simulate sub/superscript
   // glyphs. This does not add a reference to the returned font.
-  already_AddRefed<gfxFont> GetSubSuperscriptFont(
-      int32_t aAppUnitsPerDevPixel) const;
+  gfxFont* GetSubSuperscriptFont(int32_t aAppUnitsPerDevPixel) const;
 
   bool HasColorGlyphFor(uint32_t aCh, uint32_t aNextCh);
 
@@ -1999,7 +2017,7 @@ class gfxFont {
   // Return a font that is a "clone" of this one, but reduced to 80% size
   // (and with variantCaps set to normal). This does not add a reference to
   // the returned font.
-  already_AddRefed<gfxFont> GetSmallCapsFont() const;
+  gfxFont* GetSmallCapsFont() const;
 
   // subclasses may provide (possibly hinted) glyph widths (in font units);
   // if they do not override this, harfbuzz will use unhinted widths
@@ -2221,9 +2239,7 @@ class gfxFont {
   // This is OK because we only multiply by this factor, never divide.
   float mFUnitsConvFactor;
 
-  // This is guarded by gfxFontCache::GetCache()->GetMutex() but it is difficult
-  // to annotate that fact.
-  nsExpirationState mExpirationState;
+  nsExpirationState mExpirationState GUARDED_BY(mLock);
 
   // Glyph ID of the font's <space> glyph, zero if missing
   uint16_t mSpaceGlyph = 0;

gfx/thebes/gfxFontEntry.cpp

@@ -266,9 +266,9 @@ nsCString gfxFontEntry::RealFaceName() {
   return Name();
 }
 
-already_AddRefed<gfxFont> gfxFontEntry::FindOrMakeFont(
-    const gfxFontStyle* aStyle, gfxCharacterMap* aUnicodeRangeMap) {
-  RefPtr<gfxFont> font =
+gfxFont* gfxFontEntry::FindOrMakeFont(const gfxFontStyle* aStyle,
+                                      gfxCharacterMap* aUnicodeRangeMap) {
+  gfxFont* font =
       gfxFontCache::GetCache()->Lookup(this, aStyle, aUnicodeRangeMap);
 
   if (!font) {
@@ -284,7 +284,7 @@ already_AddRefed<gfxFont> gfxFontEntry::FindOrMakeFont(
     font->SetUnicodeRangeMap(aUnicodeRangeMap);
     gfxFontCache::GetCache()->AddNew(font);
   }
-  return font.forget();
+  return font;
 }
 
 uint16_t gfxFontEntry::UnitsPerEm() {

gfx/thebes/gfxFontEntry.h

@@ -329,8 +329,8 @@ class gfxFontEntry {
   // cached instance; but we also don't return already_AddRefed, because
   // the caller may only need to use the font temporarily and doesn't need
   // a strong reference.
-  already_AddRefed<gfxFont> FindOrMakeFont(
-      const gfxFontStyle* aStyle, gfxCharacterMap* aUnicodeRangeMap = nullptr);
+  gfxFont* FindOrMakeFont(const gfxFontStyle* aStyle,
+                          gfxCharacterMap* aUnicodeRangeMap = nullptr);
 
   // Get an existing font table cache entry in aBlob if it has been
   // registered, or return false if not.  Callers must call