make fontscalar gammatext lcdtext typeface verttext2 gm portable

tools/sk_tool_utils.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "sk_tool_utils.h"
 #include "sk_tool_utils_flags.h"
 
 #include "Resources.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkCommonFlags.h"
 #include "SkShader.h"
 #include "SkTestScalerContext.h"
 #include "SkTextBlob.h"
 
 DEFINE_bool(portableFonts, false, "Use portable fonts");
-DEFINE_bool(resourceFonts, false, "Use resource fonts");
 
 namespace sk_tool_utils {
 
+/* these are the default fonts chosen by Chrome for serif, sans-serif, and monospace */
+static const char* gStandardFontNames[][3] = {
+    { "Times", "Helvetica", "Courier" }, // Mac
+    { "Times New Roman", "Helvetica", "Courier" }, // iOS
+    { "Times New Roman", "Arial", "Courier New" }, // Win
+    { "Times New Roman", "Arial", "Monospace" }, // Ubuntu
+    { "Droid Serif", "Droid Sans", "Droid Sans Mono" }, // Android
+    { "Tinos", "Arimo", "Cousine" } // ChromeOS
+};
+
+const char* platform_font_name(const char* name) {
+    SkString platform = major_platform_os_name();
+    int index;
+    if (!strcmp(name, "serif")) {
+        index = 0;
+    } else if (!strcmp(name, "san-serif")) {
+        index = 1;
+    } else if (!strcmp(name, "monospace")) {
+        index = 2;
+    } else {
+        return name;
+    }
+    if (platform.equals("Mac")) {
+        return gStandardFontNames[0][index];
+    }
+    if (platform.equals("iOS")) {
+        return gStandardFontNames[1][index];
+    }
+    if (platform.equals("Win")) {
+        return gStandardFontNames[2][index];
+    }
+    if (platform.equals("Ubuntu")) {
+        return gStandardFontNames[3][index];
+    }
+    if (platform.equals("Android")) {
+        return gStandardFontNames[4][index];
+    }
+    if (platform.equals("ChromeOS")) {
+        return gStandardFontNames[5][index];
+    }
+    return name;
+}
+
 const char* platform_os_emoji() {
     const char* osName = platform_os_name();
     if (!strcmp(osName, "Android") || !strcmp(osName, "Ubuntu")) {
         return "CBDT";
     }
     if (!strncmp(osName, "Mac", 3)) {
         return "SBIX";
     }
     return "";
 }
@@ skipping 28 matching lines @@
 const char* platform_os_name() {
     for (int index = 0; index < FLAGS_key.count(); index += 2) {
         if (!strcmp("os", FLAGS_key[index])) {
             return FLAGS_key[index + 1];
         }
     }
     // when running SampleApp or dm without a --key pair, omit the platform name
     return "";
 }
 
+// omit version number in returned value
+SkString major_platform_os_name() {
+    SkString name;
+    for (int index = 0; index < FLAGS_key.count(); index += 2) {
+        if (!strcmp("os", FLAGS_key[index])) {
+            const char* platform = FLAGS_key[index + 1];
+            const char* end = platform;
+            while (*end && (*end < '0' || *end > '9')) {
+                ++end;
+            }
+            name.append(platform, end - platform);
+            break;
+        }
+    }
+    return name;
+}
+
 const char* platform_extra_config(const char* config) {
     for (int index = 0; index < FLAGS_key.count(); index += 2) {
         if (!strcmp("extra_config", FLAGS_key[index]) && !strcmp(config, FLAGS_key[index + 1])) {
             return config;
         }
     }
     return "";
 }
 
 const char* colortype_name(SkColorType ct) {
@@ skipping 14 matching lines @@
 SkColor color_to_565(SkColor color) {
     SkPMColor pmColor = SkPreMultiplyColor(color);
     U16CPU color16 = SkPixel32ToPixel16(pmColor);
     return SkPixel16ToColor(color16);
 }
 
 SkTypeface* create_portable_typeface(const char* name, SkTypeface::Style style) {
     SkTypeface* face;
     if (FLAGS_portableFonts) {
         face = create_font(name, style);
-    } else if (FLAGS_resourceFonts) {
-        face = resource_font(name, style);
     } else {
         face = SkTypeface::CreateFromName(name, style);
     }
     return face;
 }
 
 SkTypeface* create_portable_typeface_always(const char* name, SkTypeface::Style style) {
     return create_font(name, style);
 }
 
@@ skipping 44 matching lines @@
     paint.textToGlyphs(text, len, glyphs.begin());
 
     paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
     const SkTextBlobBuilder::RunBuffer& run = builder->allocRun(paint, glyphs.count(), x, y,
                                                                 NULL);
     memcpy(run.glyphs, glyphs.begin(), glyphs.count() * sizeof(uint16_t));
 }
 
 
 }  // namespace sk_tool_utils