adding baseline options for super/sub scripting

ui/gfx/render_text_harfbuzz.cc

Index: ui/gfx/render_text_harfbuzz.cc
diff --git a/ui/gfx/render_text_harfbuzz.cc b/ui/gfx/render_text_harfbuzz.cc
index 51322161e5559adf9c7ce8d15dd6f8b0b4219ccc..8c0ab9a0a279b99e5e281012a96ce490c3b33b66 100644
--- a/ui/gfx/render_text_harfbuzz.cc
+++ b/ui/gfx/render_text_harfbuzz.cc
@@ -475,6 +475,8 @@ TextRunHarfBuzz::TextRunHarfBuzz()
       script(USCRIPT_INVALID_CODE),
       glyph_count(static_cast<size_t>(-1)),
       font_size(0),
+      baseline_offset(0),
+      baseline_type(0),
       font_style(0),
       strike(false),
       diagonal_strike(false),
@@ -1019,7 +1021,7 @@ void RenderTextHarfBuzz::DrawVisualText(Canvas* canvas) {
                                      (glyphs_range.start() - j) :
                                      (glyphs_range.start() + j)];
         positions[j].offset(SkIntToScalar(origin.x()) + offset_x,
-                            SkIntToScalar(origin.y()));
+                            SkIntToScalar(origin.y() + run.baseline_offset));
       }
       for (BreakList<SkColor>::const_iterator it =
                colors().GetBreak(segment.char_range.start());
@@ -1132,13 +1134,14 @@ void RenderTextHarfBuzz::ItemizeTextToRuns(
   // empty color BreakList to avoid breaking runs at color boundaries.
   BreakList<SkColor> empty_colors;
   empty_colors.SetMax(text.length());
-  internal::StyleIterator style(empty_colors, styles());
+  internal::StyleIterator style(empty_colors, baselines(), styles());
 
   for (size_t run_break = 0; run_break < text.length();) {
     internal::TextRunHarfBuzz* run = new internal::TextRunHarfBuzz;
     run->range.set_start(run_break);
     run->font_style = (style.style(BOLD) ? Font::BOLD : 0) |
                       (style.style(ITALIC) ? Font::ITALIC : 0);
+    run->baseline_type = style.baseline();
     run->strike = style.style(STRIKE);
     run->diagonal_strike = style.style(DIAGONAL_STRIKE);
     run->underline = style.style(UNDERLINE);
@@ -1207,6 +1210,30 @@ void RenderTextHarfBuzz::ShapeRun(const base::string16& text,
   const Font& primary_font = font_list().GetPrimaryFont();
   const std::string primary_family = primary_font.GetFontName();
   run->font_size = primary_font.GetFontSize();
+  run->baseline_offset = 0;
+  if (run->baseline_type != NORMAL_BASELINE) {
+    // Calculate a slightly smaller font. The ratio here is somewhat arbitrary.
+    // Proportions from 5/9 to 5/7 all look pretty good.
+    const float ratio = 5.0f / 9.0f;
+    run->font_size = round(primary_font.GetFontSize() * ratio);

[msw, 2015/02/18 23:32:08]

nit: I don't think round is commonly used in the Chromium codebase...
Perhaps use std::ceil(foo + 0.5) here and for SUPERIOR below?

[dschuyler, 2015/02/19 00:29:15]

That gets a bit confusing/less readable because it needs to be floor if less
than zero and ceil if greater or equal to zero.  Also, with ceil, the 0.5 would
need to be subtracted (which is weird looking).  Would you consider std::round
as a replacement for round()?  That way it's using the C++ call (and I find it
easier to read that ceil).

[msw, 2015/02/19 02:50:57]

std::round only seems to be used in 4 places in the codebase. I'm not sure why
that isn't used more widely, but it makes me hesitant to recommend its use...
Maybe use gfx::ToRoundedInt from ui/gfx/geometry/safe_integer_conversions.h. I
wonder what other places use that naive code snippet and have bugs for not
handling negative numbers correctly... +CC pkasting for advice.

[Peter Kasting, 2015/02/19 07:27:46]

std::round is C++11, and since we can't yet use the C++11 standard library, it's
out.  round(), without the std:: qualifier, is also C++11 AFAICT, but was in C99
and thus likely has such broad compiler support that the couple dozen places in
the codebase that reference it "happen to work".  ToRoundedInt() is probably the
best answer, and is nicer than round() anyway in that it clamps to an int for
you.  

Incidentally, some places in our code round away from zero (the default behavior
of round() and friends) while some round toward positive infinity ("floor(x +
0.5)").  This distinction may look like a bug, but at least in the spots I've
tried to "fix" it in the past, it turned out we were doing what we were because
of explicit specs to that effect, e.g. I guess CSS rounding is specified as
always being toward positive infinity.  Dumb.

[dschuyler, 2015/02/25 02:23:05]

Done.

+    switch (run->baseline_type) {
+      case SUPERSCRIPT:
+        run->baseline_offset =
+            primary_font.GetCapHeight() - primary_font.GetHeight();
+        break;
+      case SUPERIOR:
+        run->baseline_offset = round(primary_font.GetCapHeight() * ratio) -
+            primary_font.GetCapHeight();
+        break;
+      case SUBSCRIPT:
+        run->baseline_offset =
+            primary_font.GetHeight() - primary_font.GetBaseline();
+        break;
+      case INFERIOR: // fall through

[msw, 2015/02/18 23:32:08]

nit: trailing period.

[dschuyler, 2015/02/19 00:29:14]

Done.

+      default:
+        break;
+    }
+  }
 
   std::string best_family;
   FontRenderParams best_render_params;