Implement charToGlyph on remaining ports.

tests/FontHostTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Test.h"
 #include "SkPaint.h"
 #include "SkFontStream.h"
+#include "SkOSFile.h"
 #include "SkStream.h"
 #include "SkTypeface.h"
 #include "SkEndian.h"
 
 //#define DUMP_TABLES
 //#define DUMP_TTC_TABLES
 
 #define kFontTableTag_head          SkSetFourByteTag('h', 'e', 'a', 'd')
 #define kFontTableTag_hhea          SkSetFourByteTag('h', 'h', 'e', 'a')
 #define kFontTableTag_maxp          SkSetFourByteTag('m', 'a', 'x', 'p')
@@ skipping 44 matching lines @@
     }
 
     if (tableGlyphs >= 0) {
         REPORTER_ASSERT(reporter, tableGlyphs == nativeGlyphs);
     } else {
         // not sure this is a bug, but lets report it for now as info.
         SkDebugf("--- typeface returned 0 glyphs [%X]\n", face->uniqueID());
     }
 }
 
+// Test that SkPaint::textToGlyphs agrees with SkTypeface::charsToGlyphs.
+static void test_charsToGlyphs(skiatest::Reporter* reporter, SkTypeface* face) {
+    const char text[5] = "ABCD";
+    const size_t textLength = SK_ARRAY_COUNT(text)-1;
+
+    uint16_t paintGlyphIds[textLength];
+    SkPaint paint;
+    paint.setTypeface(face);
+    paint.setTextEncoding(SkPaint::kUTF8_TextEncoding);
+    paint.textToGlyphs(text, textLength, paintGlyphIds);
+
+    uint16_t faceGlyphIds[textLength];
+    face->charsToGlyphs(text, SkTypeface::kUTF8_Encoding, faceGlyphIds, textLength);
+
+    for (size_t i = 0; i < textLength; ++i) {
+        SkString name;
+        face->getFamilyName(&name);
+        SkString a;
+        a.appendf("paintGlyphIds[%d] = %d, faceGlyphIds[%d] = %d, name = %s", 
+                  (int)i, (int)paintGlyphIds[i],     (int)i, (int)faceGlyphIds[i],    name.c_str());
+        REPORTER_ASSERT_MESSAGE(reporter, paintGlyphIds[i] == faceGlyphIds[i], a.c_str());
+    }
+}
+
 static void test_fontstream(skiatest::Reporter* reporter,
                             SkStream* stream, int ttcIndex) {
     int n = SkFontStream::GetTableTags(stream, ttcIndex, NULL);
     SkAutoTArray<SkFontTableTag> array(n);
 
     int n2 = SkFontStream::GetTableTags(stream, ttcIndex, array.get());
     REPORTER_ASSERT(reporter, n == n2);
 
     for (int i = 0; i < n; ++i) {
 #ifdef DUMP_TTC_TABLES
@@ skipping 18 matching lines @@
     int count = SkFontStream::CountTTCEntries(stream);
 #ifdef DUMP_TTC_TABLES
     SkDebugf("CountTTCEntries %d\n", count);
 #endif
     for (int i = 0; i < count; ++i) {
         test_fontstream(reporter, stream, i);
     }
 }
 
 static void test_fontstream(skiatest::Reporter* reporter) {
-    // TODO: replace when we get a tools/resources/fonts/test.ttc
-    const char* name = "/AmericanTypewriter.ttc";
-    SkFILEStream stream(name);
+    // This test cannot run if there is no resource path.
+    SkString resourcePath = skiatest::Test::GetResourcePath();
+    if (resourcePath.isEmpty()) {
+        SkDebugf("Could not run fontstream test because resourcePath not specified.");
+        return;
+    }
+    SkString filename = SkOSPath::SkPathJoin(resourcePath.c_str(), "test.ttc");
+
+    SkFILEStream stream(filename.c_str());
     if (stream.isValid()) {
         test_fontstream(reporter, &stream);
+    } else {
+        SkDebugf("Could not run fontstream test because test.ttc not found.");
     }
 }
 
 static void test_tables(skiatest::Reporter* reporter, SkTypeface* face) {
     if (false) { // avoid bit rot, suppress warning
         SkFontID fontID = face->uniqueID();
         REPORTER_ASSERT(reporter, fontID);
     }
 
     int count = face->countTables();
@@ skipping 34 matching lines @@
 }
 
 static void test_tables(skiatest::Reporter* reporter) {
     static const char* const gNames[] = {
         NULL,   // default font
         "Arial", "Times", "Times New Roman", "Helvetica", "Courier",
         "Courier New", "Terminal", "MS Sans Serif",
     };
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(gNames); ++i) {
-        SkTypeface* face = SkTypeface::CreateFromName(gNames[i],
-                                                      SkTypeface::kNormal);
+        SkAutoTUnref<SkTypeface> face(SkTypeface::CreateFromName(gNames[i], SkTypeface::kNormal));
         if (face) {
 #ifdef DUMP_TABLES
             SkDebugf("%s\n", gNames[i]);
 #endif
             test_tables(reporter, face);
             test_unitsPerEm(reporter, face);
             test_countGlyphs(reporter, face);
-            face->unref();
+            test_charsToGlyphs(reporter, face);
         }
     }
 }
 
 /*
  * Verifies that the advance values returned by generateAdvance and
  * generateMetrics match.
  */
 static void test_advances(skiatest::Reporter* reporter) {
     static const char* const faces[] = {
@@ skipping 65 matching lines @@
 static void TestFontHost(skiatest::Reporter* reporter) {
     test_tables(reporter);
     test_fontstream(reporter);
     test_advances(reporter);
 }
 
 // need tests for SkStrSearch
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS("FontHost", FontHostTestClass, TestFontHost)