Fix ShapeResult::OffsetForPosition edge behavior

third_party/WebKit/Source/platform/fonts/shaping/ShapeResult.cpp

 /*
  * Copyright (c) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013 BlackBerry Limited. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 86 matching lines @@
       }
     }
   }
   return position;
 }
 
 int ShapeResult::RunInfo::CharacterIndexForXPosition(
     float target_x,
     bool include_partial_glyphs) const {
   DCHECK(target_x >= 0 && target_x <= width_);
+  if (target_x <= 0)
+    return !Rtl() ? 0 : num_characters_;
   const unsigned num_glyphs = glyph_data_.size();
   float current_x = 0;
   float current_advance = 0;
   unsigned glyph_index = 0;
   unsigned prev_character_index = num_characters_;  // used only when rtl()
 
   while (glyph_index < num_glyphs) {
     float prev_advance = current_advance;
     unsigned current_character_index = glyph_data_[glyph_index].character_index;
     current_advance = glyph_data_[glyph_index].advance;
     while (glyph_index < num_glyphs - 1 &&
            current_character_index ==
                glyph_data_[glyph_index + 1].character_index)
       current_advance += glyph_data_[++glyph_index].advance;
     float next_x;
     if (include_partial_glyphs) {
       // For hit testing, find the closest caret point by incuding
       // end-half of the previous character and start-half of the current
       // character.
       current_advance = current_advance / 2.0;
       next_x = current_x + prev_advance + current_advance;
+      // When include_partial_glyphs, "<=" or "<" is not a big deal because
+      // |next_x| is not at the character boundary.
+      if (target_x <= next_x)
+        return Rtl() ? prev_character_index : current_character_index;
     } else {
       next_x = current_x + current_advance;
+      if (!Rtl()) {

[eae, 2017/06/06 00:03:54]

How about

static bool targetPastEdge(bool rtl, float target_x, float next_x) {
  // In RTL, the edge belongs to the character on left.
  if (rtl)
    return target_x <= next_x;
  
  // In LTR, the edge belongs to the character on right.
  return target_x < next_x; 
}

if (targetPastEdge(Rtl(), target_x, next_x)
 return current_character_index;

+        // In LTR, the edge belongs to the character on right.
+        if (target_x < next_x)
+          return current_character_index;
+      } else {
+        // In RTL, the edge belongs to the character on left.
+        if (target_x <= next_x)
+          return current_character_index;
+      }
     }
-    if (current_x <= target_x && target_x <= next_x)
-      return include_partial_glyphs && Rtl() ? prev_character_index
-                                             : current_character_index;
     current_x = next_x;
     prev_character_index = current_character_index;
     ++glyph_index;
   }
 
   return Rtl() ? 0 : num_characters_;
 }
 
 void ShapeResult::RunInfo::SetGlyphAndPositions(unsigned index,
                                                 uint16_t glyph_id,
@@ skipping 341 matching lines @@
   result->width_ = run->width_;
   result->num_glyphs_ = count;
   DCHECK_EQ(result->num_glyphs_, count);  // no overflow
   result->has_vertical_offsets_ =
       font_data->PlatformData().IsVerticalAnyUpright();
   result->runs_.push_back(std::move(run));
   return result.Release();
 }
 
 }  // namespace blink