Fix Views inline autocomplete with multi-char graphemes.

ui/gfx/render_text_unittest.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.h"
 
 #include <algorithm>
 
 #include "base/format_macros.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 26 matching lines @@
 const wchar_t kLtr[] =       L"abc";
 const wchar_t kRtl[] =       L"\x5d0\x5d1\x5d2";
 #if !defined(OS_MACOSX)
 const wchar_t kLtrRtl[] =    L"a" L"\x5d0\x5d1";
 const wchar_t kLtrRtlLtr[] = L"a" L"\x5d1" L"b";
 const wchar_t kRtlLtr[] =    L"\x5d0\x5d1" L"a";
 const wchar_t kRtlLtrRtl[] = L"\x5d0" L"a" L"\x5d1";
 #endif
 
 // Checks whether |range| contains |index|. This is not the same as calling
-// |range.Contains(gfx::Range(index))| - as that would return true when
-// |index| == |range.end()|.
+// range.Contains(Range(index)), which returns true if |index| == |range.end()|.
 bool IndexInRange(const Range& range, size_t index) {
   return index >= range.start() && index < range.end();
 }
 
 base::string16 GetSelectedText(RenderText* render_text) {
   return render_text->text().substr(render_text->selection().GetMin(),
                                     render_text->selection().length());
 }
 
 // A test utility function to set the application default text direction.
@@ skipping 229 matching lines @@
   EXPECT_EQ(0U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
   EXPECT_EQ(2U, render_text->cursor_position());
 
   // Test index conversion and cursor validity with a valid surrogate pair.
   EXPECT_EQ(0U, render_text->TextIndexToLayoutIndex(0U));
   EXPECT_EQ(1U, render_text->TextIndexToLayoutIndex(1U));
   EXPECT_EQ(1U, render_text->TextIndexToLayoutIndex(2U));
   EXPECT_EQ(0U, render_text->LayoutIndexToTextIndex(0U));
   EXPECT_EQ(2U, render_text->LayoutIndexToTextIndex(1U));
-  EXPECT_TRUE(render_text->IsCursorablePosition(0U));
-  EXPECT_FALSE(render_text->IsCursorablePosition(1U));
-  EXPECT_TRUE(render_text->IsCursorablePosition(2U));
+  EXPECT_TRUE(render_text->IsValidCursorIndex(0U));
+  EXPECT_FALSE(render_text->IsValidCursorIndex(1U));
+  EXPECT_TRUE(render_text->IsValidCursorIndex(2U));
 
   // FindCursorPosition() should not return positions between a surrogate pair.
   render_text->SetDisplayRect(Rect(0, 0, 20, 20));
   EXPECT_EQ(render_text->FindCursorPosition(Point(0, 0)).caret_pos(), 0U);
   EXPECT_EQ(render_text->FindCursorPosition(Point(20, 0)).caret_pos(), 2U);
   for (int x = -1; x <= 20; ++x) {
     SelectionModel selection = render_text->FindCursorPosition(Point(x, 0));
     EXPECT_TRUE(selection.caret_pos() == 0U || selection.caret_pos() == 2U);
   }
 
@@ skipping 125 matching lines @@
     // Surrogate pairs should be elided reasonably enough.
     { L"0\x05e9\x05bc\x05c1\x05b8",   L"0\x05e9\x05bc\x05c1\x05b8", false },
     { L"0\x05e9\x05bc\x05c1\x05b8",   L"0\x05e9\x05bc\x2026"      , true  },
     { L"01\x05e9\x05bc\x05c1\x05b8",  L"01\x05e9\x2026"           , true  },
     { L"012\x05e9\x05bc\x05c1\x05b8", L"012\x2026\x200E"          , true  },
     { L"012\xF0\x9D\x84\x9E",         L"012\xF0\x2026"            , true  },
   };
 
   scoped_ptr<RenderText> expected_render_text(RenderText::CreateInstance());
   expected_render_text->SetFontList(FontList("serif, Sans serif, 12px"));
-  expected_render_text->SetDisplayRect(gfx::Rect(0, 0, 9999, 100));
+  expected_render_text->SetDisplayRect(Rect(0, 0, 9999, 100));
 
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetFontList(FontList("serif, Sans serif, 12px"));
-  render_text->SetElideBehavior(gfx::ELIDE_AT_END);
+  render_text->SetElideBehavior(ELIDE_AT_END);
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
     // Compute expected width
     expected_render_text->SetText(WideToUTF16(cases[i].layout_text));
     int expected_width = expected_render_text->GetContentWidth();
 
     base::string16 input = WideToUTF16(cases[i].text);
     // Extend the input text to ensure that it is wider than the layout_text,
     // and so it will get elided.
     if (cases[i].elision_expected)
       input.append(WideToUTF16(L" MMMMMMMMMMM"));
 
     render_text->SetText(input);
