add portable and canonical font support for DM

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 "../src/fonts/SkTestScalerContext.h"
+#include "sk_tool_utils_flags.h"
 
 #include "SkBitmap.h"
 #include "SkCanvas.h"
+#include "SkTestScalerContext.h"
+
+DEFINE_bool(portableFonts, false, "Use portable fonts");

[mtklein, 2014/07/30 15:03:57]

What's the end game?  Ordinarily bots use --portableFonts, and we use
--resourceFonts to bootstrap?

[caryclark, 2014/07/30 15:45:32]

Today, this makes it easier to bring up a new reference piece of hardware by
comparing GMs across platforms. I use --portableFonts to help isolate GPU / CPU
bugs without getting distracted by font scalar differences. Then I use
--resourceFonts to verify that we draw the same or at least similarly with
different scalar engines.

The end game has multiple prongs:
- move the same set of fonts to all bots so that they can all use
--resourceFonts and produce more similar output
- add additional diversity like 'label fonts' so appropriate GMs would draw from
paths on all platforms all the time
- provide a mechanism so that a GM can opt out and always use resource fonts
(e.g., vertical font tests)
- add SkFontMgr support so that portable/resource/system fonts can exist
simultaneously as the GM requires

The purpose of this CL is to implement a skeleton towards these features, but is
not complete. For instance, this CL causes --portableFonts --pipe to fail since
redirecting SkFontMgr isn't implemented yet.

+DEFINE_bool(resourceFonts, false, "Use resource fonts");
 
 namespace sk_tool_utils {
 
-bool gEnablePortableTypeface = false;
-
 const char* colortype_name(SkColorType ct) {
     switch (ct) {
         case kUnknown_SkColorType:      return "Unknown";
         case kAlpha_8_SkColorType:      return "Alpha_8";
         case kIndex_8_SkColorType:      return "Index_8";
         case kARGB_4444_SkColorType:    return "ARGB_4444";
         case kRGB_565_SkColorType:      return "RGB_565";
         case kRGBA_8888_SkColorType:    return "RGBA_8888";
         case kBGRA_8888_SkColorType:    return "BGRA_8888";
         default:
             SkASSERT(false);
             return "unexpected colortype";
     }
 }
 
-SkPaint::FontMetrics create_font(SkTDArray<SkPath*>& , SkTDArray<SkFixed>& );
+SkTypeface* 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;
+}
 
-void set_portable_typeface(SkPaint* paint, SkTypeface::Style style) {
-    if (gEnablePortableTypeface) {
-        SkSafeUnref(paint->setTypeface(CreateTestTypeface(create_font, style)));
-    }
+void set_portable_typeface(SkPaint* paint, const char* name, SkTypeface::Style style) {
+    SkTypeface* face = portable_typeface(name, style);
+    SkSafeUnref(paint->setTypeface(face));
 }
 
 void write_pixels(SkCanvas* canvas, const SkBitmap& bitmap, int x, int y,
                   SkColorType colorType, SkAlphaType alphaType) {
     SkBitmap tmp(bitmap);
     tmp.lockPixels();
 
     SkImageInfo info = tmp.info();
     info.fColorType = colorType;
     info.fAlphaType = alphaType;
 
     canvas->writePixels(info, tmp.getPixels(), tmp.rowBytes(), x, y);
 }
 
 }  // namespace sk_tool_utils