Support float widths in RenderTextHarfBuzz.

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 <map>
 
 #include "base/debug/leak_annotations.h"
 #include "base/i18n/bidi_line_iterator.h"
@@ skipping 415 matching lines @@
   DCHECK(!chars->is_empty());
   DCHECK(!glyphs->is_reversed());
   DCHECK(!glyphs->is_empty());
 }
 
 }  // namespace
 
 namespace internal {
 
 TextRunHarfBuzz::TextRunHarfBuzz()
-    : width(0),
-      preceding_run_widths(0),
+    : 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),
       diagonal_strike(false),
       underline(false) {}
 
@@ skipping 42 matching lines @@
   size_t missing = 0;
   for (size_t i = 0; i < glyph_count; ++i)
     missing += (glyphs[i] == kMissingGlyphId) ? 1 : 0;
   return missing;
 }
 
 Range 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, preceding_run_widths + width);
+    return Range(preceding_run_widths_int, preceding_run_widths_int + 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;
 
   // 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
@@ skipping 13 matching lines @@
     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 + grapheme_begin_x,
-                   preceding_run_widths + grapheme_end_x);
+      return Range(preceding_run_widths_int + grapheme_begin_x,
+                   preceding_run_widths_int + grapheme_end_x);
     }
   }
 
-  return Range(preceding_run_widths + cluster_begin_x,
-               preceding_run_widths + cluster_end_x);
+  return Range(preceding_run_widths_int + cluster_begin_x,
+               preceding_run_widths_int + cluster_end_x);
 }
 
 }  // namespace internal
 
 RenderTextHarfBuzz::RenderTextHarfBuzz()
     : RenderText(),
       needs_layout_(false) {}
 
 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;
   size_t run_index = GetRunContainingXCoord(x, &offset);
@@ skipping 219 matching lines @@
           base::i18n::BreakIterator::BREAK_CHARACTER));
       if (!grapheme_iterator_->Init())
         grapheme_iterator_.reset();
 
       ItemizeText();
 
       for (size_t i = 0; i < runs_.size(); ++i)
         ShapeRun(runs_[i]);
 
       // Precalculate run width information.
-      size_t preceding_run_widths = 0;
+      float preceding_run_widths = 0.0f;
       for (size_t i = 0; i < runs_.size(); ++i) {
         internal::TextRunHarfBuzz* run = runs_[visual_to_logical_[i]];
         run->preceding_run_widths = preceding_run_widths;
         preceding_run_widths += run->width;
       }
     }
 
     needs_layout_ = false;
     std::vector<internal::Line> empty_lines;
     set_lines(&empty_lines);
@@ skipping 16 matching lines @@
       segment.run = i;
       lines[0].segments.push_back(segment);
 
       paint.setTypeface(run.skia_face.get());
       paint.setTextSize(run.font_size);
       SkPaint::FontMetrics metrics;
       paint.getFontMetrics(&metrics);
 
       lines[0].size.set_width(lines[0].size.width() + run.width);
       lines[0].size.set_height(std::max(lines[0].size.height(),
-          SkScalarRoundToInt(metrics.fDescent - metrics.fAscent)));
+                                        metrics.fDescent - metrics.fAscent));
       lines[0].baseline = std::max(lines[0].baseline,
                                    SkScalarRoundToInt(-metrics.fAscent));
     }
 
     set_lines(&lines);
   }
 }
 
 void RenderTextHarfBuzz::DrawVisualText(Canvas* canvas) {
   DCHECK(!needs_layout_);
@@ skipping 224 matching lines @@
       best_font = current_font;
     }
   }
 
   if (!best_font.empty() &&
       (best_font == current_font || ShapeRunWithFont(run, best_font))) {
     return;
   }
 
   run->glyph_count = 0;
-  run->width = 0;
+  run->width = 0.0f;
 }
 
 bool RenderTextHarfBuzz::ShapeRunWithFont(internal::TextRunHarfBuzz* run,
                                           const std::string& font_family) {
   const base::string16& text = GetLayoutText();
   skia::RefPtr<SkTypeface> skia_face =
       internal::CreateSkiaTypeface(font_family, run->font_style);
   if (skia_face == NULL)
     return false;
   run->skia_face = skia_face;
@@ skipping 17 matching lines @@
 
   // Populate the run fields with the resulting glyph data in the buffer.
   unsigned int glyph_count = 0;
   hb_glyph_info_t* infos = hb_buffer_get_glyph_infos(buffer, &glyph_count);
   run->glyph_count = glyph_count;
   hb_glyph_position_t* hb_positions =
       hb_buffer_get_glyph_positions(buffer, NULL);
   run->glyphs.reset(new uint16[run->glyph_count]);
   run->glyph_to_char.resize(run->glyph_count);
   run->positions.reset(new SkPoint[run->glyph_count]);
-  run->width = 0;
+  run->width = 0.0f;
   for (size_t i = 0; i < run->glyph_count; ++i) {
     run->glyphs[i] = infos[i].codepoint;
     run->glyph_to_char[i] = infos[i].cluster;
-    const int x_offset =
-        SkScalarRoundToInt(SkFixedToScalar(hb_positions[i].x_offset));
-    const int y_offset =
-        SkScalarRoundToInt(SkFixedToScalar(hb_positions[i].y_offset));
+    const int x_offset = SkFixedToScalar(hb_positions[i].x_offset);
+    const int y_offset = SkFixedToScalar(hb_positions[i].y_offset);
     run->positions[i].set(run->width + x_offset, -y_offset);
-    run->width +=
-        SkScalarRoundToInt(SkFixedToScalar(hb_positions[i].x_advance));
+    run->width += SkFixedToScalar(hb_positions[i].x_advance);
   }
 
   hb_buffer_destroy(buffer);
   hb_font_destroy(harfbuzz_font);
   return true;
 }
 
 }  // namespace gfx