Revert of Fix Views inline autocomplete with multi-char graphemes.

ui/gfx/render_text_pango.cc

 // Copyright (c) 2012 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_pango.h"
 
 #include <pango/pangocairo.h>
 #include <algorithm>
 #include <string>
 #include <vector>
@@ skipping 22 matching lines @@
 }
 
 // Returns true if the given visual cursor |direction| is logically forward
 // motion in the given Pango |item|.
 bool IsForwardMotion(VisualCursorDirection direction, const PangoItem* item) {
   bool rtl = item->analysis.level & 1;
   return rtl == (direction == CURSOR_LEFT);
 }
 
 // Checks whether |range| contains |index|. This is not the same as calling
-// range.Contains(Range(index)), which returns true if |index| == |range.end()|.
+// |range.Contains(gfx::Range(index))| - as that would return true when
+// |index| == |range.end()|.
 bool IndexInRange(const Range& range, size_t index) {
   return index >= range.start() && index < range.end();
 }
 
 // Sets underline metrics on |renderer| according to Pango font |desc|.
 void SetPangoUnderlineMetrics(PangoFontDescription *desc,
                               internal::SkiaTextRenderer* renderer) {
   PangoFontMetrics* metrics = GetPangoFontMetrics(desc);
   int thickness = pango_font_metrics_get_underline_thickness(metrics);
   // Pango returns the position "above the baseline". Change its sign to convert
@@ skipping 187 matching lines @@
     Rect rect(x, 0, width, height);
     rect.set_origin(ToViewPoint(rect.origin()));
     bounds.push_back(rect);
   }
   g_free(ranges);
   return bounds;
 }
 
 size_t RenderTextPango::TextIndexToLayoutIndex(size_t index) const {
   DCHECK(layout_);
-  ptrdiff_t offset = UTF16IndexToOffset(text(), 0, index);
+  ptrdiff_t offset = gfx::UTF16IndexToOffset(text(), 0, index);
   // Clamp layout indices to the length of the text actually used for layout.
   offset = std::min<size_t>(offset, g_utf8_strlen(layout_text_, -1));
   const char* layout_pointer = g_utf8_offset_to_pointer(layout_text_, offset);
   return (layout_pointer - layout_text_);
 }
 
 size_t RenderTextPango::LayoutIndexToTextIndex(size_t index) const {
   DCHECK(layout_);
   const char* layout_pointer = layout_text_ + index;
   const long offset = g_utf8_pointer_to_offset(layout_text_, layout_pointer);
-  return UTF16OffsetToIndex(text(), 0, offset);
+  return gfx::UTF16OffsetToIndex(text(), 0, offset);
 }
 
-bool RenderTextPango::IsValidCursorIndex(size_t index) {
-  if (index == 0 || index == text().length())
+bool RenderTextPango::IsCursorablePosition(size_t position) {
+  if (position == 0 && text().empty())
     return true;
-  if (!IsValidLogicalIndex(index))
+  if (position >= text().length())
+    return position == text().length();
+  if (!gfx::IsValidCodePointIndex(text(), position))
     return false;
 
   EnsureLayout();
-  ptrdiff_t offset = UTF16IndexToOffset(text(), 0, index);
-  // Check that the index is marked as a legitimate cursor position by Pango.
-  return offset < num_log_attrs_ && log_attrs_[offset].is_cursor_position;
+  ptrdiff_t offset = gfx::UTF16IndexToOffset(text(), 0, position);
+  // Check that the index corresponds with a valid text code point, that it is
+  // marked as a legitimate cursor position by Pango, and that it is not
+  // truncated from layout text (its glyph is shown on screen).
+  return (offset < num_log_attrs_ && log_attrs_[offset].is_cursor_position &&
+          offset < g_utf8_strlen(layout_text_, -1));
 }
 
 void RenderTextPango::ResetLayout() {
   // set_cached_bounds_and_offset_valid(false) is done in RenderText for every
   // operation that triggers ResetLayout().
   if (layout_) {
     // TODO(msw): Keep |layout_| across text changes, etc.; it can be re-used.
     g_object_unref(layout_);
     layout_ = NULL;
   }
@@ skipping 93 matching lines @@
   SkScalar y = SkIntToScalar(offset.y());
 
   std::vector<SkPoint> pos;
   std::vector<uint16> glyphs;
 
   internal::SkiaTextRenderer renderer(canvas);
   ApplyFadeEffects(&renderer);
   ApplyTextShadows(&renderer);
 
   // TODO(derat): Use font-specific params: http://crbug.com/125235
-  const FontRenderParams& render_params = GetDefaultFontRenderParams();
+  const gfx::FontRenderParams& render_params =
+      gfx::GetDefaultFontRenderParams();
   const bool use_subpixel_rendering =
       render_params.subpixel_rendering !=
-          FontRenderParams::SUBPIXEL_RENDERING_NONE;
+          gfx::FontRenderParams::SUBPIXEL_RENDERING_NONE;
   renderer.SetFontSmoothingSettings(
       render_params.antialiasing,
       use_subpixel_rendering && !background_is_transparent(),
       render_params.subpixel_positioning);
 
   SkPaint::Hinting skia_hinting = SkPaint::kNormal_Hinting;
   switch (render_params.hinting) {
-    case FontRenderParams::HINTING_NONE:
+    case gfx::FontRenderParams::HINTING_NONE:
       skia_hinting = SkPaint::kNo_Hinting;
       break;
-    case FontRenderParams::HINTING_SLIGHT:
+    case gfx::FontRenderParams::HINTING_SLIGHT:
       skia_hinting = SkPaint::kSlight_Hinting;
       break;
-    case FontRenderParams::HINTING_MEDIUM:
+    case gfx::FontRenderParams::HINTING_MEDIUM:
       skia_hinting = SkPaint::kNormal_Hinting;
       break;
-    case FontRenderParams::HINTING_FULL:
+    case gfx::FontRenderParams::HINTING_FULL:
       skia_hinting = SkPaint::kFull_Hinting;
       break;
   }
   renderer.SetFontHinting(skia_hinting);
 
   // Temporarily apply composition underlines and selection colors.
   ApplyCompositionAndSelectionStyles();
 
   internal::StyleIterator style(colors(), styles());
   for (GSList* it = current_line_->runs; it; it = it->next) {
@@ skipping 100 matching lines @@
                                           int glyph_index) const {
   return LayoutIndexToTextIndex(run->item->offset +
                                 run->glyphs->log_clusters[glyph_index]);
 }
 
 RenderText* RenderText::CreateInstance() {
   return new RenderTextPango;
 }
 
 }  // namespace gfx