Allow various font weights in gfx.

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 308 matching lines @@
     render_text->SetText(WideToUTF16(cases[i]));
   }
 }
 
 TEST_F(RenderTextTest, SetStyles) {
   // Ensure custom default styles persist across setting and clearing text.
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   const SkColor color = SK_ColorRED;
   render_text->SetColor(color);
   render_text->SetBaselineStyle(SUPERSCRIPT);
-  render_text->SetStyle(BOLD, true);
+  render_text->SetWeight(Font::Weight::BOLD);
   render_text->SetStyle(UNDERLINE, false);
   const wchar_t* const cases[] = { kWeak, kLtr, L"Hello", kRtl, L"", L"" };
   for (size_t i = 0; i < arraysize(cases); ++i) {
     EXPECT_TRUE(render_text->colors().EqualsValueForTesting(color));
     EXPECT_TRUE(render_text->baselines().EqualsValueForTesting(SUPERSCRIPT));
-    EXPECT_TRUE(render_text->styles()[BOLD].EqualsValueForTesting(true));
+    EXPECT_TRUE(
+        render_text->weights().EqualsValueForTesting(Font::Weight::BOLD));
     EXPECT_TRUE(render_text->styles()[UNDERLINE].EqualsValueForTesting(false));
     render_text->SetText(WideToUTF16(cases[i]));
 
     // Ensure custom default styles can be applied after text has been set.
     if (i == 1)
       render_text->SetStyle(STRIKE, true);
     if (i >= 1)
       EXPECT_TRUE(render_text->styles()[STRIKE].EqualsValueForTesting(true));
   }
 }
 
 TEST_F(RenderTextTest, ApplyStyles) {
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetText(ASCIIToUTF16("012345678"));
 
   // Apply a ranged color and style and check the resulting breaks.
   render_text->ApplyColor(SK_ColorRED, Range(1, 4));
   render_text->ApplyBaselineStyle(SUPERIOR, Range(2, 4));
-  render_text->ApplyStyle(BOLD, true, Range(2, 5));
+  render_text->ApplyWeight(Font::Weight::BOLD, Range(2, 5));
   std::vector<std::pair<size_t, SkColor> > expected_color;
   expected_color.push_back(std::pair<size_t, SkColor>(0, SK_ColorBLACK));
   expected_color.push_back(std::pair<size_t, SkColor>(1, SK_ColorRED));
   expected_color.push_back(std::pair<size_t, SkColor>(4, SK_ColorBLACK));
   EXPECT_TRUE(render_text->colors().EqualsForTesting(expected_color));
   std::vector<std::pair<size_t, BaselineStyle>> expected_baseline_style;
   expected_baseline_style.push_back(
       std::pair<size_t, BaselineStyle>(0, NORMAL_BASELINE));
   expected_baseline_style.push_back(
       std::pair<size_t, BaselineStyle>(2, SUPERIOR));
   expected_baseline_style.push_back(
       std::pair<size_t, BaselineStyle>(4, NORMAL_BASELINE));
   EXPECT_TRUE(
       render_text->baselines().EqualsForTesting(expected_baseline_style));
-  std::vector<std::pair<size_t, bool> > expected_style;
-  expected_style.push_back(std::pair<size_t, bool>(0, false));
-  expected_style.push_back(std::pair<size_t, bool>(2, true));
-  expected_style.push_back(std::pair<size_t, bool>(5, false));
-  EXPECT_TRUE(render_text->styles()[BOLD].EqualsForTesting(expected_style));
+  std::vector<std::pair<size_t, Font::Weight>> expected_weight;
+  expected_weight.push_back(
+      std::pair<size_t, Font::Weight>(0, Font::Weight::NORMAL));
+  expected_weight.push_back(
+      std::pair<size_t, Font::Weight>(2, Font::Weight::BOLD));
+  expected_weight.push_back(
+      std::pair<size_t, Font::Weight>(5, Font::Weight::NORMAL));
+  EXPECT_TRUE(render_text->weights().EqualsForTesting(expected_weight));
 
   // Ensure that setting a value overrides the ranged values.
   render_text->SetColor(SK_ColorBLUE);
   EXPECT_TRUE(render_text->colors().EqualsValueForTesting(SK_ColorBLUE));
   render_text->SetBaselineStyle(SUBSCRIPT);
   EXPECT_TRUE(render_text->baselines().EqualsValueForTesting(SUBSCRIPT));
-  render_text->SetStyle(BOLD, false);
-  EXPECT_TRUE(render_text->styles()[BOLD].EqualsValueForTesting(false));
+  render_text->SetWeight(Font::Weight::NORMAL);
+  EXPECT_TRUE(
+      render_text->weights().EqualsValueForTesting(Font::Weight::NORMAL));
 
   // Apply a value over the text end and check the resulting breaks (INT_MAX
   // should be used instead of the text length for the range end)
   const size_t text_length = render_text->text().length();
   render_text->ApplyColor(SK_ColorRED, Range(0, text_length));
   render_text->ApplyBaselineStyle(SUPERIOR, Range(0, text_length));
-  render_text->ApplyStyle(BOLD, true, Range(2, text_length));
+  render_text->ApplyWeight(Font::Weight::BOLD, Range(2, text_length));
   std::vector<std::pair<size_t, SkColor> > expected_color_end;
   expected_color_end.push_back(std::pair<size_t, SkColor>(0, SK_ColorRED));
   EXPECT_TRUE(render_text->colors().EqualsForTesting(expected_color_end));
   std::vector<std::pair<size_t, BaselineStyle>> expected_baseline_end;
   expected_baseline_end.push_back(
       std::pair<size_t, BaselineStyle>(0, SUPERIOR));
   EXPECT_TRUE(render_text->baselines().EqualsForTesting(expected_baseline_end));
-  std::vector<std::pair<size_t, bool> > expected_style_end;
-  expected_style_end.push_back(std::pair<size_t, bool>(0, false));
-  expected_style_end.push_back(std::pair<size_t, bool>(2, true));
-  EXPECT_TRUE(render_text->styles()[BOLD].EqualsForTesting(expected_style_end));
+  std::vector<std::pair<size_t, Font::Weight>> expected_weight_end;
+  expected_weight_end.push_back(
+      std::pair<size_t, Font::Weight>(0, Font::Weight::NORMAL));
+  expected_weight_end.push_back(
+      std::pair<size_t, Font::Weight>(2, Font::Weight::BOLD));
+  EXPECT_TRUE(render_text->weights().EqualsForTesting(expected_weight_end));
 
   // Ensure ranged values adjust to accommodate text length changes.
   render_text->ApplyStyle(ITALIC, true, Range(0, 2));
   render_text->ApplyStyle(ITALIC, true, Range(3, 6));
   render_text->ApplyStyle(ITALIC, true, Range(7, text_length));
   std::vector<std::pair<size_t, bool> > expected_italic;
   expected_italic.push_back(std::pair<size_t, bool>(0, true));
   expected_italic.push_back(std::pair<size_t, bool>(2, false));
   expected_italic.push_back(std::pair<size_t, bool>(3, true));
   expected_italic.push_back(std::pair<size_t, bool>(6, false));
@@ skipping 336 matching lines @@
 TEST_F(RenderTextTest, MultilineElide) {
   std::unique_ptr<RenderText> render_text(new RenderTextHarfBuzz);
   base::string16 input_text;
   // Aim for 3 lines of text.
   for (int i = 0; i < 20; ++i)
     input_text.append(ASCIIToUTF16("hello world "));
   render_text->SetText(input_text);
   // Apply a style that tweaks the layout to make sure elision is calculated
   // with these styles. This can expose a behavior in layout where text is
   // slightly different width. This must be done after |SetText()|.
-  render_text->ApplyStyle(gfx::BOLD, true, gfx::Range(1, 20));
-  render_text->ApplyStyle(gfx::ITALIC, true, gfx::Range(1, 20));
-  render_text->ApplyStyle(gfx::DIAGONAL_STRIKE, true, gfx::Range(1, 20));
+  render_text->ApplyWeight(Font::Weight::BOLD, Range(1, 20));
+  render_text->ApplyStyle(ITALIC, true, Range(1, 20));
+  render_text->ApplyStyle(DIAGONAL_STRIKE, true, Range(1, 20));
   render_text->SetMultiline(true);
   render_text->SetElideBehavior(ELIDE_TAIL);
   render_text->SetMaxLines(3);
-  const gfx::Size size = render_text->GetStringSize();
+  const Size size = render_text->GetStringSize();
   // Fit in 3 lines. (If we knew the width of a word, we could
   // anticipate word wrap better.)
-  render_text->SetDisplayRect(gfx::Rect((size.width() + 96) / 3, 0));
+  render_text->SetDisplayRect(Rect((size.width() + 96) / 3, 0));
   // Trigger rendering.
   render_text->GetStringSize();
   EXPECT_EQ(input_text, render_text->GetDisplayText());
 
   const base::char16 kEllipsisUTF16[] = {0x2026, 0};
   base::string16 actual_text;
   // Try widening the space gradually, one pixel at a time, trying
   // to trigger a failure in layout. There was an issue where, right at
   // the edge of a word getting truncated, the estimate would be wrong
   // and it would wrap instead.
   for (int i = (size.width() - 12) / 3; i < (size.width() + 30) / 3; ++i) {
-    render_text->SetDisplayRect(gfx::Rect(i, 0));
+    render_text->SetDisplayRect(Rect(i, 0));
     // Trigger rendering.
     render_text->GetStringSize();
     actual_text = render_text->GetDisplayText();
     EXPECT_LT(actual_text.size(), input_text.size());
     EXPECT_EQ(actual_text, input_text.substr(0, actual_text.size() - 1) +
                                base::string16(kEllipsisUTF16));
     EXPECT_EQ(3U, render_text->GetNumLines());
   }
   // Now remove line restriction.
   render_text->SetMaxLines(0);
   render_text->GetStringSize();
   EXPECT_EQ(input_text, render_text->GetDisplayText());
 
   // And put it back.
   render_text->SetMaxLines(3);
   render_text->GetStringSize();
   EXPECT_LT(actual_text.size(), input_text.size());
   EXPECT_EQ(actual_text, input_text.substr(0, actual_text.size() - 1) +
                              base::string16(kEllipsisUTF16));
 }
 
 #endif  // !defined(OS_MACOSX)
 
 TEST_F(RenderTextTest, ElidedEmail) {
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetText(ASCIIToUTF16("test@example.com"));
-  const gfx::Size size = render_text->GetStringSize();
+  const Size size = render_text->GetStringSize();
 
   const base::string16 long_email =
       ASCIIToUTF16("longemailaddresstest@example.com");
   render_text->SetText(long_email);
   render_text->SetElideBehavior(ELIDE_EMAIL);
-  render_text->SetDisplayRect(gfx::Rect(size));
+  render_text->SetDisplayRect(Rect(size));
   EXPECT_GE(size.width(), render_text->GetStringSize().width());
   EXPECT_GT(long_email.size(), render_text->GetDisplayText().size());
 }
 
 TEST_F(RenderTextTest, TruncatedText) {
   struct {
     const wchar_t* text;
     const wchar_t* display_text;
   } cases[] = {
     // Strings shorter than the truncation length should be laid out in full.
@@ skipping 909 matching lines @@
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetFontList(FontList("Arial,Symbol, 13px"));
   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(13, render_text->font_list().GetFontSize());
 }
 
 TEST_F(RenderTextTest, StringSizeBoldWidth) {
+  // TODO(mboc): Add some unittests for other weights (currently not
+  // implemented because of test system font configuration).
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetText(UTF8ToUTF16("Hello World"));
 
   const int plain_width = render_text->GetStringSize().width();
   EXPECT_GT(plain_width, 0);
 
   // Apply a bold style and check that the new width is greater.
-  render_text->SetStyle(BOLD, true);
+  render_text->SetWeight(Font::Weight::BOLD);
   const int bold_width = render_text->GetStringSize().width();
   EXPECT_GT(bold_width, plain_width);
 
+#if defined(OS_WIN)
+  render_text->SetWeight(Font::Weight::SEMIBOLD);
+  const int semibold_width = render_text->GetStringSize().width();
+  EXPECT_GT(bold_width, semibold_width);
+#endif
+
   // Now, apply a plain style over the first word only.
-  render_text->ApplyStyle(BOLD, false, Range(0, 5));
+  render_text->ApplyWeight(Font::Weight::NORMAL, Range(0, 5));
   const int plain_bold_width = render_text->GetStringSize().width();
   EXPECT_GT(plain_bold_width, plain_width);
   EXPECT_LT(plain_bold_width, bold_width);
 }
 
 TEST_F(RenderTextTest, StringSizeHeight) {
   base::string16 cases[] = {
     WideToUTF16(L"Hello World!"),  // English
     WideToUTF16(L"\x6328\x62f6"),  // Japanese
     WideToUTF16(L"\x0915\x093f"),  // Hindi
@@ skipping 661 matching lines @@
     // to the original text.
     render_text.SetMultiline(true);
     EXPECT_EQ(WideToUTF16(kTestStrings[i]), render_text.GetDisplayText());
   }
 }
 
 // Ensure horizontal alignment works in multiline mode.
 TEST_F(RenderTextTest, Multiline_HorizontalAlignment) {
   const struct {
     const wchar_t* const text;
-    const gfx::HorizontalAlignment alignment;
+    const HorizontalAlignment alignment;
   } kTestStrings[] = {
-    { L"abcdefghij\nhijkl", gfx::ALIGN_LEFT },
-    { L"nhijkl\nabcdefghij", gfx::ALIGN_LEFT },
+    { L"abcdefghij\nhijkl", ALIGN_LEFT },
+    { L"nhijkl\nabcdefghij", ALIGN_LEFT },
     // hebrew, 2nd line shorter
     { L"\x5d0\x5d1\x5d2\x5d3\x5d4\x5d5\x5d6\x5d7\n\x5d0\x5d1\x5d2\x5d3",
-      gfx::ALIGN_RIGHT },
+      ALIGN_RIGHT },
     // hebrew, 2nd line longer
     { L"\x5d0\x5d1\x5d2\x5d3\n\x5d0\x5d1\x5d2\x5d3\x5d4\x5d5\x5d6\x5d7",
-      gfx::ALIGN_RIGHT },
+      ALIGN_RIGHT },
     // arabic, 2nd line shorter
     { L"\x62a\x62b\x62c\x62d\x62e\x62f\x630\n\x660\x661\x662\x663\x664",
-      gfx::ALIGN_RIGHT },
+      ALIGN_RIGHT },
     // arabic, 2nd line longer
     { L"\x660\x661\x662\x663\x664\n\x62a\x62b\x62c\x62d\x62e\x62f\x630",
-      gfx::ALIGN_RIGHT },
+      ALIGN_RIGHT },
   };
   const int kGlyphSize = 5;
   RenderTextHarfBuzz render_text;
