Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit dfa33071 authored by Ben Wagner's avatar Ben Wagner Committed by Android (Google) Code Review
Browse files

Merge "Use own enum instead of SkTypeface::Style."

parents 4f99ad1e 2763fb72

core/jni/android/graphics/Typeface.cpp

+4 −4
Original line number Diff line number Diff line
@@ -30,14 +30,14 @@ using namespace android; 


static jlong Typeface_createFromTypeface(JNIEnv* env, jobject, jlong familyHandle, jint style) {

    Typeface* family = reinterpret_cast<Typeface*>(familyHandle);

    Typeface* face = Typeface::createRelative(family, (SkTypeface::Style)style);

    Typeface* face = Typeface::createRelative(family, (Typeface::Style)style);

    // TODO: the following logic shouldn't be necessary, the above should always succeed.

    // Try to find the closest matching font, using the standard heuristic

    if (NULL == face) {

        face = Typeface::createRelative(family, (SkTypeface::Style)(style ^ SkTypeface::kItalic));

        face = Typeface::createRelative(family, (Typeface::Style)(style ^ Typeface::kItalic));

    }

    for (int i = 0; NULL == face && i < 4; i++) {

        face = Typeface::createRelative(family, (SkTypeface::Style)i);

        face = Typeface::createRelative(family, (Typeface::Style)i);

    }

    return reinterpret_cast<jlong>(face);

}
@@ -78,7 +78,7 @@ static void Typeface_unref(JNIEnv* env, jobject obj, jlong faceHandle) { 


static jint Typeface_getStyle(JNIEnv* env, jobject obj, jlong faceHandle) {

    Typeface* face = reinterpret_cast<Typeface*>(faceHandle);

    return face->fSkiaStyle;

    return face->fAPIStyle;

}



static jint Typeface_getWeight(JNIEnv* env, jobject obj, jlong faceHandle) {

libs/hwui/hwui/Typeface.cpp

+14 −14
Original line number Diff line number Diff line
@@ -34,12 +34,12 @@ 


namespace android {



static SkTypeface::Style computeSkiaStyle(int weight, bool italic) {

static Typeface::Style computeAPIStyle(int weight, bool italic) {

    // This bold detection comes from SkTypeface.h

    if (weight >= SkFontStyle::kSemiBold_Weight) {

        return italic ? SkTypeface::kBoldItalic : SkTypeface::kBold;

        return italic ? Typeface::kBoldItalic : Typeface::kBold;

    } else {

        return italic ? SkTypeface::kItalic : SkTypeface::kNormal;

        return italic ? Typeface::kItalic : Typeface::kNormal;

    }

}
@@ -50,12 +50,12 @@ static minikin::FontStyle computeMinikinStyle(int weight, bool italic) { 
}



// Resolve the relative weight from the baseWeight and target style.

static minikin::FontStyle computeRelativeStyle(int baseWeight, SkTypeface::Style relativeStyle) {

static minikin::FontStyle computeRelativeStyle(int baseWeight, Typeface::Style relativeStyle) {

    int weight = baseWeight;

    if ((relativeStyle & SkTypeface::kBold) != 0) {

    if ((relativeStyle & Typeface::kBold) != 0) {

        weight += 300;

    }

    bool italic = (relativeStyle & SkTypeface::kItalic) != 0;

    bool italic = (relativeStyle & Typeface::kItalic) != 0;

    return computeMinikinStyle(weight, italic);

}
@@ -66,13 +66,13 @@ const Typeface* Typeface::resolveDefault(const Typeface* src) { 
    return src == nullptr ? gDefaultTypeface : src;

}



Typeface* Typeface::createRelative(Typeface* src, SkTypeface::Style style) {

Typeface* Typeface::createRelative(Typeface* src, Typeface::Style style) {

    const Typeface* resolvedFace = Typeface::resolveDefault(src);

    Typeface* result = new Typeface;

    if (result != nullptr) {

        result->fFontCollection = resolvedFace->fFontCollection;

        result->fBaseWeight = resolvedFace->fBaseWeight;

        result->fSkiaStyle = style;

        result->fAPIStyle = style;

        result->fStyle = computeRelativeStyle(result->fBaseWeight, style);

    }

    return result;
@@ -84,7 +84,7 @@ Typeface* Typeface::createAbsolute(Typeface* base, int weight, bool italic) { 
    if (result != nullptr) {

        result->fFontCollection = resolvedFace->fFontCollection;

        result->fBaseWeight = resolvedFace->fBaseWeight;

        result->fSkiaStyle = computeSkiaStyle(weight, italic);

        result->fAPIStyle = computeAPIStyle(weight, italic);

        result->fStyle = computeMinikinStyle(weight, italic);

    }

    return result;
@@ -105,7 +105,7 @@ Typeface* Typeface::createFromTypefaceWithVariation(Typeface* src, 
        // Do not update styles.

        // TODO: We may want to update base weight if the 'wght' is specified.

        result->fBaseWeight = resolvedFace->fBaseWeight;

        result->fSkiaStyle = resolvedFace->fSkiaStyle;

        result->fAPIStyle = resolvedFace->fAPIStyle;

        result->fStyle = resolvedFace->fStyle;

    }

    return result;
@@ -117,8 +117,8 @@ Typeface* Typeface::createWithDifferentBaseWeight(Typeface* src, int weight) { 
    if (result != nullptr) {

        result->fFontCollection = resolvedFace->fFontCollection;

        result->fBaseWeight = weight;

        result->fSkiaStyle = resolvedFace->fSkiaStyle;

        result->fStyle = computeRelativeStyle(weight, result->fSkiaStyle);

        result->fAPIStyle = resolvedFace->fAPIStyle;

        result->fStyle = computeRelativeStyle(weight, result->fAPIStyle);

    }

    return result;

}
@@ -161,7 +161,7 @@ Typeface* Typeface::createFromFamilies( 
    }



    result->fBaseWeight = weight;

    result->fSkiaStyle = computeSkiaStyle(weight, italic);

    result->fAPIStyle = computeAPIStyle(weight, italic);

    result->fStyle = computeMinikinStyle(weight, italic);

    return result;

}
@@ -191,7 +191,7 @@ void Typeface::setRobotoTypefaceForTest() { 


    Typeface* hwTypeface = new Typeface();

    hwTypeface->fFontCollection = collection;

    hwTypeface->fSkiaStyle = SkTypeface::kNormal;

    hwTypeface->fAPIStyle = Typeface::kNormal;

    hwTypeface->fBaseWeight = SkFontStyle::kNormal_Weight;

    hwTypeface->fStyle = minikin::FontStyle(4 /* weight */, false /* italic */);

libs/hwui/hwui/Typeface.h

+9 −3
Original line number Diff line number Diff line
@@ -38,8 +38,14 @@ struct ANDROID_API Typeface { 
    // resolved style actually used for rendering

    minikin::FontStyle fStyle;



    // style used for constructing and querying Typeface objects

    SkTypeface::Style fSkiaStyle;

    // style used in the API

    enum Style : uint8_t {

        kNormal = 0,

        kBold   = 0x01,

        kItalic = 0x02,

        kBoldItalic = 0x03

    };

    Style fAPIStyle;



    static const Typeface* resolveDefault(const Typeface* src);
@@ -68,7 +74,7 @@ struct ANDROID_API Typeface { 
    //

    //   Typeface* black = createAbsolute(base, 900, false);  // Rendered with a weight of 900.

    static Typeface* createWithDifferentBaseWeight(Typeface* src, int baseweight);

    static Typeface* createRelative(Typeface* src, SkTypeface::Style desiredStyle);

    static Typeface* createRelative(Typeface* src, Style desiredStyle);

    static Typeface* createAbsolute(Typeface* base, int weight, bool italic);



    static Typeface* createFromTypefaceWithVariation(Typeface* src,

libs/hwui/tests/unit/TypefaceTests.cpp

+66 −66
Original line number Diff line number Diff line
@@ -84,159 +84,159 @@ TEST(TypefaceTest, createWithDifferentBaseWeight) { 
    std::unique_ptr<Typeface> bold(Typeface::createWithDifferentBaseWeight(nullptr, 700));

    EXPECT_EQ(7, bold->fStyle.getWeight());

    EXPECT_FALSE(bold->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kNormal, bold->fSkiaStyle);

    EXPECT_EQ(Typeface::kNormal, bold->fAPIStyle);



    std::unique_ptr<Typeface> light(Typeface::createWithDifferentBaseWeight(nullptr, 300));

    EXPECT_EQ(3, light->fStyle.getWeight());

    EXPECT_FALSE(light->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kNormal, light->fSkiaStyle);

    EXPECT_EQ(Typeface::kNormal, light->fAPIStyle);

}



TEST(TypefaceTest, createRelativeTest_fromRegular) {

    // In Java, Typeface.create(Typeface.DEFAULT, Typeface.NORMAL);

    std::unique_ptr<Typeface> normal(Typeface::createRelative(nullptr, SkTypeface::kNormal));

    std::unique_ptr<Typeface> normal(Typeface::createRelative(nullptr, Typeface::kNormal));

    EXPECT_EQ(4, normal->fStyle.getWeight());

    EXPECT_FALSE(normal->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kNormal, normal->fSkiaStyle);

    EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle);



    // In Java, Typeface.create(Typeface.DEFAULT, Typeface.BOLD);

    std::unique_ptr<Typeface> bold(Typeface::createRelative(nullptr, SkTypeface::kBold));

    std::unique_ptr<Typeface> bold(Typeface::createRelative(nullptr, Typeface::kBold));

    EXPECT_EQ(7, bold->fStyle.getWeight());

    EXPECT_FALSE(bold->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);

    EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);



    // In Java, Typeface.create(Typeface.DEFAULT, Typeface.ITALIC);

    std::unique_ptr<Typeface> italic(Typeface::createRelative(nullptr, SkTypeface::kItalic));

    std::unique_ptr<Typeface> italic(Typeface::createRelative(nullptr, Typeface::kItalic));

    EXPECT_EQ(4, italic->fStyle.getWeight());

    EXPECT_TRUE(italic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);

    EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);



    // In Java, Typeface.create(Typeface.DEFAULT, Typeface.BOLD_ITALIC);

    std::unique_ptr<Typeface> boldItalic(

            Typeface::createRelative(nullptr, SkTypeface::kBoldItalic));

            Typeface::createRelative(nullptr, Typeface::kBoldItalic));

    EXPECT_EQ(7, boldItalic->fStyle.getWeight());

    EXPECT_TRUE(boldItalic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBoldItalic, boldItalic->fSkiaStyle);

    EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle);

}



TEST(TypefaceTest, createRelativeTest_BoldBase) {

    std::unique_ptr<Typeface> base(Typeface::createWithDifferentBaseWeight(nullptr, 700));



    // In Java, Typeface.create(Typeface.create("sans-serif-bold"), Typeface.NORMAL);

    std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), SkTypeface::kNormal));

    std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), Typeface::kNormal));

    EXPECT_EQ(7, normal->fStyle.getWeight());

    EXPECT_FALSE(normal->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kNormal, normal->fSkiaStyle);

    EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle);



    // In Java, Typeface.create(Typeface.create("sans-serif-bold"), Typeface.BOLD);

    std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), SkTypeface::kBold));

    std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), Typeface::kBold));

    EXPECT_EQ(10, bold->fStyle.getWeight());

    EXPECT_FALSE(bold->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);

    EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);



    // In Java, Typeface.create(Typeface.create("sans-serif-bold"), Typeface.ITALIC);

    std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), SkTypeface::kItalic));

    std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), Typeface::kItalic));

    EXPECT_EQ(7, italic->fStyle.getWeight());

    EXPECT_TRUE(italic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);

    EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);



    // In Java, Typeface.create(Typeface.create("sans-serif-bold"), Typeface.BOLD_ITALIC);

    std::unique_ptr<Typeface>

            boldItalic(Typeface::createRelative(base.get(), SkTypeface::kBoldItalic));

            boldItalic(Typeface::createRelative(base.get(), Typeface::kBoldItalic));

    EXPECT_EQ(10, boldItalic->fStyle.getWeight());

    EXPECT_TRUE(boldItalic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBoldItalic, boldItalic->fSkiaStyle);

    EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle);

}



