Enable subpixel positioning for UI

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 <map>
 
 #include "base/i18n/bidi_line_iterator.h"
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/char_iterator.h"
 #include "base/lazy_instance.h"
 #include "third_party/harfbuzz-ng/src/hb.h"
 #include "third_party/icu/source/common/unicode/ubidi.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font_fallback.h"
 #include "ui/gfx/font_render_params.h"
 #include "ui/gfx/utf16_indexing.h"
 
 #if defined(OS_WIN)
 #include "ui/gfx/font_fallback_win.h"
 #endif
 
+using gfx::internal::RangeF;
+using gfx::internal::RoundRangeF;
+
 namespace gfx {
 
 namespace {
 
 // Text length limit. Longer strings are slow and not fully tested.
 const size_t kMaxTextLength = 10000;
 
 // The maximum number of scripts a Unicode character can belong to. This value
 // is arbitrarily chosen to be a good limit because it is unlikely for a single
 // character to belong to more scripts.
@@ skipping 416 matching lines @@
   DCHECK(!chars->is_reversed());
   DCHECK(!chars->is_empty());
   DCHECK(!glyphs->is_reversed());
   DCHECK(!glyphs->is_empty());
 }
 
 }  // namespace
 
 namespace internal {
 
+Range RoundRangeF(const RangeF& range_f) {
+  return Range(std::round(range_f.first), std::round(range_f.second));
+}
+
 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),
       font_style(0),
       strike(false),
@@ skipping 41 matching lines @@
 }
 
 size_t TextRunHarfBuzz::CountMissingGlyphs() const {
   static const int kMissingGlyphId = 0;
   size_t missing = 0;
   for (size_t i = 0; i < glyph_count; ++i)
     missing += (glyphs[i] == kMissingGlyphId) ? 1 : 0;
   return missing;
 }
 
