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

ui/gfx/render_text_win.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_win.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/i18n/char_iterator.h"
@@ skipping 486 matching lines @@
 };
 
 }  // namespace internal
 
 // static
 HDC RenderTextWin::cached_hdc_ = NULL;
 
 // static
 std::map<std::string, Font> RenderTextWin::successful_substitute_fonts_;
 
-RenderTextWin::RenderTextWin() : RenderText(), needs_layout_(false) {
+RenderTextWin::RenderTextWin()
+    : RenderText(),
+      needs_layout_(false) {
   set_truncate_length(kMaxUniscribeTextLength);
+
   memset(&script_control_, 0, sizeof(script_control_));
   memset(&script_state_, 0, sizeof(script_state_));
+
   MoveCursorTo(EdgeSelectionModel(CURSOR_LEFT));
 }
 
-RenderTextWin::~RenderTextWin() {}
+RenderTextWin::~RenderTextWin() {
+}
 
 Size RenderTextWin::GetStringSize() {
   EnsureLayout();
   return multiline_string_size_;
 }
 
 SelectionModel RenderTextWin::FindCursorPosition(const Point& point) {
   if (text().empty())
     return SelectionModel();
 
@@ skipping 179 matching lines @@
   }
   for (size_t i = 0; i < bounds.size(); ++i) {
     std::vector<Rect> current_rects = TextBoundsToViewBounds(bounds[i]);
     rects.insert(rects.end(), current_rects.begin(), current_rects.end());
   }
   return rects;
 }
 
 size_t RenderTextWin::TextIndexToLayoutIndex(size_t index) const {
   DCHECK_LE(index, text().length());
-  ptrdiff_t i = obscured() ? UTF16IndexToOffset(text(), 0, index) : index;
+  ptrdiff_t i = obscured() ? gfx::UTF16IndexToOffset(text(), 0, index) : index;
   CHECK_GE(i, 0);
   // Clamp layout indices to the length of the text actually used for layout.
   return std::min<size_t>(GetLayoutText().length(), i);
 }
 
 size_t RenderTextWin::LayoutIndexToTextIndex(size_t index) const {
   if (!obscured())
     return index;
 
   DCHECK_LE(index, GetLayoutText().length());
-  const size_t text_index = UTF16OffsetToIndex(text(), 0, index);
+  const size_t text_index = gfx::UTF16OffsetToIndex(text(), 0, index);
   DCHECK_LE(text_index, text().length());
   return text_index;
 }
 
-bool RenderTextWin::IsValidCursorIndex(size_t index) {
-  if (index == 0 || index == text().length())
+bool RenderTextWin::IsCursorablePosition(size_t position) {
+  if (position == 0 || position == text().length())
     return true;
-  if (!IsValidLogicalIndex(index))
-    return false;
   EnsureLayout();
-  // Disallow indices amid multi-character graphemes by checking glyph bounds.
-  // These characters are not surrogate-pairs, but may yield a single glyph:
-  //   \x0915\x093f - (ki) - one of many Devanagari biconsonantal conjuncts.
-  //   \x0e08\x0e33 - (cho chan + sara am) - a Thai consonant and vowel pair.
-  return GetGlyphBounds(index) != GetGlyphBounds(index - 1);
+
+  // Check that the index is at a valid code point (not mid-surrgate-pair),
+  // that it is not truncated from layout text (its glyph is shown on screen),
+  // and that its glyph has distinct bounds (not mid-multi-character-grapheme).
+  // An example of a multi-character-grapheme that is not a surrogate-pair is:
+  // \x0915\x093f - (ki) - one of many Devanagari biconsonantal conjuncts.
+  return gfx::IsValidCodePointIndex(text(), position) &&
+         position < LayoutIndexToTextIndex(GetLayoutText().length()) &&
+         GetGlyphBounds(position) != GetGlyphBounds(position - 1);
 }
 
 void RenderTextWin::ResetLayout() {
   // Layout is performed lazily as needed for drawing/metrics.
   needs_layout_ = true;
 }
 
 void RenderTextWin::EnsureLayout() {
   if (needs_layout_) {
     // TODO(msw): Skip complex processing if ScriptIsComplex returns false.
@@ skipping 95 matching lines @@
       renderer.SetFontFamilyWithStyle(run->font.GetFontName(), run->font_style);
 
       for (BreakList<SkColor>::const_iterator it =
                colors().GetBreak(segment->char_range.start());
            it != colors().breaks().end() &&
                it->first < segment->char_range.end();
            ++it) {
         const Range intersection =
             colors().GetRange(it).Intersect(segment->char_range);
         const Range colored_glyphs = CharRangeToGlyphRange(*run, intersection);
-        // The range may be empty if a portion of a multi-character grapheme is
-        // selected, yielding two colors for a single glyph. For now, this just
-        // paints the glyph with a single style, but it should paint it twice,
-        // clipped according to selection bounds. See http://crbug.com/366786
-        if (colored_glyphs.is_empty())
-          continue;
         DCHECK(glyph_range.Contains(colored_glyphs));
+        DCHECK(!colored_glyphs.is_empty());
         const SkPoint& start_pos =
             pos[colored_glyphs.start() - glyph_range.start()];
         const SkPoint& end_pos =
             pos[colored_glyphs.end() - glyph_range.start()];
 
         renderer.SetForegroundColor(it->second);
         renderer.DrawPosText(&start_pos, &run->glyphs[colored_glyphs.start()],
                              colored_glyphs.length());
         renderer.DrawDecorations(start_pos.x(), text_offset.y(),
                                  SkScalarCeilToInt(end_pos.x() - start_pos.x()),
@@ skipping 398 matching lines @@
   size_t position = LayoutIndexToTextIndex(run->range.end());
   position = IndexOfAdjacentGrapheme(position, CURSOR_BACKWARD);
   return SelectionModel(position, CURSOR_FORWARD);
 }
 
 RenderText* RenderText::CreateInstance() {
   return new RenderTextWin;
 }
 
 }  // namespace gfx