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 243 matching lines @@
     render_text->SetText(WideToUTF16(cases[i]));
   }
 }
 
 TEST_F(RenderTextTest, SetStyles) {
   // Ensure custom default styles persist across setting and clearing text.
   scoped_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(gfx::Font::Weight::BOLD);

[Alexei Svitkine (slow), 2016/04/05 16:38:53]

Remove gfx::

   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(gfx::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) {
   scoped_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(gfx::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, gfx::Font::Weight>> expected_weight;
+  expected_weight.push_back(
+      std::pair<size_t, gfx::Font::Weight>(0, gfx::Font::Weight::NORMAL));
+  expected_weight.push_back(
+      std::pair<size_t, gfx::Font::Weight>(2, gfx::Font::Weight::BOLD));
+  expected_weight.push_back(
+      std::pair<size_t, gfx::Font::Weight>(5, gfx::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(gfx::Font::Weight::NORMAL);
+  EXPECT_TRUE(
+      render_text->weights().EqualsValueForTesting(gfx::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(gfx::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, gfx::Font::Weight>> expected_weight_end;
+  expected_weight_end.push_back(
+      std::pair<size_t, gfx::Font::Weight>(0, gfx::Font::Weight::NORMAL));
+  expected_weight_end.push_back(
+      std::pair<size_t, gfx::Font::Weight>(2, gfx::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 1270 matching lines @@
 }
 
 TEST_F(RenderTextTest, StringSizeBoldWidth) {
   scoped_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(gfx::Font::Weight::BOLD);
   const int bold_width = render_text->GetStringSize().width();
   EXPECT_GT(bold_width, plain_width);
 
   // Now, apply a plain style over the first word only.
-  render_text->ApplyStyle(BOLD, false, Range(0, 5));
+  render_text->ApplyWeight(gfx::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 1276 matching lines @@
   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) {
   scoped_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(gfx::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(gfx::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());
     const uint32_t* buffer =
         static_cast<const uint32_t*>(surface->peekPixels(nullptr, nullptr));
@@ skipping 163 matching lines @@
     backend[i]->SetColor(SK_ColorRED);
     test_api.DrawVisualText(&renderer);
 
     renderer.GetTextLogAndReset(&text_log);
     EXPECT_EQ(1u, text_log.size());
     EXPECT_EQ(SK_ColorRED, text_log[0].color);
   }
 }
 
 }  // namespace gfx