-Range TextRunHarfBuzz::GetGraphemeBounds(
+RangeF TextRunHarfBuzz::GetGraphemeBounds(
     base::i18n::BreakIterator* grapheme_iterator,
     size_t text_index) {
   DCHECK_LT(text_index, range.end());
-  // TODO(msw): Support floating point grapheme bounds.
-  const int preceding_run_widths_int = SkScalarRoundToInt(preceding_run_widths);
   if (glyph_count == 0)
-    return Range(preceding_run_widths_int, preceding_run_widths_int + width);
+    return RangeF(preceding_run_widths, preceding_run_widths + width);
 
   Range chars;
   Range glyphs;
   GetClusterAt(text_index, &chars, &glyphs);
-  const int cluster_begin_x = SkScalarRoundToInt(positions[glyphs.start()].x());
-  const int cluster_end_x = glyphs.end() < glyph_count ?
-      SkScalarRoundToInt(positions[glyphs.end()].x()) : width;
+  const float cluster_begin_x = positions[glyphs.start()].x();
+  const float cluster_end_x = glyphs.end() < glyph_count ?
+      positions[glyphs.end()].x() : SkFloatToScalar(width);
 
   // A cluster consists of a number of code points and corresponds to a number
   // of glyphs that should be drawn together. A cluster can contain multiple
   // graphemes. In order to place the cursor at a grapheme boundary inside the
   // cluster, we simply divide the cluster width by the number of graphemes.
   if (chars.length() > 1 && grapheme_iterator) {
     int before = 0;
     int total = 0;
     for (size_t i = chars.start(); i < chars.end(); ++i) {
       if (grapheme_iterator->IsGraphemeBoundary(i)) {
         if (i < text_index)
           ++before;
         ++total;
       }
     }
     DCHECK_GT(total, 0);
     if (total > 1) {
       if (is_rtl)
         before = total - before - 1;
       DCHECK_GE(before, 0);
       DCHECK_LT(before, total);
       const int cluster_width = cluster_end_x - cluster_begin_x;
       const int grapheme_begin_x = cluster_begin_x + static_cast<int>(0.5f +
           cluster_width * before / static_cast<float>(total));
       const int grapheme_end_x = cluster_begin_x + static_cast<int>(0.5f +
           cluster_width * (before + 1) / static_cast<float>(total));
-      return Range(preceding_run_widths_int + grapheme_begin_x,
-                   preceding_run_widths_int + grapheme_end_x);
+      return RangeF(preceding_run_widths + grapheme_begin_x,
+                    preceding_run_widths + grapheme_end_x);
     }
   }
 
-  return Range(preceding_run_widths_int + cluster_begin_x,
-               preceding_run_widths_int + cluster_end_x);
+  return RangeF(preceding_run_widths + cluster_begin_x,
+                preceding_run_widths + cluster_end_x);
 }
 
 }  // namespace internal
 
 RenderTextHarfBuzz::RenderTextHarfBuzz()
     : RenderText(),
       needs_layout_(false) {
   set_truncate_length(kMaxTextLength);
 }
 
 RenderTextHarfBuzz::~RenderTextHarfBuzz() {}
 
 Size RenderTextHarfBuzz::GetStringSize() {
   const SizeF size_f = GetStringSizeF();
   return Size(std::ceil(size_f.width()), size_f.height());
 }
 
 SizeF RenderTextHarfBuzz::GetStringSizeF() {
   EnsureLayout();
   return lines()[0].size;
 }
 
 SelectionModel RenderTextHarfBuzz::FindCursorPosition(const Point& point) {
   EnsureLayout();
 
   int x = ToTextPoint(point).x();
-  int offset = 0;
+  float offset = 0;
   size_t run_index = GetRunContainingXCoord(x, &offset);
   if (run_index >= runs_.size())
     return EdgeSelectionModel((x < 0) ? CURSOR_LEFT : CURSOR_RIGHT);
   const internal::TextRunHarfBuzz& run = *runs_[run_index];
 
   for (size_t i = 0; i < run.glyph_count; ++i) {
     const SkScalar end =
         i + 1 == run.glyph_count ? run.width : run.positions[i + 1].x();
     const SkScalar middle = (end + run.positions[i].x()) / 2;
 
@@ skipping 29 matching lines @@
 
 Range RenderTextHarfBuzz::GetGlyphBounds(size_t index) {
   EnsureLayout();
   const size_t run_index =
       GetRunContainingCaret(SelectionModel(index, CURSOR_FORWARD));
   // Return edge bounds if the index is invalid or beyond the layout text size.
   if (run_index >= runs_.size())
     return Range(GetStringSize().width());
   const size_t layout_index = TextIndexToLayoutIndex(index);
   internal::TextRunHarfBuzz* run = runs_[run_index];
-  Range bounds = run->GetGraphemeBounds(grapheme_iterator_.get(), layout_index);
-  return run->is_rtl ? Range(bounds.end(), bounds.start()) : bounds;
+  RangeF bounds =
+      run->GetGraphemeBounds(grapheme_iterator_.get(), layout_index);
+  if (cursor_enabled() && run_index == runs_.size() - 1 &&
+      index == (run->is_rtl ? run->range.start() : run->range.end() - 1))
+    bounds.second = std::ceil(bounds.second);

[msw, 2014/11/24 21:51:00]

Add a comment here explaining why this is necessary. Should this also std::floor
the bounds.first for the leftmost char in RTL when the cursor is enabled?

[ckocagil, 2014/11/25 01:39:47]

Done.
Do you mean visually leftmost or logically? We handle visually rightmost for
both RTL and LTR. Visually leftmost isn't a problem since the first glyph always
starts at 0.

[msw, 2014/11/25 04:52:05]

Acknowledged.

+  return RoundRangeF(run->is_rtl ?
+      RangeF(bounds.second, bounds.first) : bounds);
 }
 
 int RenderTextHarfBuzz::GetLayoutTextBaseline() {
   EnsureLayout();
   return lines()[0].baseline;
 }
 
 SelectionModel RenderTextHarfBuzz::AdjacentCharSelectionModel(
     const SelectionModel& selection,
     VisualCursorDirection direction) {
@@ skipping 110 matching lines @@
     return rects;
   std::vector<Range> bounds;
 
   // Add a Range for each run/selection intersection.
   for (size_t i = 0; i < runs_.size(); ++i) {
     internal::TextRunHarfBuzz* run = runs_[visual_to_logical_[i]];
     Range intersection = run->range.Intersect(layout_range);
     if (!intersection.IsValid())
       continue;
     DCHECK(!intersection.is_reversed());
-    const Range leftmost_character_x = run->GetGraphemeBounds(
+    const Range leftmost_character_x = RoundRangeF(run->GetGraphemeBounds(
         grapheme_iterator_.get(),
-        run->is_rtl ? intersection.end() - 1 : intersection.start());
-    const Range rightmost_character_x = run->GetGraphemeBounds(
+        run->is_rtl ? intersection.end() - 1 : intersection.start()));
+    const Range rightmost_character_x = RoundRangeF(run->GetGraphemeBounds(
         grapheme_iterator_.get(),
-        run->is_rtl ? intersection.start() : intersection.end() - 1);
+        run->is_rtl ? intersection.start() : intersection.end() - 1));
     Range range_x(leftmost_character_x.start(), rightmost_character_x.end());
     DCHECK(!range_x.is_reversed());
     if (range_x.is_empty())
       continue;
 
     // Union this with the last range if they're adjacent.
     DCHECK(bounds.empty() || bounds.back().GetMax() <= range_x.GetMin());
     if (!bounds.empty() && bounds.back().GetMax() == range_x.GetMin()) {
       range_x = Range(bounds.back().GetMin(), range_x.GetMax());
       bounds.pop_back();
@@ skipping 102 matching lines @@
   }
 }
 
 void RenderTextHarfBuzz::DrawVisualText(Canvas* canvas) {
   DCHECK(!needs_layout_);
   internal::SkiaTextRenderer renderer(canvas);
   ApplyFadeEffects(&renderer);
   ApplyTextShadows(&renderer);
   ApplyCompositionAndSelectionStyles();
 
-  int current_x = 0;
   const Vector2d line_offset = GetLineOffset(0);
   for (size_t i = 0; i < runs_.size(); ++i) {
     const internal::TextRunHarfBuzz& run = *runs_[visual_to_logical_[i]];
     renderer.SetTypeface(run.skia_face.get());
     renderer.SetTextSize(SkIntToScalar(run.font_size));
     renderer.SetFontRenderParams(run.render_params,
                                  background_is_transparent());
 
-    Vector2d origin = line_offset + Vector2d(current_x, lines()[0].baseline);
+    Vector2d origin = line_offset + Vector2d(0, lines()[0].baseline);
     scoped_ptr<SkPoint[]> positions(new SkPoint[run.glyph_count]);
     for (size_t j = 0; j < run.glyph_count; ++j) {
       positions[j] = run.positions[j];
-      positions[j].offset(SkIntToScalar(origin.x()), SkIntToScalar(origin.y()));
+      positions[j].offset(SkIntToScalar(origin.x()) + run.preceding_run_widths,
+                          SkIntToScalar(origin.y()));
     }
 
     for (BreakList<SkColor>::const_iterator it =
              colors().GetBreak(run.range.start());
          it != colors().breaks().end() && it->first < run.range.end();
          ++it) {
       const Range intersection = colors().GetRange(it).Intersect(run.range);
       const Range colored_glyphs = run.CharRangeToGlyphRange(intersection);
       // The range may be empty if a portion of a multi-character grapheme is
       // selected, yielding two colors for a single glyph. For now, this just
       // paints the glyph with a single style, but it should paint it twice,
       // clipped according to selection bounds. See http://crbug.com/366786
       if (colored_glyphs.is_empty())
         continue;
 
       renderer.SetForegroundColor(it->second);
       renderer.DrawPosText(&positions[colored_glyphs.start()],
                            &run.glyphs[colored_glyphs.start()],
                            colored_glyphs.length());
       int start_x = SkScalarRoundToInt(positions[colored_glyphs.start()].x());
       int end_x = SkScalarRoundToInt((colored_glyphs.end() == run.glyph_count) ?
-          (run.width + SkIntToScalar(origin.x())) :
+          (run.width + run.preceding_run_widths + SkIntToScalar(origin.x())) :
           positions[colored_glyphs.end()].x());
       renderer.DrawDecorations(start_x, origin.y(), end_x - start_x,
                                run.underline, run.strike, run.diagonal_strike);
     }
-
-    current_x += run.width;
   }
 
   renderer.EndDiagonalStrike();
 
   UndoCompositionAndSelectionStyles();
 }
 
 size_t RenderTextHarfBuzz::GetRunContainingCaret(
     const SelectionModel& caret) const {
   DCHECK(!needs_layout_);
   size_t layout_position = TextIndexToLayoutIndex(caret.caret_pos());
   LogicalCursorDirection affinity = caret.caret_affinity();
   for (size_t run = 0; run < runs_.size(); ++run) {
     if (RangeContainsCaret(runs_[run]->range, layout_position, affinity))
       return run;
   }
   return runs_.size();
 }
 
-size_t RenderTextHarfBuzz::GetRunContainingXCoord(int x, int* offset) const {
+size_t RenderTextHarfBuzz::GetRunContainingXCoord(float x,
+                                                  float* offset) const {
   DCHECK(!needs_layout_);
   if (x < 0)
     return runs_.size();
   // Find the text run containing the argument point (assumed already offset).
-  int current_x = 0;
+  float current_x = 0;
   for (size_t i = 0; i < runs_.size(); ++i) {
     size_t run = visual_to_logical_[i];
     current_x += runs_[run]->width;
     if (x < current_x) {
       *offset = x - (current_x - runs_[run]->width);
       return run;
     }
   }
   return runs_.size();
 }
@@ skipping 141 matching lines @@
   // Append fonts in the fallback list of the Uniscribe font.
   if (!uniscribe_family.empty()) {
     std::vector<std::string> uniscribe_fallbacks =
         GetFallbackFontFamilies(uniscribe_family);
     fallback_families.insert(fallback_families.end(),
         uniscribe_fallbacks.begin(), uniscribe_fallbacks.end());
   }
 #endif
 
   // Try shaping with the fallback fonts.
-  for (auto family : fallback_families) {
+  for (const auto& family : fallback_families) {
     if (family == primary_family)
       continue;
 #if defined(OS_WIN)
     if (family == uniscribe_family)
       continue;
 #endif
     FontRenderParamsQuery query(false);
     query.families.push_back(family);
     query.pixel_size = run->font_size;
     query.style = run->font_style;
@@ skipping 64 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