Add shared mutexes to the direct write cache code to get better parallelism.

src/ports/SkScalerContext_win_dw.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkTypes.h"
 #undef GetGlyphIndices
 
 #include "SkDWrite.h"
 #include "SkDWriteGeometrySink.h"
 #include "SkEndian.h"
 #include "SkGlyph.h"
 #include "SkHRESULT.h"
 #include "SkMaskGamma.h"
 #include "SkMatrix22.h"
 #include "SkMutex.h"
 #include "SkOTTable_EBLC.h"
 #include "SkOTTable_EBSC.h"
 #include "SkOTTable_gasp.h"
 #include "SkOTTable_maxp.h"
 #include "SkPath.h"
 #include "SkScalerContext.h"
 #include "SkScalerContext_win_dw.h"
+#include "SkSharedMutex.h"
 #include "SkTScopedComPtr.h"
 #include "SkTypeface_win_dw.h"
 
 #include <dwrite.h>
 #if SK_HAS_DWRITE_1_H
 #  include <dwrite_1.h>
 #endif
 
 /* Note:
  * In versions 8 and 8.1 of Windows, some calls in DWrite are not thread safe.
  * The DWriteFactoryMutex protects the calls that are problematic.
  */
-SK_DECLARE_STATIC_MUTEX(DWriteFactoryMutex);
+static SkSharedMutex DWriteFactoryMutex;
 
-typedef SkAutoMutexExclusive Exclusive;
+typedef SkAutoTExclusive<SkSharedMutex> Exclusive;
+typedef SkAutoSharedMutexShared Shared;
 
 static bool isLCD(const SkScalerContext::Rec& rec) {
     return SkMask::kLCD16_Format == rec.fMaskFormat;
 }
 
 static bool is_hinted_without_gasp(DWriteFontTypeface* typeface) {
     Exclusive l(DWriteFactoryMutex);
     AutoTDWriteTable<SkOTTableMaximumProfile> maxp(typeface->fDWriteFontFace.get());
     if (!maxp.fExists) {
         return false;
@@ skipping 307 matching lines @@
                  &gm),
              "Could not get gdi compatible glyph metrics.");
     } else {
         Exclusive l(DWriteFactoryMutex);
         HRVM(fTypeface->fDWriteFontFace->GetDesignGlyphMetrics(&glyphId, 1, &gm),
              "Could not get design metrics.");
     }
 
     DWRITE_FONT_METRICS dwfm;
     {
-        Exclusive l(DWriteFactoryMutex);
+        Shared l(DWriteFactoryMutex);
         fTypeface->fDWriteFontFace->GetMetrics(&dwfm);
     }
     SkScalar advanceX = SkScalarMulDiv(fTextSizeMeasure,
                                        SkIntToScalar(gm.advanceWidth),
                                        SkIntToScalar(dwfm.designUnitsPerEm));
 
     SkVector vecs[1] = { { advanceX, 0 } };
     if (DWRITE_MEASURING_MODE_GDI_CLASSIC == fMeasuringMode ||
         DWRITE_MEASURING_MODE_GDI_NATURAL == fMeasuringMode)
     {
@@ skipping 28 matching lines @@
 
     DWRITE_GLYPH_RUN run;
     run.glyphCount = 1;
     run.glyphAdvances = &advance;
     run.fontFace = fTypeface->fDWriteFontFace.get();
     run.fontEmSize = SkScalarToFloat(fTextSizeRender);
     run.bidiLevel = 0;
     run.glyphIndices = &glyphId;
     run.isSideways = FALSE;
     run.glyphOffsets = &offset;
+
+    SkTScopedComPtr<IDWriteGlyphRunAnalysis> glyphRunAnalysis;
     {
         Exclusive l(DWriteFactoryMutex);
-        SkTScopedComPtr<IDWriteGlyphRunAnalysis> glyphRunAnalysis;
         HRM(fTypeface->fFactory->CreateGlyphRunAnalysis(
             &run,
             1.0f, // pixelsPerDip,
             &fXform,
             renderingMode,
             fMeasuringMode,
             0.0f, // baselineOriginX,
             0.0f, // baselineOriginY,
             &glyphRunAnalysis),
             "Could not create glyph run analysis.");
-
+    }
+    {
+        Shared l(DWriteFactoryMutex);
         HRM(glyphRunAnalysis->GetAlphaTextureBounds(textureType, bbox),
             "Could not get texture bounds.");
     }
     return S_OK;
 }
 
 /** GetAlphaTextureBounds succeeds but sometimes returns empty bounds like
  *  { 0x80000000, 0x80000000, 0x80000000, 0x80000000 }
  *  for small, but not quite zero, sized glyphs.
  *  Only set as non-empty if the returned bounds are non-empty.
@@ skipping 221 matching lines @@
     DWRITE_GLYPH_RUN run;
     run.glyphCount = 1;
     run.glyphAdvances = &advance;
     run.fontFace = fTypeface->fDWriteFontFace.get();
     run.fontEmSize = SkScalarToFloat(fTextSizeRender);
     run.bidiLevel = 0;
     run.glyphIndices = &index;
     run.isSideways = FALSE;
     run.glyphOffsets = &offset;
     {
-        Exclusive l(DWriteFactoryMutex);
+
         SkTScopedComPtr<IDWriteGlyphRunAnalysis> glyphRunAnalysis;
-        HRNM(fTypeface->fFactory->CreateGlyphRunAnalysis(&run,
-            1.0f, // pixelsPerDip,
-            &fXform,
-            renderingMode,
-            fMeasuringMode,
-            0.0f, // baselineOriginX,
-            0.0f, // baselineOriginY,
-            &glyphRunAnalysis),
-            "Could not create glyph run analysis.");
-
+        {
+            Exclusive l(DWriteFactoryMutex);
+            HRNM(fTypeface->fFactory->CreateGlyphRunAnalysis(&run,
+                1.0f, // pixelsPerDip,
+                &fXform,
+                renderingMode,
+                fMeasuringMode,
+                0.0f, // baselineOriginX,
+                0.0f, // baselineOriginY,
+                &glyphRunAnalysis),
+                "Could not create glyph run analysis.");
+        }
         //NOTE: this assumes that the glyph has already been measured
         //with an exact same glyph run analysis.
         RECT bbox;
         bbox.left = glyph.fLeft;
         bbox.top = glyph.fTop;
         bbox.right = glyph.fLeft + glyph.fWidth;
         bbox.bottom = glyph.fTop + glyph.fHeight;
-        HRNM(glyphRunAnalysis->CreateAlphaTexture(textureType,
-            &bbox,
-            fBits.begin(),
-            sizeNeeded),
-            "Could not draw mask.");
+        {
+            Shared l(DWriteFactoryMutex);
+            HRNM(glyphRunAnalysis->CreateAlphaTexture(textureType,
+                &bbox,
+                fBits.begin(),
+                sizeNeeded),
+                "Could not draw mask.");
+        }
     }
     return fBits.begin();
 }
 
 void SkScalerContext_DW::generateImage(const SkGlyph& glyph) {
     //Create the mask.
     DWRITE_RENDERING_MODE renderingMode = fRenderingMode;
     DWRITE_TEXTURE_TYPE textureType = fTextureType;
     if (glyph.fForceBW) {
         renderingMode = DWRITE_RENDERING_MODE_ALIASED;
@@ skipping 53 matching lines @@
             nullptr, //offsets
             1, //num glyphs
             FALSE, //sideways
             FALSE, //rtl
             geometryToPath.get()),
             "Could not create glyph outline.");
     }
 
     path->transform(fSkXform);
 }