[Not for commit] Inject TRACE_EVENT to SkFontHost_FreeType.cpp

src/ports/SkFontHost_FreeType.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkAdvancedTypefaceMetrics.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkDescriptor.h"
 #include "SkFDot6.h"
 #include "SkFontDescriptor.h"
 #include "SkFontHost_FreeType_common.h"
 #include "SkGlyph.h"
 #include "SkMask.h"
 #include "SkMaskGamma.h"
 #include "SkMatrix22.h"
 #include "SkMutex.h"
 #include "SkOTUtils.h"
 #include "SkPath.h"
 #include "SkScalerContext.h"
 #include "SkStream.h"
 #include "SkString.h"
 #include "SkTemplates.h"
 #include "SkTypes.h"
 #include <memory>
 
+#include "base/trace_event/trace_event.h"
+
 #if defined(SK_CAN_USE_DLOPEN)
 #include <dlfcn.h>
 #endif
 #include <ft2build.h>
 #include FT_ADVANCES_H
 #include FT_BITMAP_H
 #include FT_FREETYPE_H
 #include FT_LCD_FILTER_H
 #include FT_MODULE_H
 #include FT_MULTIPLE_MASTERS_H
@@ skipping 11 matching lines @@
 #    define FT_LOAD_COLOR ( 1L << 20 )
 #    define FT_PIXEL_MODE_BGRA 7
 #endif
 
 //#define ENABLE_GLYPH_SPEW     // for tracing calls
 //#define DUMP_STRIKE_CREATION
 //#define SK_FONTHOST_FREETYPE_USE_NORMAL_LCD_FILTER
 //#define SK_FONTHOST_FREETYPE_RUNTIME_VERSION
 //#define SK_GAMMA_APPLY_TO_A8
 
