Fix the Char to Glyph mapping logic 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/i18n/bidi_line_iterator.h"
 #include "base/i18n/break_iterator.h"
@@ skipping 375 matching lines @@
       strike(false),
       diagonal_strike(false),
       underline(false) {}
 
 TextRunHarfBuzz::~TextRunHarfBuzz() {}
 
 size_t TextRunHarfBuzz::CharToGlyph(size_t pos) const {
   DCHECK(range.start() <= pos && pos < range.end());
 
   if (!is_rtl) {
-    for (size_t i = 0; i < glyph_count - 1; ++i) {
-      if (pos < glyph_to_char[i + 1])
-        return i;
-    }
-    return glyph_count - 1;
+    size_t cluster_start = 0;
+    for (size_t i = 1; i < glyph_count && pos >= glyph_to_char[i]; ++i)
+      if (glyph_to_char[i] != glyph_to_char[i - 1])
+        cluster_start = i;
+    return cluster_start;
   }
 
   for (size_t i = 0; i < glyph_count; ++i) {
     if (pos >= glyph_to_char[i])
       return i;
   }
   NOTREACHED();
   return 0;
 }
 
-Range TextRunHarfBuzz::CharRangeToGlyphRange(const Range& range) const {
-  DCHECK(range.Contains(range));
-  DCHECK(!range.is_reversed());
-  DCHECK(!range.is_empty());
+Range TextRunHarfBuzz::CharRangeToGlyphRange(const Range& char_range) const {
+  DCHECK(range.Contains(char_range));
+  DCHECK(!char_range.is_reversed());
+  DCHECK(!char_range.is_empty());
 
-  const size_t first = CharToGlyph(range.start());
-  const size_t last = CharToGlyph(range.end() - 1);
-  // TODO(ckocagil): What happens when the character has zero or multiple
-  // glyphs? Is the "+ 1" below correct then?
-  return Range(std::min(first, last), std::max(first, last) + 1);
+  size_t first = 0;
+  size_t last = 0;
+
+  if (is_rtl) {
+    // For RTL runs, we subtract 1 from |char_range| to get the leading edges.
+    last = CharToGlyph(char_range.end() - 1);
+    // Loop until we find a non-empty glyph range. For multi-character clusters,
+    // the loop is needed to find the cluster end. Do the same for LTR below.
+    for (size_t i = char_range.start(); i > range.start(); --i) {
+      first = CharToGlyph(i - 1);
+      if (first != last)
+        return Range(last, first);
+    }
+    return Range(last, glyph_count);
+  }
+
+  first = CharToGlyph(char_range.start());
+  for (size_t i = char_range.end(); i < range.end(); ++i) {
+    last = CharToGlyph(i);
+    if (first != last)
+      return Range(first, last);
+  }
+  return Range(first, glyph_count);
 }
 
 // Returns whether the given shaped run contains any missing glyphs.
 bool TextRunHarfBuzz::HasMissingGlyphs() const {
   static const int kMissingGlyphId = 0;
   for (size_t i = 0; i < glyph_count; ++i) {
     if (glyphs[i] == kMissingGlyphId)
       return true;
   }
   return false;
@@ skipping 541 matching lines @@
     run->positions[i].set(run->width + x_offset, y_offset);
     run->width +=
         SkScalarRoundToInt(SkFixedToScalar(hb_positions[i].x_advance));
   }
 
   hb_buffer_destroy(buffer);
   hb_font_destroy(harfbuzz_font);
 }
 
 }  // namespace gfx