SkAdvancedTypefaceMetrics: abstract out linked list

tests/WArrayTest.cpp

 /*
  * Copyright 2011 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 the implementation so we can make an appropriate template instance.
 #include "SkAdvancedTypefaceMetrics.h"
 
-using namespace skia_advanced_typeface_metrics_utils;
-
 // Negative values and zeros in a range plus trailing zeros.
 //                        0  1   2  3  4  5  6  7  8  9 10 11 12 13 14
 static const int16_t data1[] = {-1, 0, -3, 4, 5, 6, 7, 0, 0, 0, 8, 0, 0, 0, 0};
 static const char* expected1 = "0[-1 0 -3 4 5 6 7 0 0 0 8]";
 
 // Run with leading and trailing zeros.
 // Test rules: d         0  1  2    3    4    5    6    7    8    9 10 11
 static const int16_t data2[] = {0, 0, 0, 100, 100, 100, 100, 100, 100, 100, 0, 0};
 static const char* expected2 = "3 9 100";
 
@@ skipping 66 matching lines @@
 static const uint32_t subset13[] = {0, 3, 4, 7};
 static const char* expectedSubset13 = "0[1] 1 6 2 7[3]";
 
 // Enough don't cares to breakup something.
 // Test rules: a          0  1  2  3  4  5
 static const int16_t data14[] = {1, 0, 0, 0, 0, 2};
 static const char* expected14 = "0[1] 5[2]";
 static const uint32_t subset14[] = {0, 5};
 static const char* expectedSubset14 = "0[1] 5[2]";
 
-static SkString stringify_advance_data(SkAdvancedTypefaceMetrics::AdvanceMetric<int16_t>* data) {
+static SkString stringify_advance_data(const SkSinglyLinkedList<
+        SkAdvancedTypefaceMetrics::AdvanceMetric<int16_t>>& list) {
     SkString result;
     bool leadingSpace = false;
-    while (data != nullptr) {
-      if (leadingSpace) {
-        result.append(" ");
-      } else {
-        leadingSpace = true;
-      }
-      switch(data->fType) {
-        case SkAdvancedTypefaceMetrics::AdvanceMetric<int16_t>::kRun:
-          result.appendf("%d %d %d", data->fStartId, data->fEndId, data->fAdvance[0]);
-          break;
-        case SkAdvancedTypefaceMetrics::AdvanceMetric<int16_t>::kRange:
-          result.appendf("%d[", data->fStartId);
-          for (int i = 0; i < data->fAdvance.count(); ++i) {
-            if (i > 0) {
-              result.append(" ");
-            }
-            result.appendf("%d", data->fAdvance[i]);
-          }
-          result.append("]");
-          break;
-        case SkAdvancedTypefaceMetrics::AdvanceMetric<int16_t>::kDefault:
-          result.appendf("<Default=%d>", data->fAdvance[0]);
-          break;
-      }
-      data = data->fNext.get();
+    for (const SkAdvancedTypefaceMetrics::AdvanceMetric<int16_t>& data : list) {
+        if (leadingSpace) {
+            result.append(" ");
+        } else {
+            leadingSpace = true;
+        }
+        switch (data.fType) {
+            case SkAdvancedTypefaceMetrics::AdvanceMetric<int16_t>::kRun:
+                result.appendf("%d %d %d", data.fStartId, data.fEndId,
+                               data.fAdvance[0]);
+                break;
+            case SkAdvancedTypefaceMetrics::AdvanceMetric<int16_t>::kRange:
+                result.appendf("%d[", data.fStartId);
+                for (int i = 0; i < data.fAdvance.count(); ++i) {
+                    if (i > 0) {
+                        result.append(" ");
+                    }
+                    result.appendf("%d", data.fAdvance[i]);
+                }
+                result.append("]");
+                break;
+            case SkAdvancedTypefaceMetrics::AdvanceMetric<int16_t>::kDefault:
+                result.appendf("<Default=%d>", data.fAdvance[0]);
+                break;
+        }
     }
     return result;
 }
 
 class TestWData {
   public:
     TestWData(skiatest::Reporter* reporter,
               const int16_t advances[], int advanceLen,
               const uint32_t subset[], int subsetLen,
               const char* expected)
@@ skipping 15 matching lines @@
     static bool getAdvance(void* tc, int gId, int16_t* advance) {
         TestWData* testCase = (TestWData*)tc;
         if (gId >= 0 && gId < testCase->fAdvancesLen) {
             *advance = testCase->fAdvances[gId];
             return true;
         }
         return false;
     }
 
     void runTest(skiatest::Reporter* reporter) {
-        SkAutoTDelete<SkAdvancedTypefaceMetrics::AdvanceMetric<int16_t> > result;
-        result.reset(getAdvanceData((void*)this, fAdvancesLen, fSubset, fSubsetLen, getAdvance));
+        SkAdvancedTypefaceMetrics metrics;
+        metrics.setGlyphWidths((void*)this, fAdvancesLen, fSubset, fSubsetLen,
+                               getAdvance);
 
-        SkString stringResult = stringify_advance_data(result);
+        SkString stringResult = stringify_advance_data(metrics.fGlyphWidths);
         if (!stringResult.equals(fExpected)) {
             ERRORF(reporter, "Expected: %s\n  Result: %s\n", fExpected, stringResult.c_str());
         }
     }
 };
 
 DEF_TEST(WArray, reporter) {
     TestWData(reporter, data1, SK_ARRAY_COUNT(data1), nullptr, 0, expected1);
     TestWData(reporter, data2, SK_ARRAY_COUNT(data2), nullptr, 0, expected2);
     TestWData(reporter, data3, SK_ARRAY_COUNT(data3), nullptr, 0, expected3);
@@ skipping 18 matching lines @@
     TestWData(reporter, data12, SK_ARRAY_COUNT(data12), nullptr, 0, expected12);
     TestWData(reporter, data12, SK_ARRAY_COUNT(data12), subset12,
               SK_ARRAY_COUNT(subset12), expectedSubset12);
     TestWData(reporter, data13, SK_ARRAY_COUNT(data13), nullptr, 0, expected13);
     TestWData(reporter, data13, SK_ARRAY_COUNT(data13), subset13,
               SK_ARRAY_COUNT(subset13), expectedSubset13);
     TestWData(reporter, data14, SK_ARRAY_COUNT(data14), nullptr, 0, expected14);
     TestWData(reporter, data14, SK_ARRAY_COUNT(data14), subset14,
               SK_ARRAY_COUNT(subset14), expectedSubset14);
 }