TEST(TypefaceTest, createRelativeTest_LightBase) {

    std::unique_ptr<Typeface> base(Typeface::createWithDifferentBaseWeight(nullptr, 300));



    // In Java, Typeface.create(Typeface.create("sans-serif-light"), Typeface.NORMAL);

    std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), SkTypeface::kNormal));

    std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), Typeface::kNormal));

    EXPECT_EQ(3, normal->fStyle.getWeight());

    EXPECT_FALSE(normal->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kNormal, normal->fSkiaStyle);

    EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle);



    // In Java, Typeface.create(Typeface.create("sans-serif-light"), Typeface.BOLD);

    std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), SkTypeface::kBold));

    std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), Typeface::kBold));

    EXPECT_EQ(6, bold->fStyle.getWeight());

    EXPECT_FALSE(bold->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);

    EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);



    // In Java, Typeface.create(Typeface.create("sans-serif-light"), Typeface.ITLIC);

    std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), SkTypeface::kItalic));

    std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), Typeface::kItalic));

    EXPECT_EQ(3, italic->fStyle.getWeight());

    EXPECT_TRUE(italic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);

    EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);



    // In Java, Typeface.create(Typeface.create("sans-serif-light"), Typeface.BOLD_ITALIC);

    std::unique_ptr<Typeface>

            boldItalic(Typeface::createRelative(base.get(), SkTypeface::kBoldItalic));

            boldItalic(Typeface::createRelative(base.get(), Typeface::kBoldItalic));

    EXPECT_EQ(6, boldItalic->fStyle.getWeight());

    EXPECT_TRUE(boldItalic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBoldItalic, boldItalic->fSkiaStyle);

    EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle);

}