-  render_text.SetHorizontalAlignment(gfx::ALIGN_TO_HEAD);
+  render_text.SetHorizontalAlignment(ALIGN_TO_HEAD);
   render_text.set_glyph_width_for_test(kGlyphSize);
   render_text.SetDisplayRect(Rect(100, 1000));
   render_text.SetMultiline(true);
 
   Canvas canvas;
   for (size_t i = 0; i < arraysize(kTestStrings); ++i) {
     SCOPED_TRACE(base::StringPrintf("kTestStrings[%" PRIuS "] %ls", i,
                                     kTestStrings[i].text));
     render_text.SetText(WideToUTF16(kTestStrings[i].text));
     render_text.Draw(&canvas);
     ASSERT_LE(2u, render_text.lines().size());
-    if (kTestStrings[i].alignment == gfx::ALIGN_LEFT) {
+    if (kTestStrings[i].alignment == ALIGN_LEFT) {
       EXPECT_EQ(0, render_text.GetAlignmentOffset(0).x());
       EXPECT_EQ(0, render_text.GetAlignmentOffset(1).x());
     } else {
       std::vector<base::string16> lines = base::SplitString(
           base::WideToUTF16(kTestStrings[i].text),
           base::string16(1, '\n'), base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       ASSERT_EQ(2u, lines.size());
       int difference = (lines[0].length() - lines[1].length()) * kGlyphSize;
       EXPECT_EQ(render_text.GetAlignmentOffset(0).x() + difference,
                 render_text.GetAlignmentOffset(1).x());
@@ skipping 546 matching lines @@
   EXPECT_EQ(Range(3, 8), chars);
   EXPECT_EQ(Range(0, 0), glyphs);
 }
 
 // Ensure the line breaker doesn't compute the word's width bigger than the
 // actual size. See http://crbug.com/470073
 TEST_F(RenderTextTest, HarfBuzz_WordWidthWithDiacritics) {
   RenderTextHarfBuzz render_text;
   const base::string16 kWord = WideToUTF16(L"\u0906\u092A\u0915\u0947 ");
   render_text.SetText(kWord);
-  const gfx::SizeF text_size = render_text.GetStringSizeF();
+  const SizeF text_size = render_text.GetStringSizeF();
 
   render_text.SetText(kWord + kWord);
   render_text.SetMultiline(true);
   EXPECT_EQ(text_size.width() * 2, render_text.GetStringSizeF().width());
   EXPECT_EQ(text_size.height(), render_text.GetStringSizeF().height());
-  render_text.SetDisplayRect(gfx::Rect(0, 0, std::ceil(text_size.width()), 0));
+  render_text.SetDisplayRect(Rect(0, 0, std::ceil(text_size.width()), 0));
   EXPECT_NEAR(text_size.width(), render_text.GetStringSizeF().width(), 1.0f);
   EXPECT_EQ(text_size.height() * 2, render_text.GetStringSizeF().height());
 }
 
 // Ensure a string fits in a display rect with a width equal to the string's.
 TEST_F(RenderTextTest, StringFitsOwnWidth) {
   std::unique_ptr<RenderText> render_text(RenderText::CreateInstance());
   const base::string16 kString = ASCIIToUTF16("www.example.com");
 
   render_text->SetText(kString);
-  render_text->ApplyStyle(BOLD, true, Range(0, 3));
+  render_text->ApplyWeight(Font::Weight::BOLD, Range(0, 3));
   render_text->SetElideBehavior(ELIDE_TAIL);
 
   render_text->SetDisplayRect(Rect(0, 0, 500, 100));
   EXPECT_EQ(kString, render_text->GetDisplayText());
   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)
@@ skipping 87 matching lines @@
   render_text->SetColor(SK_ColorBLACK);
 
   for (auto string : kTestStrings) {
     surface->getCanvas()->clear(SK_ColorWHITE);
     render_text->SetText(WideToUTF16(string));
     const Size string_size = render_text->GetStringSize();
     render_text->ApplyBaselineStyle(SUPERSCRIPT, Range(1, 2));
     render_text->ApplyBaselineStyle(SUPERIOR, Range(3, 4));
     render_text->ApplyBaselineStyle(INFERIOR, Range(5, 6));
     render_text->ApplyBaselineStyle(SUBSCRIPT, Range(7, 8));
-    render_text->SetStyle(BOLD, true);
+    render_text->SetWeight(Font::Weight::BOLD);
     render_text->SetDisplayRect(
         Rect(kTestSize, kTestSize, string_size.width(), string_size.height()));
     // Allow the RenderText to paint outside of its display rect.
     render_text->set_clip_to_display_rect(false);
     ASSERT_LE(string_size.width() + kTestSize * 2, kCanvasSize.width());
 
     render_text->Draw(&canvas);
     ASSERT_LT(string_size.width() + kTestSize, kCanvasSize.width());
     SkPixmap pixmap;
     surface->peekPixels(&pixmap);
@@ skipping 109 matching lines @@
                                   kTestSize, kTestSize, fake_height);
     }
   }
 }
 
 #if defined(OS_MACOSX)
 TEST_F(RenderTextTest, Mac_ElidedText) {
   RenderTextMac render_text;
   base::string16 text(ASCIIToUTF16("This is an example."));
   render_text.SetText(text);
-  gfx::Size string_size = render_text.GetStringSize();
-  render_text.SetDisplayRect(gfx::Rect(string_size));
+  Size string_size = render_text.GetStringSize();
+  render_text.SetDisplayRect(Rect(string_size));
   render_text.EnsureLayout();
   // NOTE: Character and glyph counts are only comparable for simple text.
   EXPECT_EQ(text.size(),
             static_cast<size_t>(CTLineGetGlyphCount(render_text.line_)));
 
   render_text.SetElideBehavior(ELIDE_TAIL);
   string_size.set_width(string_size.width() / 2);
-  render_text.SetDisplayRect(gfx::Rect(string_size));
+  render_text.SetDisplayRect(Rect(string_size));
   render_text.EnsureLayout();
   CFIndex glyph_count = CTLineGetGlyphCount(render_text.line_);
   EXPECT_GT(text.size(), static_cast<size_t>(glyph_count));
   EXPECT_NE(0, glyph_count);
 }
 #endif
 
 // Ensure color changes are picked up by the RenderText implementation.
 TEST_F(RenderTextTest, ColorChange) {
   RenderTextAllBackends backend;
@@ skipping 18 matching lines @@
 }
 
 // Ensure style information propagates to the typeface on the text renderer.
 TEST_F(RenderTextTest, StylePropagated) {
   RenderTextAllBackends backend;
 
   // Default-constructed fonts on Mac are system fonts. These can have all kinds
   // of weird weights and style, which are preserved by PlatformFontMac, but do
   // not map simply to a SkTypeface::Style (the full details in SkFontStyle is
   // needed). They also vary depending on the OS version, so set a known font.
-  gfx::FontList font_list(gfx::Font("Arial", 10));
+  FontList font_list(Font("Arial", 10));
 
   while (backend.Advance()) {
     SCOPED_TRACE(testing::Message() << "backend: " << backend.GetName());
     backend->SetText(ASCIIToUTF16("x"));
     backend->SetFontList(font_list);
 
     backend.DrawVisualText();
     EXPECT_EQ(SkTypeface::kNormal, backend.paint().getTypeface()->style());
 
-    backend->SetStyle(TextStyle::BOLD, true);
+    backend->SetWeight(Font::Weight::BOLD);
     backend.DrawVisualText();
     EXPECT_EQ(SkTypeface::kBold, backend.paint().getTypeface()->style());
 
     backend->SetStyle(TextStyle::ITALIC, true);
     backend.DrawVisualText();
     EXPECT_EQ(SkTypeface::kBoldItalic, backend.paint().getTypeface()->style());
 
-    backend->SetStyle(TextStyle::BOLD, false);
+    backend->SetWeight(Font::Weight::NORMAL);
     backend.DrawVisualText();
     EXPECT_EQ(SkTypeface::kItalic, backend.paint().getTypeface()->style());
   }
 }
 
 // Ensure the painter adheres to RenderText::subpixel_rendering_suppressed().
 TEST_F(RenderTextTest, SubpixelRenderingSuppressed) {
   RenderTextAllBackends backend;
 
   while (backend.Advance()) {
@@ skipping 20 matching lines @@
     EXPECT_FALSE(backend.paint().isLCDRenderText());
     backend.GetHarfbuzzRunList()->runs()[0]->render_params.subpixel_rendering =
         FontRenderParams::SUBPIXEL_RENDERING_RGB;
     backend.DrawVisualText();
 #endif
     EXPECT_FALSE(backend.paint().isLCDRenderText());
   }
 }
 
 }  // namespace gfx