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
+  // 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 2289 matching lines @@
   render_text->SetColor(SK_ColorBLACK);
 
   for (auto string : kTestStrings) {
     surface->getCanvas()->clear(SK_ColorWHITE);
     render_text->SetText(WideToUTF16(string));
     render_text->SetStyle(BOLD, true);
     render_text->Draw(canvas.get());
     int width = render_text->GetStringSize().width();
     ASSERT_LT(width + kTestWidth, kCanvasSize.width());
     const uint32* buffer = static_cast<const uint32*>(
         surface->peekPixels(NULL, NULL));

[msw, 2015/02/26 03:36:54]

nit: nullptr

[dschuyler, 2015/02/26 23:15:55]

Done.

     ASSERT_NE(nullptr, buffer);
 
     for (int y = 0; y < kCanvasSize.height(); ++y) {
       // Allow one column of anti-aliased pixels past the expected width.
       SkColor color = buffer[width + y * kCanvasSize.width()];
       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;
       }
     }
   }
 }
 
+// Ensure that the width reported by RenderText is sufficient for drawing. Draws
+// to a canvas and checks whether any pixel beyond the bounding rectangle is
+// colored.
+TEST_F(RenderTextTest, TextBaselineStyleDoesntClip) {

[msw, 2015/02/26 03:36:53]

It might be nice to combine the two tests, or maybe extract some helpers.

[dschuyler, 2015/02/26 23:15:55]

I realized that TextDoesntClipt was a subset of TextBaselineDoesntClip while
looking at consolidating them.
A test for TextDoesClip has also been added.

+  const wchar_t* kTestStrings[] = {
+      L"TEST_______",
+      L"WWWWWWWWWW",
+      L"gAXAXAXAXAXAXA",
+      L"g\x00C5X\x00C5X\x00C5X\x00C5X\x00C5X\x00C5X\x00C5",
+      L"\x0647\x0654\x0647\x0654\x0647\x0654\x0647\x0654\x0645\x0631\x062D"
+      L"\x0628\x0627"};
+  const Size kCanvasSize(300, 50);
+  const int kTestSize = 10;
+
+  skia::RefPtr<SkSurface> surface = skia::AdoptRef(
+      SkSurface::NewRasterN32Premul(kCanvasSize.width(), kCanvasSize.height()));
+  scoped_ptr<Canvas> canvas(
+      Canvas::CreateCanvasWithoutScaling(surface->getCanvas(), 1.0f));
+  scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
+  render_text->SetDisplayRect(Rect(kCanvasSize));
+  render_text->SetHorizontalAlignment(gfx::ALIGN_LEFT);

[msw, 2015/02/26 03:36:53]

nit: you can remove all gfx:: qualifiers in this test.

[dschuyler, 2015/02/26 23:15:55]

Done.

+  render_text->SetColor(SK_ColorBLACK);
+
+  for (auto string : kTestStrings) {
+    surface->getCanvas()->clear(SK_ColorWHITE);
+    render_text->SetText(WideToUTF16(string));
+    render_text->ApplyBaselineStyle(SUPERSCRIPT, gfx::Range(1, 2));
+    render_text->ApplyBaselineStyle(SUPERIOR, gfx::Range(3, 4));
+    render_text->ApplyBaselineStyle(INFERIOR, gfx::Range(5, 6));
+    render_text->ApplyBaselineStyle(SUBSCRIPT, gfx::Range(7, 8));
+    render_text->SetStyle(BOLD, true);
+    render_text->SetDisplayRect(
+        Rect(kTestSize, 0, kCanvasSize.width() - kTestSize,

[msw, 2015/02/26 03:36:54]

Shouldn't the width be render_text->GetStringSize().width() + kTestSize * 2?

[dschuyler, 2015/02/26 23:15:55]

If the intent were to clip to the rect, yes.  The intent was just to avoid going
off of the canvas.  It's good for this test to allow freedom to expose errors.  

The reason I was using the * 2 on the height is because I don't know a way to
control the vertical alignment other than manipulating the rect.  It would be
much nicer if I could simply vertically align top, for example.

+             render_text->GetStringSize().height() + kTestSize * 2));
+#if 1
+    // REMOVE(dschuyler): This should be removed because it creates a fake
+    // success for this test by clipping the text.
+    render_text->SetDisplayRect(Rect(kTestSize, kTestSize,
+                                     kCanvasSize.width() - kTestSize,
+                                     render_text->GetStringSize().height()));
+#endif
+    render_text->Draw(canvas.get());
+    int width = render_text->GetStringSize().width();
+    ASSERT_LT(width + kTestSize, kCanvasSize.width());
+    const uint32* buffer =
+        static_cast<const uint32*>(surface->peekPixels(NULL, NULL));

[msw, 2015/02/26 03:36:53]

nit: nullptr

[dschuyler, 2015/02/26 23:15:55]

Done.

+    ASSERT_NE(nullptr, buffer);
+    // Top side.
+    for (int y = 0; y < kTestSize; ++y) {

[msw, 2015/02/26 03:36:53]

I don't think you can assume the text will be vertically centered like this
because RenderText uses cap-height centering. If the internal leading and the
descent (descender + external leading?) are not equal, the text's vertical
position will not match these expectations, afaik. Maybe try something like:
  // Allow the RenderText to paint outside of its display rect. (you should
verify that this really still works as advertised, maybe set a super small
display rect and ensure text is painted outside that rect)
  render_text->set_clip_to_display_rect(false);
  // Set the text size to exactly what the RenderText requests (maybe smaller or
0 size to ensure the above flag works).
  Rect text_rect(kTestSize, kTestSize, render_text->GetStringSize().width(),
render_text->GetStringSize().height())
  render_text->SetDisplayRect(text_rect);

  // Ensure nothing is painted outside of the following rects (x, y, w, h):
  EnsureSolidRect(SK_ColorWHITE, 0, 0, kCanvasSize.width(), kTestSize);  // top
  EnsureSolidRect(SK_ColorWHITE, 0, text_rect.bottom(), kCanvasSize.width(),
kTestSize);  // bottom
  EnsureSolidRect(SK_ColorWHITE, 0, 0, kTestSize, kCanvasSize.height()); // left
  EnsureSolidRect(SK_ColorWHITE, text_rect.right() + 1?, 0, kTestSize,
kCanvasSize.height()); // right (with 1 px for AA)
  // Ensure the pixel just right of the rect only contains AA pixels...

[dschuyler, 2015/02/26 23:15:55]

Thanks for pointing out the clip to display rect false call.


Done.

+      for (int x = 0; x < kCanvasSize.width(); ++x) {
+        SkColor color = buffer[x + y * kCanvasSize.width()];
+        EXPECT_EQ(SK_ColorWHITE, color) << string << " at " << x << ", " << y;
+      }
+    }
+    // Bottom side.
+    int underside = (kTestSize + render_text->GetStringSize().height());
+    for (int y = underside; y < underside + kTestSize; ++y) {
+      for (int x = 0; x < kCanvasSize.width(); ++x) {
+        SkColor color = buffer[x + y * kCanvasSize.width()];
+        EXPECT_EQ(SK_ColorWHITE, color) << string << " at " << x << ", " << y;
+      }
+    }
+    // Left side.
+    for (int y = 0; y < kCanvasSize.height(); ++y) {
+      int current_y = y * kCanvasSize.width();
+      SkColor color;
+      for (int x = 0; x < kTestSize; ++x) {
+        color = buffer[x + current_y];
+        EXPECT_EQ(SK_ColorWHITE, color) << string << " at " << x << ", " << y;
+      }
+    }
+    // Right side.
+    for (int y = 0; y < kCanvasSize.height(); ++y) {
+      // Allow one column of anti-aliased pixels past the expected width.
+      SkColor color = buffer[kTestSize + width + y * kCanvasSize.width()];
+      EXPECT_LT(220U, color_utils::GetLuminanceForColor(color)) << string;
+      for (int x = 1; x < kTestSize; ++x) {
+        color = buffer[kTestSize + width + x + y * kCanvasSize.width()];
+        EXPECT_EQ(SK_ColorWHITE, color) << string << " at " << x << ", " << y;
+      }
+    }
+  }
+}
+
 }  // namespace gfx