TEST(TypefaceTest, createRelativeTest_fromBoldStyled) {

    std::unique_ptr<Typeface> base(Typeface::createRelative(nullptr, SkTypeface::kBold));

    std::unique_ptr<Typeface> base(Typeface::createRelative(nullptr, Typeface::kBold));



    // In Java, Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD), Typeface.NORMAL);

    std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), SkTypeface::kNormal));

    std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), Typeface::kNormal));

    EXPECT_EQ(4, normal->fStyle.getWeight());

    EXPECT_FALSE(normal->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kNormal, normal->fSkiaStyle);

    EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle);



    // In Java Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD), Typeface.BOLD);

    std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), SkTypeface::kBold));

    std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), Typeface::kBold));

    EXPECT_EQ(7, bold->fStyle.getWeight());

    EXPECT_FALSE(bold->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);

    EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);



    // In Java, Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD), Typeface.ITALIC);

    std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), SkTypeface::kItalic));

    std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), Typeface::kItalic));

    EXPECT_EQ(4, normal->fStyle.getWeight());

    EXPECT_TRUE(italic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);

    EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);



    // In Java,

    // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.BOLD), Typeface.BOLD_ITALIC);

    std::unique_ptr<Typeface>

            boldItalic(Typeface::createRelative(base.get(), SkTypeface::kBoldItalic));

            boldItalic(Typeface::createRelative(base.get(), Typeface::kBoldItalic));

    EXPECT_EQ(7, boldItalic->fStyle.getWeight());

    EXPECT_TRUE(boldItalic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBoldItalic, boldItalic->fSkiaStyle);

    EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle);

}



