Add Pepper TrueType font API call to enumerate fonts in a given family.

ppapi/tests/test_truetype_font.cc

Index: ppapi/tests/test_truetype_font.cc
diff --git a/ppapi/tests/test_truetype_font.cc b/ppapi/tests/test_truetype_font.cc
index b09cb585c31d212fbc38c9e4ee95c57ef069eb66..80315ab40cba70a68529518f3612310aaca69bd0 100644
--- a/ppapi/tests/test_truetype_font.cc
+++ b/ppapi/tests/test_truetype_font.cc
@@ -6,6 +6,7 @@
 
 #include "ppapi/tests/test_truetype_font.h"
 
+#include <stdio.h>

[dmichael (off chromium), 2013/04/12 23:34:18]

nit: I'm guessing you don't want this anymore

[bbudge, 2013/04/13 00:44:44]

Done.

 #include <string.h>
 #include <algorithm>
 #include <limits>
@@ -85,6 +86,7 @@ TestTrueTypeFont::~TestTrueTypeFont() {
 
 void TestTrueTypeFont::RunTests(const std::string& filter) {
   RUN_TEST(GetFontFamilies, filter);
+  RUN_TEST(GetFontsInFamily, filter);
   RUN_TEST(Create, filter);
   RUN_TEST(Describe, filter);
   RUN_TEST(GetTableTags, filter);
@@ -121,6 +123,66 @@ std::string TestTrueTypeFont::TestGetFontFamilies() {
   PASS();
 }
 
+std::string TestTrueTypeFont::TestGetFontsInFamily() {
+  {
+    // Get the list of all font families.
+    TestCompletionCallbackWithOutput< std::vector<pp::Var> > cc(
+        instance_->pp_instance(), false);
+    cc.WaitForResult(pp::TrueTypeFont_Dev::GetFontFamilies(instance_,
+                                                           cc.GetCallback()));
+    // Try to use a common family that is likely to have multiple variations.
+    const std::vector<pp::Var> families = cc.output();
+    pp::Var family("Arial");
+    if (std::find(families.begin(), families.end(), family) == families.end()) {
+      family = pp::Var("Times");
+      if (std::find(families.begin(), families.end(), family) == families.end())
+        family = families[0];  // Just use the first family.
+    }
+
+    // GetFontsInFamily: A valid instance should be able to enumerate fonts
+    // in a given family.
+    TestCompletionCallbackWithOutput< std::vector<pp::TrueTypeFontDesc_Dev> >
+        cc2(instance_->pp_instance(), false);
+    cc2.WaitForResult(pp::TrueTypeFont_Dev::GetFontsInFamily(
+        instance_,
+        family,
+        cc2.GetCallback()));
+    std::vector<pp::TrueTypeFontDesc_Dev> fonts_in_family = cc2.output();
+    ASSERT_NE(0, fonts_in_family.size());
+    ASSERT_EQ(static_cast<int32_t>(fonts_in_family.size()), cc2.result());
+
+    // We should be able to create any of the returned fonts without fallback.
+    for (size_t i = 0; i < fonts_in_family.size(); ++i) {
+      pp::TrueTypeFontDesc_Dev& font_in_family = fonts_in_family[i];
+      pp::TrueTypeFont_Dev font(instance_, font_in_family);
+      TestCompletionCallbackWithOutput<pp::TrueTypeFontDesc_Dev> cc(
+          instance_->pp_instance(), false);
+      cc.WaitForResult(font.Describe(cc.GetCallback()));
+      const pp::TrueTypeFontDesc_Dev desc = cc.output();
+
+      ASSERT_EQ(family, desc.family());
+      ASSERT_EQ(font_in_family.style(), desc.style());
+      ASSERT_EQ(font_in_family.weight(), desc.weight());
+    }
+  }
+  {
+    // Using an invalid instance should fail.
+    TestCompletionCallbackWithOutput< std::vector<pp::TrueTypeFontDesc_Dev> >
+        cc(instance_->pp_instance(), false);
+    pp::Var family("Times");
+    cc.WaitForResult(
+        ppb_truetype_font_interface_->GetFontsInFamily(
+            kInvalidInstance,
+            family.pp_var(),
+            cc.GetCallback().output(),
+            cc.GetCallback().pp_completion_callback()));
+    ASSERT_EQ(PP_ERROR_FAILED, cc.result());
+    ASSERT_EQ(0, cc.output().size());
+  }
+
+  PASS();
+}
+
 std::string TestTrueTypeFont::TestCreate() {
   PP_Resource font;
   PP_TrueTypeFontDesc_Dev desc = {
@@ -134,16 +196,16 @@ std::string TestTrueTypeFont::TestCreate() {
   // Creating a font from an invalid instance returns an invalid resource.
   font = ppb_truetype_font_interface_->Create(kInvalidInstance, &desc);
   ASSERT_EQ(kInvalidResource, font);
-  ASSERT_NE(PP_TRUE, ppb_truetype_font_interface_->IsFont(font));
+  ASSERT_NE(PP_TRUE, ppb_truetype_font_interface_->IsTrueTypeFont(font));
 
   // Creating a font from a valid instance returns a font resource.
   font = ppb_truetype_font_interface_->Create(instance_->pp_instance(), &desc);
   ASSERT_NE(kInvalidResource, font);
-  ASSERT_EQ(PP_TRUE, ppb_truetype_font_interface_->IsFont(font));
+  ASSERT_EQ(PP_TRUE, ppb_truetype_font_interface_->IsTrueTypeFont(font));
 
   ppb_core_interface_->ReleaseResource(font);
   // Once released, the resource shouldn't be a font.
-  ASSERT_NE(PP_TRUE, ppb_truetype_font_interface_->IsFont(font));
+  ASSERT_NE(PP_TRUE, ppb_truetype_font_interface_->IsTrueTypeFont(font));
 
   PASS();
 }