adding baseline options for super/sub scripting

ui/gfx/render_text_harfbuzz.cc

 // Copyright 2014 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_harfbuzz.h"
 
 #include <limits>
 
 #include "base/i18n/bidi_line_iterator.h"
 #include "base/i18n/break_iterator.h"
@@ skipping 455 matching lines @@
 }
 
 TextRunHarfBuzz::TextRunHarfBuzz()
     : width(0.0f),
       preceding_run_widths(0.0f),
       is_rtl(false),
       level(0),
       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),
       underline(false) {}
 
 TextRunHarfBuzz::~TextRunHarfBuzz() {}
 
 void TextRunHarfBuzz::GetClusterAt(size_t pos,
                                    Range* chars,
                                    Range* glyphs) const {
@@ skipping 474 matching lines @@
                                    background_is_transparent());
       Range glyphs_range = run.CharRangeToGlyphRange(segment.char_range);
       scoped_ptr<SkPoint[]> positions(new SkPoint[glyphs_range.length()]);
       SkScalar offset_x =
           preceding_segment_widths - run.positions[glyphs_range.start()].x();
       for (size_t j = 0; j < glyphs_range.length(); ++j) {
         positions[j] = run.positions[(glyphs_range.is_reversed()) ?
                                      (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());
            it != colors().breaks().end() &&
                it->first < segment.char_range.end();
            ++it) {
         const Range intersection =
             colors().GetRange(it).Intersect(segment.char_range);
         const Range colored_glyphs = run.CharRangeToGlyphRange(intersection);
         // The range may be empty if a portion of a multi-character grapheme is
@@ skipping 88 matching lines @@
     return;
   }
 
   // Temporarily apply composition underlines and selection colors.
   ApplyCompositionAndSelectionStyles();
 
   // Build the list of runs from the script items and ranged styles. Use an
   // 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);
 
     int32 script_item_break = 0;
     bidi_iterator.GetLogicalRun(run_break, &script_item_break, &run->level);
     // Odd BiDi embedding levels correspond to RTL runs.
     run->is_rtl = (run->level % 2) == 1;
     // Find the length and script of this script run.
     script_item_break = ScriptInterval(text, run_break,
@@ skipping 46 matching lines @@
     *best_render_params = render_params;
     *best_missing_glyphs = missing_glyphs;
   }
   return missing_glyphs == 0;
 }
 
 void RenderTextHarfBuzz::ShapeRun(internal::TextRunHarfBuzz* run) {
   const Font& primary_font = font_list().GetPrimaryFont();
   const std::string primary_family = primary_font.GetFontName();
   run->font_size = primary_font.GetFontSize();
+  if (run->baseline_type) {

[msw, 2015/02/18 17:07:23]

nit: explicitly compare if (run->baseline_type != NORMAL_BASELINE) {

[dschuyler, 2015/02/18 22:36:03]

Done.

+    // 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);
+    int cap_height = round(primary_font.GetCapHeight() * ratio);
+    switch (run->baseline_type) {

[msw, 2015/02/18 17:07:23]

nit: I think you'll need a default case or explicitly handle each of the enum
values (including NUM_BASELINE_STYLES), or you'll probably get clang warnings or
similar compiler errors on some bots.

[dschuyler, 2015/02/18 22:36:03]

I moved the INFERIOR case to fall through to the new default case.

Done.

+      case SUPERSCRIPT:
+        run->baseline_offset =
+            primary_font.GetCapHeight() - primary_font.GetHeight();
+        break;
+      case SUPERIOR:
+        run->baseline_offset = cap_height - primary_font.GetCapHeight();
+        break;
+      case INFERIOR:
+        run->baseline_offset = 0;
+        break;
+      case SUBSCRIPT:
+        run->baseline_offset =
+            primary_font.GetHeight() - primary_font.GetBaseline();
+        break;
+    }
+  }
 
   std::string best_family;
   FontRenderParams best_render_params;
   size_t best_missing_glyphs = std::numeric_limits<size_t>::max();
 
   for (const Font& font : font_list().GetFonts()) {
     if (CompareFamily(run, font.GetFontName(), font.GetFontRenderParams(),
                       &best_family, &best_render_params, &best_missing_glyphs))
       return;
   }
@@ skipping 162 matching lines @@
     if (!run->render_params.subpixel_positioning)
       run->width = std::floor(run->width + 0.5f);
   }
 
   hb_buffer_destroy(buffer);
   hb_font_destroy(harfbuzz_font);
   return true;
 }
 
 }  // namespace gfx