TEST(TypefaceTest, createRelativeTest_fromItalicStyled) {

    std::unique_ptr<Typeface> base(Typeface::createRelative(nullptr, SkTypeface::kItalic));

    std::unique_ptr<Typeface> base(Typeface::createRelative(nullptr, Typeface::kItalic));



    // In Java,

    // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC), Typeface.NORMAL);

    std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), SkTypeface::kNormal));

    std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), Typeface::kNormal));

    EXPECT_EQ(4, normal->fStyle.getWeight());

    EXPECT_FALSE(normal->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kNormal, normal->fSkiaStyle);

    EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle);



    // In Java, Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC), Typeface.BOLD);

    std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), SkTypeface::kBold));

    std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), Typeface::kBold));

    EXPECT_EQ(7, bold->fStyle.getWeight());

    EXPECT_FALSE(bold->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);

    EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);



    // In Java,

    // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC), Typeface.ITALIC);

    std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), SkTypeface::kItalic));

    std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), Typeface::kItalic));

    EXPECT_EQ(4, italic->fStyle.getWeight());

    EXPECT_TRUE(italic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);

    EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);



    // In Java,

    // Typeface.create(Typeface.create(Typeface.DEFAULT, Typeface.ITALIC), Typeface.BOLD_ITALIC);

    std::unique_ptr<Typeface>

            boldItalic(Typeface::createRelative(base.get(), SkTypeface::kBoldItalic));

            boldItalic(Typeface::createRelative(base.get(), Typeface::kBoldItalic));

    EXPECT_EQ(7, boldItalic->fStyle.getWeight());

    EXPECT_TRUE(boldItalic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBoldItalic, boldItalic->fSkiaStyle);

    EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle);

}



