adding baseline options for super/sub scripting

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 <algorithm>
 
 #include "base/format_macros.h"
 #include "base/i18n/break_iterator.h"
@@ skipping 156 matching lines @@
 class RenderTextTest : public testing::Test {
 };
 
 TEST_F(RenderTextTest, DefaultStyle) {
   // Check the default styles applied to new instances and adjusted text.
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   EXPECT_TRUE(render_text->text().empty());
   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(SK_ColorBLACK));
+    EXPECT_TRUE(
+        render_text->baselines().EqualsValueForTesting(NORMAL_BASELINE));
     for (size_t style = 0; style < NUM_TEXT_STYLES; ++style)
       EXPECT_TRUE(render_text->styles()[style].EqualsValueForTesting(false));
     render_text->SetText(WideToUTF16(cases[i]));
   }
 }
 
 TEST_F(RenderTextTest, SetColorAndStyle) {
   // 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->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->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, ApplyColorAndStyle) {
   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));
   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));
 
-  // Ensure setting a color and style overrides the ranged colors and styles.
+  // Ensure setting a color, baseline, and style overrides the ranged colors,
+  // baseline, and styles.
   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));
 
-  // Apply a color and style over the text end and check the resulting breaks.
-  // (INT_MAX should be used instead of the text length for the range end)
+  // Apply a color, baseline, and style over the text end and check the
+  // resulting breaks  (INT_MAX should be used instead of the text length for

[msw, 2015/02/25 16:02:33]

nit: remove the extra space before the parens. You can optionally leave this
comment, and the one at line 237, as they were.

[dschuyler, 2015/02/26 02:11:02]

Done.

+  // 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));
   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));
 
   // 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;
@@ skipping 2305 matching lines @@
       EXPECT_LT(220U, color_utils::GetLuminanceForColor(color)) << string;
       for (int x = 1; x < kTestWidth; ++x) {
         color = buffer[width + x + y * kCanvasSize.width()];
         EXPECT_EQ(SK_ColorWHITE, color) << string;
       }
     }
   }
 }
 
 }  // namespace gfx