Add oblique as a slant.

src/core/SkFontMgr.cpp

Index: src/core/SkFontMgr.cpp
diff --git a/src/core/SkFontMgr.cpp b/src/core/SkFontMgr.cpp
index eba2b28fd6375bd65fc79debf59511830c7703ad..e2d3815700a85ac6028d994dde155852391677c4 100644
--- a/src/core/SkFontMgr.cpp
+++ b/src/core/SkFontMgr.cpp
@@ -211,6 +211,9 @@ SkTypeface* SkFontStyleSet::matchStyleCSS3(const SkFontStyle& pattern) {
     struct Score {
         int score;
         int index;
+        Score& operator +=(int rhs) { this->score += rhs; return *this; }
+        Score& operator <<=(int rhs) { this->score <<= rhs; return *this; }
+        bool operator <(const Score& that) { return this->score < that.score; }
     };
 
     Score maxScore = { 0, 0 };
@@ -223,54 +226,78 @@ SkTypeface* SkFontStyleSet::matchStyleCSS3(const SkFontStyle& pattern) {
         // This has the highest priority.
         if (pattern.width() <= SkFontStyle::kNormal_Width) {
             if (current.width() <= pattern.width()) {
-                currentScore.score += 10 - pattern.width() + current.width();
+                currentScore += 10 - pattern.width() + current.width();
             } else {
-                currentScore.score += 10 - current.width();
+                currentScore += 10 - current.width();
             }
         } else {
             if (current.width() > pattern.width()) {
-                currentScore.score += 10 + pattern.width() - current.width();
+                currentScore += 10 + pattern.width() - current.width();
             } else {
-                currentScore.score += current.width();
+                currentScore += current.width();
             }
         }
-        currentScore.score *= 1002;
-
-        // CSS style (italic/oblique)
-        // Being italic trumps all valid weights which are not italic.
-        // Note that newer specs differentiate between italic and oblique.
-        if (pattern.isItalic() == current.isItalic()) {
-            currentScore.score += 1001;
+        currentScore <<= 8;
+
+        // CSS style (normal/italic/oblique)
+        // Style takes priority over all valid weights.

[reed1, 2016/04/26 20:36:09]

s/Style/Slant ?

[bungeman-skia, 2016/04/27 15:37:20]

Eck, yeah. So CSS uses the terms stretch, style, weight where we use width,
slant, and weight. I'll update the comments above each of the sections here to
make that clearer.

+        switch (pattern.slant()) {
+            case SkFontStyle::kUpright_Slant: {

[reed1, 2016/04/26 20:36:09]

Sure seems like a table or other calc might be clearer. (not sure how to do that
tho).

Why don't we give the same (low) score to italic and oblique, if we're trying to
match upright?

I get the preference for the "other" slant if we're requesting one, and always
giving upright the lowest score.

[bungeman-skia, 2016/04/27 15:37:20]

I originally wrote this as a small 3x3 score table, and have gone back to that.
I wrote the 'switch' code on the basis that it would be easy for the compromised
renderer process to spew garbage SkFontStyle data and read outside this static
score table in the browser process if we didn't do additional runtime checks.
However, I have now convinced myself that SkFontStyles are all being created
through the constructor (which pins the values to legal ones) and also that any
code which tries to create SkFontStyles by casting bits deserves the pain they
will eventually receive. Also, it turns out we're squeezing the slant into 8
bits, so an attacker could only read up to 2^16 bytes of static data anyway,
even if some code were insecure.

I've added a bunch of assert here to state the preconditions of this working so
that if anything changes in the future we'll know about it.
Because that's the way it's spec'ed in the CSS3 font matching algorithm. When
requesting CSS3 'normal' (what we call upright) and there is no 'normal' then
'oblique' is preferred to 'italic'. Obviously we don't expect this to happen
very often, but we might as well implement the specification.

+                switch (current.slant()) {
+                    case SkFontStyle::kUpright_Slant: currentScore += 3; break;
+                    case SkFontStyle::kItalic_Slant : currentScore += 1; break;
+                    case SkFontStyle::kOblique_Slant: currentScore += 2; break;
+                    default: SkASSERT(false); break;
+                };
+            } break;
+            case SkFontStyle::kItalic_Slant: {
+                switch (current.slant()) {
+                    case SkFontStyle::kUpright_Slant: currentScore += 1; break;
+                    case SkFontStyle::kItalic_Slant : currentScore += 3; break;
+                    case SkFontStyle::kOblique_Slant: currentScore += 2; break;
+                    default: SkASSERT(false); break;
+                };
+            } break;
+            case SkFontStyle::kOblique_Slant: {
+                switch (current.slant()) {
+                    case SkFontStyle::kUpright_Slant: currentScore += 1; break;
+                    case SkFontStyle::kItalic_Slant : currentScore += 2; break;
+                    case SkFontStyle::kOblique_Slant: currentScore += 3; break;
+                    default: SkASSERT(false); break;
+                };
+            } break;
+            default: SkASSERT(false); break;
         }
+        currentScore <<= 8;
 
         // Synthetics (weight/style) [no stretch synthetic?]
 
         // The 'closer' to the target weight, the higher the score.
         // 1000 is the 'heaviest' recognized weight
         if (pattern.weight() == current.weight()) {
-            currentScore.score += 1000;
+            currentScore += 1000;
         } else if (pattern.weight() <= 500) {
             if (400 <= pattern.weight() && pattern.weight() < 450) {
                 if (450 <= current.weight() && current.weight() <= 500) {
                     // Artificially boost the 500 weight.
                     // TODO: determine correct number to use.
-                    currentScore.score += 500;
+                    currentScore += 500;
                 }
             }
             if (current.weight() <= pattern.weight()) {
-                currentScore.score += 1000 - pattern.weight() + current.weight();
+                currentScore += 1000 - pattern.weight() + current.weight();
             } else {
-                currentScore.score += 1000 - current.weight();
+                currentScore += 1000 - current.weight();
             }
         } else if (pattern.weight() > 500) {
             if (current.weight() > pattern.weight()) {
-                currentScore.score += 1000 + pattern.weight() - current.weight();
+                currentScore += 1000 + pattern.weight() - current.weight();
             } else {
-                currentScore.score += current.weight();
+                currentScore += current.weight();
             }
         }
 
-        if (currentScore.score > maxScore.score) {
+        if (maxScore < currentScore) {
             maxScore = currentScore;
         }
     }