-    render_text->SetDisplayRect(gfx::Rect(0, 0, expected_width, 100));
+    render_text->SetDisplayRect(Rect(0, 0, expected_width, 100));
     EXPECT_EQ(input, render_text->text())
         << "->For case " << i << ": " << cases[i].text << "\n";
     EXPECT_EQ(WideToUTF16(cases[i].layout_text), render_text->GetLayoutText())
         << "->For case " << i << ": " << cases[i].text << "\n";
     expected_render_text->SetText(base::string16());
   }
 }
 
 TEST_F(RenderTextTest, ElidedObscuredText) {
   scoped_ptr<RenderText> expected_render_text(RenderText::CreateInstance());
   expected_render_text->SetFontList(FontList("serif, Sans serif, 12px"));
-  expected_render_text->SetDisplayRect(gfx::Rect(0, 0, 9999, 100));
+  expected_render_text->SetDisplayRect(Rect(0, 0, 9999, 100));
   expected_render_text->SetText(WideToUTF16(L"**\x2026"));
 
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   render_text->SetFontList(FontList("serif, Sans serif, 12px"));
-  render_text->SetElideBehavior(gfx::ELIDE_AT_END);
+  render_text->SetElideBehavior(ELIDE_AT_END);
   render_text->SetDisplayRect(
-      gfx::Rect(0, 0, expected_render_text->GetContentWidth(), 100));
+      Rect(0, 0, expected_render_text->GetContentWidth(), 100));
   render_text->SetObscured(true);
   render_text->SetText(WideToUTF16(L"abcdef"));
   EXPECT_EQ(WideToUTF16(L"abcdef"), render_text->text());
   EXPECT_EQ(WideToUTF16(L"**\x2026"), render_text->GetLayoutText());
 }
 
 TEST_F(RenderTextTest, TruncatedText) {
   struct {
     const wchar_t* text;
     const wchar_t* layout_text;
@@ skipping 400 matching lines @@
 
   // TODO(asvitkine): Disable tests that fail on XP bots due to lack of complete
   //                  font support for some scripts - http://crbug.com/106450
 #if defined(OS_WIN)
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     return;
 #endif
 
   scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
+    SCOPED_TRACE(base::StringPrintf("Testing cases[%" PRIuS "]", i));
     render_text->SetText(cases[i].text);
 
     size_t next = render_text->IndexOfAdjacentGrapheme(cases[i].index,
                                                        CURSOR_FORWARD);
     EXPECT_EQ(cases[i].expected_next, next);
-    EXPECT_TRUE(render_text->IsCursorablePosition(next));
+    EXPECT_TRUE(render_text->IsValidCursorIndex(next));
 
     size_t previous = render_text->IndexOfAdjacentGrapheme(cases[i].index,
                                                            CURSOR_BACKWARD);
     EXPECT_EQ(cases[i].expected_previous, previous);
-    EXPECT_TRUE(render_text->IsCursorablePosition(previous));
+    EXPECT_TRUE(render_text->IsValidCursorIndex(previous));
   }
 }
 
+TEST_F(RenderTextTest, MidGraphemeSelectionBounds) {
+  // Test that selection bounds may be set amid multi-character graphemes.
+  const base::string16 kHindi = WideToUTF16(L"\x0915\x093f");
+  const base::string16 kThai = WideToUTF16(L"\x0e08\x0e33");
+  base::string16 cases[] = { kHindi, kThai };

[Alexei Svitkine (slow), 2014/05/01 20:48:09]

Nit: Can this be a "const base::string16& cases[] ="?

[msw, 2014/05/01 22:43:22]

This yields "error: 'cases' declared as array of references of type 'const
base::string16 &'". An array of references is not a legal type, just as pointers
to references and references to references are prohibited. I did make the array
const, however.

+
+  scoped_ptr<RenderText> render_text(RenderText::CreateInstance());
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {

[Alexei Svitkine (slow), 2014/05/01 20:48:09]

Nit: I think you can just use arraysize(cases) here since |cases| is not an anon
struct.

[msw, 2014/05/01 22:43:22]

Done.

+    SCOPED_TRACE(base::StringPrintf("Testing cases[%" PRIuS "]", i));
+    render_text->SetText(cases[i]);
+    EXPECT_TRUE(render_text->IsValidLogicalIndex(1));
+#if !defined(OS_MACOSX)
+    EXPECT_FALSE(render_text->IsValidCursorIndex(1));
+#endif
+    EXPECT_TRUE(render_text->SelectRange(Range(2, 1)));
+    EXPECT_EQ(Range(2, 1), render_text->selection());
+    EXPECT_EQ(1U, render_text->cursor_position());
+    // Although selection bounds may be set within a multi-character grapheme,
+    // cursor movement (e.g. via arrow key) should avoid those indices.
+    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_LEFT, false);
+    EXPECT_EQ(0U, render_text->cursor_position());
+    render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, false);
+    EXPECT_EQ(2U, render_text->cursor_position());
+  }
+}
+
 TEST_F(RenderTextTest, EdgeSelectionModels) {
   // Simple Latin text.
   const base::string16 kLatin = WideToUTF16(L"abc");
   // LTR 2-character grapheme.
   const base::string16 kLTRGrapheme = WideToUTF16(L"\x0915\x093f");
   // LTR 2-character grapheme, LTR a, LTR 2-character grapheme.
   const base::string16 kHindiLatin =
       WideToUTF16(L"\x0915\x093f" L"a" L"\x0915\x093f");
   // RTL 2-character grapheme.
   const base::string16 kRTLGrapheme = WideToUTF16(L"\x05e0\x05b8");
@@ skipping 949 matching lines @@
   render_text->SetText(WideToUTF16(L"x \x25B6 y"));
   render_text->EnsureLayout();
   ASSERT_EQ(3U, render_text->runs_.size());
   EXPECT_EQ(Range(0, 2), render_text->runs_[0]->range);
   EXPECT_EQ(Range(2, 3), render_text->runs_[1]->range);
   EXPECT_EQ(Range(3, 5), render_text->runs_[2]->range);
 }
 #endif  // defined(OS_WIN)
 
 }  // namespace gfx