Add test for typeface style round trip.

tests/TypefaceTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
+#include "SkData.h"
+#include "SkOTTable_OS_2.h"
+#include "SkSFNTHeader.h"
+#include "SkStream.h"
 #include "SkRefCnt.h"
 #include "SkTypeface.h"
 #include "SkTypefaceCache.h"
+#include "Resources.h"
 #include "Test.h"
 
+#include <memory>
+static void TypefaceStyle_test(skiatest::Reporter* reporter, uint16_t weight, uint16_t width,
+                               SkData* data)
+{
+    SkSFNTHeader* sfntHeader = static_cast<SkSFNTHeader*>(data->writable_data());

[bungeman-skia, 2016/07/25 13:23:08]

This is what is actually failing on Mac (on the second and subsequent times
through). The previous typeface was destroyed but the data provider retain count
never went to 0, so that old data provider is still holding on to the data. It
appears that creating a CTFont from a CGFont from a CGDataProvider and actually
using it does all sorts of interesting things to the reference count, leading to
the data leaking. It appears that all fonts from streams are leaking all their
data on Mac. The weird thing is that this test passed on iOS.

+    SkSFNTHeader::TableDirectoryEntry* tableEntry = SkTAfter<SkSFNTHeader::TableDirectoryEntry>(sfntHeader);
+    SkSFNTHeader::TableDirectoryEntry* os2TableEntry = nullptr;
+    int numTables = SkEndian_SwapBE16(sfntHeader->numTables);
+    for (int tableEntryIndex = 0; tableEntryIndex < numTables; ++tableEntryIndex) {
+        if (SkOTTableOS2::TAG == tableEntry[tableEntryIndex].tag) {
+            os2TableEntry = tableEntry + tableEntryIndex;
+            break;
+        }
+    }
+    SkASSERT(os2TableEntry);
+
+    size_t os2TableOffset = SkEndian_SwapBE32(os2TableEntry->offset);
+    SkOTTableOS2_V0* os2Table = SkTAddOffset<SkOTTableOS2_V0>(sfntHeader, os2TableOffset);
+    os2Table->usWeightClass.value = SkEndian_SwapBE16(weight);
+    os2Table->usWidthClass.value = static_cast<SkOTTableOS2_V0::WidthClass::Value>(SkEndian_SwapBE16(width));
+
+    sk_sp<SkTypeface> newTypeface(SkTypeface::MakeFromStream(new SkMemoryStream(data)));
+    SkASSERT(newTypeface);
+
+    SkFontStyle newStyle = newTypeface->fontStyle();
+    //printf("%d, %f\n", weight, (newStyle.weight() - (float)0x7FFF) / (float)0x7FFF);
+    //printf("%d, %f\n", width, (newStyle.width() - (float)0x7F) / (float)0x7F);
+    //printf("(%d, %d)\n", weight, newStyle.weight());
+    //printf("%d, %d\n", width, newStyle.width());
+
+    // Some back-ends (CG, GDI, DW) support OS/2 version A which uses 0 - 10 (but all differently).
+    REPORTER_ASSERT(reporter,
+                    newStyle.weight() == weight ||
+                    (weight <=   10 && newStyle.weight() == 100 * weight) ||
+                    (weight ==    4 && newStyle.weight() == 350) ||  // GDI weirdness
+                    (weight ==    5 && newStyle.weight() == 400) ||  // GDI weirdness
+                    (weight ==    0 && newStyle.weight() ==   1) ||  // DW weirdness
+                    (weight == 1000 && newStyle.weight() == 999)     // DW weirdness
+    );
+
+    // Some back-ends (GDI) don't support width, ensure these always report 'medium'.
+    REPORTER_ASSERT(reporter, newStyle.width() == width || newStyle.width() == 5);
+}
+DEF_TEST(TypefaceStyle, reporter) {
+    sk_sp<SkTypeface> typeface(MakeResourceAsTypeface("/fonts/Em.ttf"));
+    if (!typeface) {
+        REPORT_FAILURE(reporter, "/fonts/Em.ttf", SkString("Cannot load resource"));
+        return;
+    }
+    std::unique_ptr<SkStreamAsset> stream(typeface->openStream(nullptr));
+    SkASSERT(stream);
+    sk_sp<SkData> data(SkData::MakeFromStream(stream.get(), stream->getLength()));
+
+    for (int weight = 0; weight <= 1000; ++weight) {
+        TypefaceStyle_test(reporter, weight, 4, data.get());
+    }
+    for (int width = SkFontStyle::kUltraCondensed_Width; width <= SkFontStyle::kUltaExpanded_Width; ++width) {
+        TypefaceStyle_test(reporter, 400, width, data.get());
+    }
+}
+
 DEF_TEST(Typeface, reporter) {
 
     sk_sp<SkTypeface> t1(SkTypeface::MakeFromName(nullptr, SkFontStyle()));
     sk_sp<SkTypeface> t2(SkTypeface::MakeDefault(SkTypeface::kNormal));
 
     REPORTER_ASSERT(reporter, SkTypeface::Equal(t1.get(), t2.get()));
     REPORTER_ASSERT(reporter, SkTypeface::Equal(0, t1.get()));
     REPORTER_ASSERT(reporter, SkTypeface::Equal(0, t2.get()));
     REPORTER_ASSERT(reporter, SkTypeface::Equal(t1.get(), 0));
     REPORTER_ASSERT(reporter, SkTypeface::Equal(t2.get(), 0));
@@ skipping 65 matching lines @@
             REPORTER_ASSERT(reporter, count(reporter, cache) == 2);
             cache.purgeAll();
             REPORTER_ASSERT(reporter, count(reporter, cache) == 2);
         }
         REPORTER_ASSERT(reporter, count(reporter, cache) == 2);
         cache.purgeAll();
         REPORTER_ASSERT(reporter, count(reporter, cache) == 1);
     }
     REPORTER_ASSERT(reporter, t1->unique());
 }