ppapi/tests/test_browser_font.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ppapi/tests/test_browser_font.h"
   6
   7 #include <string.h>
   8
   9 #include "ppapi/tests/test_utils.h"
  10 #include "ppapi/tests/testing_instance.h"
  11 #include "ppapi/cpp/image_data.h"
  12 #include "ppapi/cpp/trusted/browser_font_trusted.h"
  13
  14 REGISTER_TEST_CASE(BrowserFont);
  15
  16 bool TestBrowserFont::Init() {
  17   return true;
  18 }
  19
  20 void TestBrowserFont::RunTests(const std::string& filter) {
  21   RUN_TEST(FontFamilies, filter);
  22   RUN_TEST(Measure, filter);
  23   RUN_TEST(MeasureRTL, filter);
  24   RUN_TEST(CharPos, filter);
  25   // This test is disabled. It doesn't currently pass. See the
  26   // CharacterOffsetForPixel API.
  27   //RUN_TEST(CharPosRTL, filter);
  28   RUN_TEST(Draw, filter);
  29 }
  30
  31 // Just tests that GetFontFamilies is hooked up & returns something.
  32 std::string TestBrowserFont::TestFontFamilies() {
  33   // This function is only supported out-of-process.
  34   const PPB_Testing_Dev* testing_interface = GetTestingInterface();
  35   if (testing_interface && !testing_interface->IsOutOfProcess())
  36     PASS();
  37
  38   pp::Var families = pp::BrowserFont_Trusted::GetFontFamilies(instance_);
  39
  40   ASSERT_TRUE(families.is_string());
  41   ASSERT_TRUE(!families.AsString().empty());
  42   PASS();
  43 }
  44
  45 // Tests that measuring text behaves reasonably. We aren't sure if the browser
  46 // will be doing kerning or something for the particular default font, so we
  47 // just make a string that we're pretty sure should be more than twice as long
  48 // as another one, and verify that condition.
  49 std::string TestBrowserFont::TestMeasure() {
  50   pp::BrowserFontDescription desc;
  51   pp::BrowserFont_Trusted font(instance_, desc);
  52
  53   int32_t length1 = font.MeasureText(pp::BrowserFontTextRun("WWW"));
  54   ASSERT_TRUE(length1 > 0);
  55   int32_t length2 = font.MeasureText(pp::BrowserFontTextRun("WWWWWWWW"));
  56
  57   ASSERT_TRUE(length2 >= length1 * 2);
  58   PASS();
  59 }
  60
  61 std::string TestBrowserFont::TestMeasureRTL() {
  62   pp::BrowserFontDescription desc;
  63   pp::BrowserFont_Trusted font(instance_, desc);
  64
  65   // Mixed string, two chars of LTR, two of RTL, then two of LTR.
  66   // Note this is in UTF-8 so has more than 6 bytes.
  67   std::string mixed("AB\xd7\x94\xd7\x97ZZ");
  68   const int kNumChars = 6;
  69   pp::BrowserFontTextRun run(mixed);
  70
  71   // Note that since this is UTF-8, the two RTL chars are two bytes each.
  72   int32_t len[kNumChars];
  73   len[0] = font.PixelOffsetForCharacter(run, 0);
  74   len[1] = font.PixelOffsetForCharacter(run, 1);
  75   len[2] = font.PixelOffsetForCharacter(run, 2);
  76   len[3] = font.PixelOffsetForCharacter(run, 3);
  77   len[4] = font.PixelOffsetForCharacter(run, 4);
  78   len[5] = font.PixelOffsetForCharacter(run, 5);
  79
  80   // First three chars should be increasing.
  81   ASSERT_TRUE(len[0] >= 0);
  82   ASSERT_TRUE(len[1] > len[0]);
  83   ASSERT_TRUE(len[3] > len[1]);
  84   ASSERT_TRUE(len[2] > len[3]);
  85   ASSERT_TRUE(len[4] > len[2]);
  86   ASSERT_TRUE(len[5] > len[4]);
  87
  88   // Test the same sequence with force LTR. The offsets should appear in
  89   // sequence.
  90   pp::BrowserFontTextRun forced_run(mixed, false, true);
  91   len[0] = font.PixelOffsetForCharacter(forced_run, 0);
  92   len[1] = font.PixelOffsetForCharacter(forced_run, 1);
  93   len[2] = font.PixelOffsetForCharacter(forced_run, 2);
  94   len[3] = font.PixelOffsetForCharacter(forced_run, 3);
  95   len[4] = font.PixelOffsetForCharacter(forced_run, 4);
  96   len[5] = font.PixelOffsetForCharacter(forced_run, 5);
  97   for (int i = 1; i < kNumChars; i++)
  98     ASSERT_TRUE(len[i] > len[i - 1]);
  99
 100   PASS();
 101 }
 102
 103 // Tests that the character/pixel offset functions correctly round-trip.
 104 std::string TestBrowserFont::TestCharPos() {
 105   pp::BrowserFontDescription desc;
 106   pp::BrowserFont_Trusted font(instance_, desc);
 107
 108   pp::BrowserFontTextRun run("Hello, world");
 109   uint32_t original_char = 3;
 110   uint32_t pixel_offset = font.PixelOffsetForCharacter(run, original_char);
 111   ASSERT_TRUE(pixel_offset > 0);
 112
 113   uint32_t computed_char = font.CharacterOffsetForPixel(
 114       run, static_cast<int32_t>(pixel_offset));
 115   ASSERT_TRUE(computed_char == original_char);
 116
 117   PASS();
 118 }
 119
 120 // Tests that we can get character positions in a mixed LTR/RTL run.
 121 std::string TestBrowserFont::TestCharPosRTL() {
 122   pp::BrowserFontDescription desc;
 123   pp::BrowserFont_Trusted font(instance_, desc);
 124
 125   // Mixed string, two chars of LTR, two of RTL, than two of LTR.
 126   // Note this is in UTF-8 so has more than 6 bytes.
 127   std::string mixed("AB\xd7\x94\xd7\x97ZZ");
 128
 129   pp::BrowserFontTextRun run(mixed);
 130   static const int kNumChars = 6;
 131   int expected_char_sequence[kNumChars] = { 0, 1, 3, 2, 4, 5 };
 132
 133   // Check that the characters appear in the order we expect.
 134   int pixel_width = font.MeasureText(pp::BrowserFontTextRun(mixed));
 135   int last_sequence = 0;  // Index into expected_char_sequence.
 136   for (int x = 0; x < pixel_width; x++) {
 137     int cur_char = font.CharacterOffsetForPixel(run, x);
 138     if (cur_char != expected_char_sequence[last_sequence]) {
 139       // This pixel has a different character. It should be the next one in
 140       // the sequence for it to be correct.
 141       last_sequence++;
 142       ASSERT_TRUE(last_sequence < kNumChars);
 143       ASSERT_TRUE(cur_char == expected_char_sequence[last_sequence]);
 144     }
 145   }
 146
 147   // Try the same string with force LTR. The characters should all appear in
 148   // sequence.
 149   pp::BrowserFontTextRun forced_run(mixed, false, true);
 150   int last_forced_char = 0;  // Char index into the forced sequence.
 151   for (int x = 0; x < pixel_width; x++) {
 152     int cur_char = font.CharacterOffsetForPixel(forced_run, x);
 153     if (cur_char != last_forced_char) {
 154       last_forced_char++;
 155       ASSERT_TRUE(cur_char == last_forced_char);
 156     }
 157   }
 158
 159   PASS();
 160 }
 161
 162 // Tests that drawing some text produces "some" output.
 163 std::string TestBrowserFont::TestDraw() {
 164   pp::BrowserFontDescription desc;
 165   desc.set_family(PP_BROWSERFONT_TRUSTED_FAMILY_MONOSPACE);
 166   desc.set_size(10);
 167   pp::BrowserFont_Trusted font(instance_, desc);
 168
 169   const pp::Size kSize(30, 10);
 170   pp::ImageData image(instance_,
 171                       PP_IMAGEDATAFORMAT_BGRA_PREMUL,  // 0xAARRGGBB
 172                       kSize,
 173                       false);  // init_to_zero
 174   ASSERT_FALSE(image.is_null());
 175
 176   // Draw black text on white canvas.
 177   memset(image.data(), 0xFF, 4 * kSize.GetArea());
 178   font.DrawSimpleText(&image,
 179                       "Hello",
 180                       pp::Point(0, 10),  // Baseline position.
 181                       0xFF000000,  // Black text.
 182                       true);  // image_data_is_opaque.
 183
 184   // Expect that at least a few pixels are non-white (text).
 185   // Due to blending, there may be rounding errors and
 186   // checking for exact black may not be correct.
 187   // Also expect that all pixels are opaque.
 188   const uint32_t kRGBMask = 0x00FFFFFF;
 189   const uint32_t kAlphaMask = 0xFF000000;
 190   int text_pixels = 0, opaque_pixels = 0;
 191   const uint32_t* pixels = static_cast<const uint32_t*>(image.data());
 192   for (int i = 0; i < kSize.GetArea(); ++i) {
 193     if ((pixels[i] & kRGBMask) != kRGBMask)
 194       ++text_pixels;
 195     if ((pixels[i] & kAlphaMask) == kAlphaMask)
 196       ++opaque_pixels;
 197   }
 198   ASSERT_GT(text_pixels, 0);
 199   ASSERT_EQ(opaque_pixels, kSize.GetArea());
 200   PASS();
 201 }