Configure font font names in GFX unittests

ui/gfx/render_text_unittest.cc

 // Copyright (c) 2012 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.
 
 #include "ui/gfx/render_text.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 11 matching lines @@
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "ui/gfx/break_list.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/font.h"
+#include "ui/gfx/font_names_testing.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/range/range.h"
 #include "ui/gfx/range/range_f.h"
 #include "ui/gfx/render_text_harfbuzz.h"
 #include "ui/gfx/text_utils.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "ui/gfx/platform_font_win.h"
@@ skipping 1917 matching lines @@
     render_text->SetText(base::string16(length, 'a'));
     const Size string_size = render_text->GetStringSize();
     EXPECT_GT(string_size.width(), previous_string_size.width());
     EXPECT_GT(string_size.height(), 0);
     previous_string_size = string_size;
   }
 }
 
 TEST_P(RenderTextTest, StringSizeEmptyString) {
   // Ascent and descent of Arial and Symbol are different on most platforms.
-  const FontList font_list("Arial,Symbol, 16px");
+  const FontList font_list(
+      base::StringPrintf("Arial,%s, 16px", kSymbolFontName));
   RenderText* render_text = GetRenderText();
   render_text->SetFontList(font_list);
   render_text->SetDisplayRect(Rect(0, 0, 0, font_list.GetHeight()));
 
   // The empty string respects FontList metrics for non-zero height
   // and baseline.
   render_text->SetText(base::string16());
   EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
   EXPECT_EQ(0, render_text->GetStringSize().width());
   EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
 
   render_text->SetText(UTF8ToUTF16(" "));
   EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
   EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
 }
 
 TEST_P(RenderTextTest, StringSizeRespectsFontListMetrics) {
   // Check that Arial and Symbol have different font metrics.
   Font arial_font("Arial", 16);
   ASSERT_EQ("arial",
             base::ToLowerASCII(arial_font.GetActualFontNameForTesting()));
-  Font symbol_font("Symbol", 16);
-  ASSERT_EQ("symbol",
+  Font symbol_font(kSymbolFontName, 16);
+  ASSERT_EQ(base::ToLowerASCII(kSymbolFontName),
             base::ToLowerASCII(symbol_font.GetActualFontNameForTesting()));
   EXPECT_NE(arial_font.GetHeight(), symbol_font.GetHeight());
   EXPECT_NE(arial_font.GetBaseline(), symbol_font.GetBaseline());
   // "a" should be rendered with Arial, not with Symbol.
   const char* arial_font_text = "a";
-  // "®" (registered trademark symbol) should be rendered with Symbol,
+  // "⊕" CIRCLED PLUS SIGN should be rendered with Symbol,
   // not with Arial.
-  const char* symbol_font_text = "\xC2\xAE";
+  const char* symbol_font_text = u8"⊕";
 
   Font smaller_font = arial_font;
   Font larger_font = symbol_font;
   const char* smaller_font_text = arial_font_text;
   const char* larger_font_text = symbol_font_text;
   if (symbol_font.GetHeight() < arial_font.GetHeight() &&
       symbol_font.GetBaseline() < arial_font.GetBaseline()) {
     std::swap(smaller_font, larger_font);
     std::swap(smaller_font_text, larger_font_text);
   }
   ASSERT_LT(smaller_font.GetHeight(), larger_font.GetHeight());
   ASSERT_LT(smaller_font.GetBaseline(), larger_font.GetBaseline());
 
   // Check |smaller_font_text| is rendered with the smaller font.
   RenderText* render_text = GetRenderText();
   render_text->SetText(UTF8ToUTF16(smaller_font_text));
   render_text->SetFontList(FontList(smaller_font));
   render_text->SetDisplayRect(Rect(0, 0, 0,
                                    render_text->font_list().GetHeight()));
-  EXPECT_EQ(smaller_font.GetHeight(), render_text->GetStringSize().height());
-  EXPECT_EQ(smaller_font.GetBaseline(), render_text->GetBaseline());
+  EXPECT_STRCASEEQ(
+      render_text->GetFontSpansForTesting()[0].first.GetFontName().c_str(),
+      smaller_font.GetFontName().c_str());
 
   // Layout the same text with mixed fonts.  The text should be rendered with
   // the smaller font, but the height and baseline are determined with the
   // metrics of the font list, which is equal to the larger font.
   std::vector<Font> fonts;
   fonts.push_back(smaller_font);  // The primary font is the smaller font.
   fonts.push_back(larger_font);
   const FontList font_list(fonts);
   render_text->SetFontList(font_list);
   render_text->SetDisplayRect(Rect(0, 0, 0,
                                    render_text->font_list().GetHeight()));
+  EXPECT_STRCASEEQ(
+      render_text->GetFontSpansForTesting()[0].first.GetFontName().c_str(),
+      smaller_font.GetFontName().c_str());
   EXPECT_LT(smaller_font.GetHeight(), render_text->GetStringSize().height());
   EXPECT_LT(smaller_font.GetBaseline(), render_text->GetBaseline());
   EXPECT_EQ(font_list.GetHeight(), render_text->GetStringSize().height());
   EXPECT_EQ(font_list.GetBaseline(), render_text->GetBaseline());
 }
 
 TEST_P(RenderTextTest, MinLineHeight) {
   RenderText* render_text = GetRenderText();
   render_text->SetText(ASCIIToUTF16("Hello!"));
   SizeF default_size = render_text->GetStringSizeF();
   ASSERT_NE(0, default_size.height());
   ASSERT_NE(0, default_size.width());
 
   render_text->SetMinLineHeight(default_size.height() / 2);
   EXPECT_EQ(default_size.ToString(), render_text->GetStringSizeF().ToString());
 
   render_text->SetMinLineHeight(default_size.height() * 2);
   SizeF taller_size = render_text->GetStringSizeF();
   EXPECT_EQ(default_size.height() * 2, taller_size.height());
   EXPECT_EQ(default_size.width(), taller_size.width());
 }
 
 TEST_P(RenderTextTest, SetFontList) {
   RenderText* render_text = GetRenderText();
-  render_text->SetFontList(FontList("Arial,Symbol, 13px"));
+  render_text->SetFontList(
+      FontList(base::StringPrintf("Arial,%s, 13px", kSymbolFontName)));
   const std::vector<Font>& fonts = render_text->font_list().GetFonts();
   ASSERT_EQ(2U, fonts.size());
   EXPECT_EQ("Arial", fonts[0].GetFontName());
-  EXPECT_EQ("Symbol", fonts[1].GetFontName());
+  EXPECT_EQ(kSymbolFontName, fonts[1].GetFontName());
   EXPECT_EQ(13, render_text->font_list().GetFontSize());
 }
 
 // http://crbug/624513
 #if !defined(OS_WIN)
 TEST_P(RenderTextTest, StringSizeBoldWidth) {
   // TODO(mboc): Add some unittests for other weights (currently not
   // implemented because of test system font configuration).
   RenderText* render_text = GetRenderText();
   render_text->SetText(UTF8ToUTF16("Hello World"));
@@ skipping 1315 matching lines @@
   render_text->SetDisplayRect(Rect(0, 0, render_text->GetContentWidth(), 100));
   EXPECT_EQ(kString, render_text->GetDisplayText());
 }
 
 // TODO(derat): Figure out why this fails on Windows: http://crbug.com/427184
 #if !defined(OS_WIN)
 // Ensure that RenderText examines all of the fonts in its FontList before
 // falling back to other fonts.
 TEST_P(RenderTextHarfBuzzTest, HarfBuzz_FontListFallback) {
   // Double-check that the requested fonts are present.
-  FontList font_list("Arial, Symbol, 12px");
+  FontList font_list(base::StringPrintf("Arial, %s, 12px", kSymbolFontName));
   const std::vector<Font>& fonts = font_list.GetFonts();
   ASSERT_EQ(2u, fonts.size());
   ASSERT_EQ("arial",
             base::ToLowerASCII(fonts[0].GetActualFontNameForTesting()));
-  ASSERT_EQ("symbol",
+  ASSERT_EQ(base::ToLowerASCII(kSymbolFontName),
             base::ToLowerASCII(fonts[1].GetActualFontNameForTesting()));
 
   // "⊕" (CIRCLED PLUS) should be rendered with Symbol rather than falling back
   // to some other font that's present on the system.
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
   render_text->SetFontList(font_list);
   render_text->SetText(UTF8ToUTF16("\xE2\x8A\x95"));
   const std::vector<RenderText::FontSpan> spans =
       render_text->GetFontSpansForTesting();
   ASSERT_EQ(static_cast<size_t>(1), spans.size());
-  EXPECT_EQ("Symbol", spans[0].first.GetFontName());
+  EXPECT_STRCASEEQ(kSymbolFontName, spans[0].first.GetFontName().c_str());
 }
 #endif  // !defined(OS_WIN)
 
 // Ensure that the fallback fonts of the Uniscribe font are tried for shaping.
 #if defined(OS_WIN)
 TEST_P(RenderTextHarfBuzzTest, HarfBuzz_UniscribeFallback) {
   RenderTextHarfBuzz* render_text = GetRenderTextHarfBuzz();
   PlatformFontWin* font_win = new PlatformFontWin("Meiryo", 12);
   // Japanese name for Meiryo. This name won't be found in the system's linked
   // fonts, forcing RTHB to try the Uniscribe font and its fallbacks.
@@ skipping 314 matching lines @@
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 #endif
 
 INSTANTIATE_TEST_CASE_P(,
                         RenderTextHarfBuzzTest,
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 
 }  // namespace gfx