TEST(TypefaceTest, createRelativeTest_fromSpecifiedStyled) {
@@ -246,38 +246,38 @@ TEST(TypefaceTest, createRelativeTest_fromSpecifiedStyled) { 
    // Typeface typeface = new Typeface.Builder(invalid).setFallback("sans-serif")

    //     .setWeight(700).setItalic(false).build();

    // Typeface.create(typeface, Typeface.NORMAL);

    std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), SkTypeface::kNormal));

    std::unique_ptr<Typeface> normal(Typeface::createRelative(base.get(), Typeface::kNormal));

    EXPECT_EQ(4, normal->fStyle.getWeight());

    EXPECT_FALSE(normal->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kNormal, normal->fSkiaStyle);

    EXPECT_EQ(Typeface::kNormal, normal->fAPIStyle);



    // In Java,

    // Typeface typeface = new Typeface.Builder(invalid).setFallback("sans-serif")

    //     .setWeight(700).setItalic(false).build();

    // Typeface.create(typeface, Typeface.BOLD);

    std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), SkTypeface::kBold));

    std::unique_ptr<Typeface> bold(Typeface::createRelative(base.get(), Typeface::kBold));

    EXPECT_EQ(7, bold->fStyle.getWeight());

    EXPECT_FALSE(bold->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);

    EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);



    // In Java,

    // Typeface typeface = new Typeface.Builder(invalid).setFallback("sans-serif")

    //     .setWeight(700).setItalic(false).build();

    // Typeface.create(typeface, Typeface.ITALIC);

    std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), SkTypeface::kItalic));

    std::unique_ptr<Typeface> italic(Typeface::createRelative(base.get(), Typeface::kItalic));

    EXPECT_EQ(4, italic->fStyle.getWeight());

    EXPECT_TRUE(italic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);

    EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);



    // In Java,

    // Typeface typeface = new Typeface.Builder(invalid).setFallback("sans-serif")

    //     .setWeight(700).setItalic(false).build();

    // Typeface.create(typeface, Typeface.BOLD_ITALIC);

    std::unique_ptr<Typeface>

            boldItalic(Typeface::createRelative(base.get(), SkTypeface::kBoldItalic));

            boldItalic(Typeface::createRelative(base.get(), Typeface::kBoldItalic));

    EXPECT_EQ(7, boldItalic->fStyle.getWeight());

    EXPECT_TRUE(boldItalic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBoldItalic, boldItalic->fSkiaStyle);

    EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle);

}



TEST(TypefaceTest, createAbsolute) {
@@ -287,7 +287,7 @@ TEST(TypefaceTest, createAbsolute) { 
    std::unique_ptr<Typeface> regular(Typeface::createAbsolute(nullptr, 400, false));

    EXPECT_EQ(4, regular->fStyle.getWeight());

    EXPECT_FALSE(regular->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kNormal, regular->fSkiaStyle);

    EXPECT_EQ(Typeface::kNormal, regular->fAPIStyle);



    // In Java,

    // new Typeface.Builder(invalid).setFallback("sans-serif").setWeight(700).setItalic(false)
@@ -295,7 +295,7 @@ TEST(TypefaceTest, createAbsolute) { 
    std::unique_ptr<Typeface> bold(Typeface::createAbsolute(nullptr, 700, false));

    EXPECT_EQ(7, bold->fStyle.getWeight());

    EXPECT_FALSE(bold->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);

    EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);



    // In Java,

    // new Typeface.Builder(invalid).setFallback("sans-serif").setWeight(400).setItalic(true)
@@ -303,7 +303,7 @@ TEST(TypefaceTest, createAbsolute) { 
    std::unique_ptr<Typeface> italic(Typeface::createAbsolute(nullptr, 400, true));

    EXPECT_EQ(4, italic->fStyle.getWeight());

    EXPECT_TRUE(italic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);

    EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);



    // In Java,

    // new Typeface.Builder(invalid).setFallback("sans-serif").setWeight(700).setItalic(true)
@@ -311,7 +311,7 @@ TEST(TypefaceTest, createAbsolute) { 
    std::unique_ptr<Typeface> boldItalic(Typeface::createAbsolute(nullptr, 700, true));

    EXPECT_EQ(7, boldItalic->fStyle.getWeight());

    EXPECT_TRUE(boldItalic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBoldItalic, boldItalic->fSkiaStyle);

    EXPECT_EQ(Typeface::kBoldItalic, boldItalic->fAPIStyle);



    // In Java,

    // new Typeface.Builder(invalid).setFallback("sans-serif").setWeight(1100).setItalic(true)
@@ -319,7 +319,7 @@ TEST(TypefaceTest, createAbsolute) { 
    std::unique_ptr<Typeface> over1000(Typeface::createAbsolute(nullptr, 1100, false));

    EXPECT_EQ(10, over1000->fStyle.getWeight());

    EXPECT_FALSE(over1000->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBold, over1000->fSkiaStyle);

    EXPECT_EQ(Typeface::kBold, over1000->fAPIStyle);

}



TEST(TypefaceTest, createFromFamilies_Single) {
@@ -328,21 +328,21 @@ TEST(TypefaceTest, createFromFamilies_Single) { 
            Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoRegular), 400, false));

    EXPECT_EQ(4, regular->fStyle.getWeight());

    EXPECT_FALSE(regular->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kNormal, regular->fSkiaStyle);

    EXPECT_EQ(Typeface::kNormal, regular->fAPIStyle);



    // In Java, new Typeface.Builder("Roboto-Bold.ttf").setWeight(700).setItalic(false).build();

    std::unique_ptr<Typeface> bold(

            Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoBold), 700, false));

    EXPECT_EQ(7, bold->fStyle.getWeight());

    EXPECT_FALSE(bold->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);

    EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);



    // In Java, new Typeface.Builder("Roboto-Italic.ttf").setWeight(400).setItalic(true).build();

    std::unique_ptr<Typeface> italic(

            Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoItalic), 400, true));

    EXPECT_EQ(4, italic->fStyle.getWeight());

    EXPECT_TRUE(italic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);

    EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);



    // In Java,

    // new Typeface.Builder("Roboto-BoldItalic.ttf").setWeight(700).setItalic(true).build();