+class SkTracedAutoMutexAcquire : SkNoncopyable {
+public:
+    explicit SkTracedAutoMutexAcquire(SkBaseMutex& mutex) : fMutex(&mutex) {
+        SkASSERT(fMutex != nullptr);
+        {
+            TRACE_EVENT1("tzik", __PRETTY_FUNCTION__, "line", __LINE__);
+            mutex.acquire();
+        }
+        TRACE_EVENT_BEGIN0("tzik", "locked");
+    }
+
+    explicit SkTracedAutoMutexAcquire(SkBaseMutex* mutex) : fMutex(mutex) {
+        if (mutex) {
+            {
+                TRACE_EVENT1("tzik", __PRETTY_FUNCTION__, "line", __LINE__);
+                mutex->acquire();
+            }
+            TRACE_EVENT_BEGIN0("tzik", "locked");
+        }
+    }
+
+    /** If the mutex has not been released, release it now. */
+    ~SkTracedAutoMutexAcquire() {
+        if (fMutex) {
+            TRACE_EVENT_END0("tzik", "locked");
+            fMutex->release();
+        }
+    }
+
+    /** If the mutex has not been released, release it now. */
+    void release() {
+        if (fMutex) {
+            fMutex->release();
+            fMutex = nullptr;
+        }
+    }
+
+    /** Assert that we're holding the mutex. */
+    void assertHeld() {
+        SkASSERT(fMutex);
+        fMutex->assertHeld();
+    }
+
+private:
+    SkBaseMutex* fMutex;
+};
+
+
 static bool isLCD(const SkScalerContext::Rec& rec) {
     return SkMask::kLCD16_Format == rec.fMaskFormat;
 }
 
 //////////////////////////////////////////////////////////////////////////
 
 extern "C" {
     static void* sk_ft_alloc(FT_Memory, long size) {
         return sk_malloc_throw(size);
     }
@@ skipping 609 matching lines @@
     //Cap the requested size as larger sizes give bogus values.
     //Remove when http://code.google.com/p/skia/issues/detail?id=554 is fixed.
     //Note that this also currently only protects against large text size requests,
     //the total matrix is not taken into account here.
     if (rec->fTextSize > SkIntToScalar(1 << 14)) {
         rec->fTextSize = SkIntToScalar(1 << 14);
     }
 
     if (isLCD(*rec)) {
         // TODO: re-work so that FreeType is set-up and selected by the SkFontMgr.
-        SkAutoMutexAcquire ama(gFTMutex);
+        SkTracedAutoMutexAcquire ama(gFTMutex);
         ref_ft_library();
         if (!gFTLibrary->isLCDSupported()) {
             // If the runtime Freetype library doesn't support LCD, disable it here.
             rec->fMaskFormat = SkMask::kA8_Format;
         }
         unref_ft_library();
     }
 
     SkPaint::Hinting h = rec->getHinting();
     if (SkPaint::kFull_Hinting == h && !isLCD(*rec)) {
@@ skipping 91 matching lines @@
 }
 
 SkScalerContext_FreeType::SkScalerContext_FreeType(SkTypeface* typeface,
                                                    const SkScalerContextEffects& effects,
                                                    const SkDescriptor* desc)
     : SkScalerContext_FreeType_Base(typeface, effects, desc)
     , fFace(nullptr)
     , fFTSize(nullptr)
     , fStrikeIndex(-1)
 {
-    SkAutoMutexAcquire  ac(gFTMutex);
+    SkTracedAutoMutexAcquire  ac(gFTMutex);
 
     if (!ref_ft_library()) {
         sk_throw();
     }
 
     // load the font file
     using UnrefFTFace = SkFunctionWrapper<void, skstd::remove_pointer_t<FT_Face>, unref_ft_face>;
     std::unique_ptr<skstd::remove_pointer_t<FT_Face>, UnrefFTFace> ftFace(ref_ft_face(typeface));
     if (nullptr == ftFace) {
         SkDEBUGF(("Could not create FT_Face.\n"));
@@ skipping 133 matching lines @@
         SkDEBUGF(("unknown kind of font \"%s\" size %f?\n",
                             fFace->family_name,     SkFDot6ToScalar(fScaleY)));
     }
 
     fFTSize = ftSize.release();
     fFace = ftFace.release();
     fDoLinearMetrics = linearMetrics;
 }
 
 SkScalerContext_FreeType::~SkScalerContext_FreeType() {
-    SkAutoMutexAcquire  ac(gFTMutex);
+    SkTracedAutoMutexAcquire  ac(gFTMutex);
 
     if (fFTSize != nullptr) {
         FT_Done_Size(fFTSize);
     }
 
     if (fFace != nullptr) {
         unref_ft_face(fFace);
     }
 
     unref_ft_library();
@@ skipping 16 matching lines @@
     // I get random italics from some other fFTSize)
     FT_Set_Transform(fFace, &fMatrix22, nullptr);
     return 0;
 }
 
 unsigned SkScalerContext_FreeType::generateGlyphCount() {
     return fFace->num_glyphs;
 }
 
 uint16_t SkScalerContext_FreeType::generateCharToGlyph(SkUnichar uni) {
-    SkAutoMutexAcquire  ac(gFTMutex);
+    SkTracedAutoMutexAcquire  ac(gFTMutex);
     return SkToU16(FT_Get_Char_Index( fFace, uni ));
 }
 
 SkUnichar SkScalerContext_FreeType::generateGlyphToChar(uint16_t glyph) {
-    SkAutoMutexAcquire  ac(gFTMutex);
+    SkTracedAutoMutexAcquire  ac(gFTMutex);
     // iterate through each cmap entry, looking for matching glyph indices
     FT_UInt glyphIndex;
     SkUnichar charCode = FT_Get_First_Char( fFace, &glyphIndex );
 
     while (glyphIndex != 0) {
         if (glyphIndex == glyph) {
             return charCode;
         }
         charCode = FT_Get_Next_Char( fFace, charCode, &glyphIndex );
     }
 
     return 0;
 }
 
 static SkScalar SkFT_FixedToScalar(FT_Fixed x) {
   return SkFixedToScalar(x);
 }
 
 void SkScalerContext_FreeType::generateAdvance(SkGlyph* glyph) {
    /* unhinted and light hinted text have linearly scaled advances
     * which are very cheap to compute with some font formats...
     */
     if (fDoLinearMetrics) {
-        SkAutoMutexAcquire  ac(gFTMutex);
+        SkTracedAutoMutexAcquire  ac(gFTMutex);
 
         if (this->setupSize()) {
             glyph->zeroMetrics();
             return;
         }
 
         FT_Error    error;
         FT_Fixed    advance;
 
         error = FT_Get_Advance( fFace, glyph->getGlyphID(),
@@ skipping 83 matching lines @@
     glyph.fHeight *= scale;
     glyph.fTop *= scale;
     glyph.fLeft *= scale;
 
     float floatScale = SkScalarToFloat(scale);
     glyph.fAdvanceX *= floatScale;
     glyph.fAdvanceY *= floatScale;
 }
 
 void SkScalerContext_FreeType::generateMetrics(SkGlyph* glyph) {
-    SkAutoMutexAcquire  ac(gFTMutex);
+    SkTracedAutoMutexAcquire  ac(gFTMutex);
 
     glyph->fRsbDelta = 0;
     glyph->fLsbDelta = 0;
 
     FT_Error    err;
 
     if (this->setupSize()) {
         glyph->zeroMetrics();
         return;
     }
@@ skipping 87 matching lines @@
     SkDEBUGF(("FT_Set_Char_Size(this:%p sx:%x sy:%x ", this, fScaleX, fScaleY));
     SkDEBUGF(("Metrics(glyph:%d flags:0x%x) w:%d\n", glyph->getGlyphID(), fLoadGlyphFlags, glyph->fWidth));
 #endif
 }
 
 static void clear_glyph_image(const SkGlyph& glyph) {
     sk_bzero(glyph.fImage, glyph.rowBytes() * glyph.fHeight);
 }
 
 void SkScalerContext_FreeType::generateImage(const SkGlyph& glyph) {
-    SkAutoMutexAcquire  ac(gFTMutex);
+    TRACE_EVENT1("tzik", __PRETTY_FUNCTION__, "line", __LINE__);
+    SkTracedAutoMutexAcquire  ac(gFTMutex);
 
     if (this->setupSize()) {
         clear_glyph_image(glyph);
         return;
     }
 
     FT_Error err = FT_Load_Glyph(fFace, glyph.getGlyphID(), fLoadGlyphFlags);
     if (err != 0) {
         SkDEBUGF(("SkScalerContext_FreeType::generateImage: FT_Load_Glyph(glyph:%d width:%d height:%d rb:%d flags:%d) returned 0x%x\n",
                   glyph.getGlyphID(), glyph.fWidth, glyph.fHeight, glyph.rowBytes(), fLoadGlyphFlags, err));
         clear_glyph_image(glyph);
         return;
     }
 
     emboldenIfNeeded(fFace, fFace->glyph);
     generateGlyphImage(fFace, glyph);
 }
 
 
 void SkScalerContext_FreeType::generatePath(const SkGlyph& glyph, SkPath* path) {
-    SkAutoMutexAcquire  ac(gFTMutex);
+    SkTracedAutoMutexAcquire  ac(gFTMutex);
 
     SkASSERT(path);
 
     if (this->setupSize()) {
         path->reset();
         return;
     }
 
     uint32_t flags = fLoadGlyphFlags;
     flags |= FT_LOAD_NO_BITMAP; // ignore embedded bitmaps so we're sure to get the outline
@@ skipping 20 matching lines @@
         FT_Vector_Transform(&vector, &fMatrix22);
         path->offset(SkFDot6ToScalar(vector.x), -SkFDot6ToScalar(vector.y));
     }
 }
 
 void SkScalerContext_FreeType::generateFontMetrics(SkPaint::FontMetrics* metrics) {
     if (nullptr == metrics) {
         return;
     }
 
-    SkAutoMutexAcquire ac(gFTMutex);
+    SkTracedAutoMutexAcquire ac(gFTMutex);
 
     if (this->setupSize()) {
         sk_bzero(metrics, sizeof(*metrics));
         return;
     }
 
     FT_Face face = fFace;
     SkScalar scaleX = fScale.x();
     SkScalar scaleY = fScale.y();
     SkScalar mxy = fMatrix22Scalar.getSkewX() * scaleY;
@@ skipping 334 matching lines @@
     }
 
     FT_Face face;
     if (FT_Open_Face(fLibrary, &args, ttcIndex, &face)) {
         return nullptr;
     }
     return face;
 }
 
 bool SkTypeface_FreeType::Scanner::recognizedFont(SkStream* stream, int* numFaces) const {
-    SkAutoMutexAcquire libraryLock(fLibraryMutex);
+    SkTracedAutoMutexAcquire libraryLock(fLibraryMutex);
 
     FT_StreamRec streamRec;
     FT_Face face = this->openFace(stream, -1, &streamRec);
     if (nullptr == face) {
         return false;
     }
 
     *numFaces = face->num_faces;
 
     FT_Done_Face(face);
     return true;
 }
 
 #include "SkTSearch.h"
 bool SkTypeface_FreeType::Scanner::scanFont(
     SkStream* stream, int ttcIndex,
     SkString* name, SkFontStyle* style, bool* isFixedPitch, AxisDefinitions* axes) const
 {
-    SkAutoMutexAcquire libraryLock(fLibraryMutex);
+    SkTracedAutoMutexAcquire libraryLock(fLibraryMutex);
 
     FT_StreamRec streamRec;
     FT_Face face = this->openFace(stream, ttcIndex, &streamRec);
     if (nullptr == face) {
         return false;
     }
 
     int weight = SkFontStyle::kNormal_Weight;
     int width = SkFontStyle::kNormal_Width;
     SkFontStyle::Slant slant = SkFontStyle::kUpright_Slant;
@@ skipping 137 matching lines @@
                 SkDEBUGF(("Requested font axis not found: %s '%c%c%c%c'\n",
                           name.c_str(),
                           (skTag >> 24) & 0xFF,
                           (skTag >> 16) & 0xFF,
                           (skTag >>  8) & 0xFF,
                           (skTag)       & 0xFF));
             }
         }
     )
 }