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

ppapi/tests/test_truetype_font.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Tests PPB_TrueTypeFont interface.
 
 #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>
 
 #include "ppapi/c/dev/ppb_testing_dev.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/dev/truetype_font_dev.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/tests/test_utils.h"
@@ skipping 59 matching lines @@
     instance_->AppendError("PPB_Var interface not available");
 
   return true;
 }
 
 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);
   RUN_TEST(GetTable, filter);
 }
 
 std::string TestTrueTypeFont::TestGetFontFamilies() {
   {
     // A valid instance should be able to enumerate fonts.
     TestCompletionCallbackWithOutput< std::vector<pp::Var> > cc(
@@ skipping 16 matching lines @@
             kInvalidInstance,
             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::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 = {
     PP_MakeUndefined(),
     PP_TRUETYPEFONTFAMILY_SERIF,
     PP_TRUETYPEFONTSTYLE_NORMAL,
     PP_TRUETYPEFONTWEIGHT_NORMAL,
     PP_TRUETYPEFONTWIDTH_NORMAL,
     PP_TRUETYPEFONTCHARSET_DEFAULT
   };
   // 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();
 }
 
 std::string TestTrueTypeFont::TestDescribe() {
   pp::TrueTypeFontDesc_Dev create_desc;
   create_desc.set_generic_family(PP_TRUETYPEFONTFAMILY_SERIF);
   create_desc.set_style(PP_TRUETYPEFONTSTYLE_NORMAL);
   create_desc.set_weight(PP_TRUETYPEFONTWEIGHT_NORMAL);
   pp::TrueTypeFont_Dev font(instance_, create_desc);
@@ skipping 200 matching lines @@
         instance_->pp_instance(), false);
     cc.WaitForResult(font.GetTable(MAKE_TABLE_TAG('c', 'm', 'a', 'p'),
                                    0, -100,
                                    cc.GetCallback()));
     ASSERT_EQ(PP_ERROR_BADARGUMENT, cc.result());
     ASSERT_EQ(0, cc.output().size());
   }
 
   PASS();
 }