@@ -350,7 +350,7 @@ TEST(TypefaceTest, createFromFamilies_Single) { 
            Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoBoldItalic), 700, true));

    EXPECT_EQ(7, boldItalic->fStyle.getWeight());

    EXPECT_TRUE(boldItalic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);

    EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);



    // In Java,

    // new Typeface.Builder("Roboto-BoldItalic.ttf").setWeight(1100).setItalic(false).build();
@@ -358,7 +358,7 @@ TEST(TypefaceTest, createFromFamilies_Single) { 
            Typeface::createFromFamilies(makeSingleFamlyVector(kRobotoBold), 1100, false));

    EXPECT_EQ(10, over1000->fStyle.getWeight());

    EXPECT_FALSE(over1000->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBold, over1000->fSkiaStyle);

    EXPECT_EQ(Typeface::kBold, over1000->fAPIStyle);

}



TEST(TypefaceTest, createFromFamilies_Single_resolveByTable) {
@@ -368,7 +368,7 @@ TEST(TypefaceTest, createFromFamilies_Single_resolveByTable) { 
                    RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));

    EXPECT_EQ(4, regular->fStyle.getWeight());

    EXPECT_FALSE(regular->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kNormal, regular->fSkiaStyle);

    EXPECT_EQ(Typeface::kNormal, regular->fAPIStyle);



    // In Java, new Typeface.Builder("Roboto-Bold.ttf").build();

    std::unique_ptr<Typeface> bold(
@@ -376,7 +376,7 @@ TEST(TypefaceTest, createFromFamilies_Single_resolveByTable) { 
                    RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));

    EXPECT_EQ(7, bold->fStyle.getWeight());

    EXPECT_FALSE(bold->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kBold, bold->fSkiaStyle);

    EXPECT_EQ(Typeface::kBold, bold->fAPIStyle);



    // In Java, new Typeface.Builder("Roboto-Italic.ttf").build();

    std::unique_ptr<Typeface> italic(
@@ -384,7 +384,7 @@ TEST(TypefaceTest, createFromFamilies_Single_resolveByTable) { 
                    RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));

    EXPECT_EQ(4, italic->fStyle.getWeight());

    EXPECT_TRUE(italic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);

    EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);



    // In Java, new Typeface.Builder("Roboto-BoldItalic.ttf").build();

    std::unique_ptr<Typeface> boldItalic(
@@ -392,7 +392,7 @@ TEST(TypefaceTest, createFromFamilies_Single_resolveByTable) { 
                    RESOLVE_BY_FONT_TABLE, RESOLVE_BY_FONT_TABLE));

    EXPECT_EQ(7, boldItalic->fStyle.getWeight());

    EXPECT_TRUE(boldItalic->fStyle.getItalic());

    EXPECT_EQ(SkTypeface::kItalic, italic->fSkiaStyle);

    EXPECT_EQ(Typeface::kItalic, italic->fAPIStyle);

}



TEST(TypefaceTest, createFromFamilies_Family) {