Fix the x-offset calculation when drawing the text.

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 942 matching lines @@
     const Vector2d origin = GetLineOffset(i) + Vector2d(0, line.baseline);
     SkScalar preceding_segment_widths = 0;
     for (const internal::LineSegment& segment : line.segments) {
       const internal::TextRunHarfBuzz& run = *runs_[segment.run];
       renderer.SetTypeface(run.skia_face.get());
       renderer.SetTextSize(SkIntToScalar(run.font_size));
       renderer.SetFontRenderParams(run.render_params,
                                    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();
+      SkScalar offset_x = preceding_segment_widths -

[msw, 2015/02/14 04:22:34]

Hmm, I wonder if this is actually correct, or if really should just be:
  SkScalar offset_x = preceding_segment_widths;
For single-line, there's one segment per run, so glyphs_range.start() is always
|0|, right? So, this is just adding run.positions[0].x() to the subtraction of
run.positions[0].x()... Can you debug and check if this is ever really untrue?

Otherwise, in the multi-line case, I could see why we'd subtract the position of
the first glyph in the range if the segment began mid-run (it didn't contain the
start of the run), because its run started on a previous line... In that case,
we'd want to keep the subtraction of run.positions[glyphs_range.start()].x(),
but not add the position of the first glyph... so maybe it's:
  SkScalar offset_x = preceding_segment_widths -
    (glyphs_range.start() > 0) ? run.positions[glyphs_range.start()].x() : 0;

Maybe Cem has a better idea of what's going on here...

[Jun Mukai, 2015/02/17 21:24:21]

Thanks, you are right. My intension was:
- if a segment starts from the beginning of a run, then, we should ignore the x
position because it's canceled below
- if a segment starts from the middle of a run (can happen in multi-line case),
then offset_x should consider the x-posistion from the beginning of the run,
this is essentially run.positions[glyphs_range.start()]

Done as you suggested.

+                          run.positions[glyphs_range.start()].x() +
+                          run.positions[0].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()));
       }
       for (BreakList<SkColor>::const_iterator it =
                colors().GetBreak(segment.char_range.start());
            it != colors().breaks().end() &&
@@ skipping 349 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