MacViews: Implement Force Touch/Mac dictionary lookup for Textfields.

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 <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 10 matching lines @@
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "ui/gfx/break_list.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_utils.h"
+#include "ui/gfx/decorated_text.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/font_names_testing.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/point_f.h"
 #include "ui/gfx/range/range.h"
 #include "ui/gfx/range/range_f.h"
 #include "ui/gfx/render_text_harfbuzz.h"
 #include "ui/gfx/text_utils.h"
 
 #if defined(OS_WIN)
@@ skipping 105 matching lines @@
 
 // Various weak, LTR, RTL, and Bidi string cases with three characters each.
 const wchar_t kWeak[] =      L" . ";
 const wchar_t kLtr[] =       L"abc";
 const wchar_t kRtl[] =       L"\x5d0\x5d1\x5d2";
 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";
 
+// Bitmasks based on gfx::TextStyle.
+enum {
+  ITALIC_MASK = 1 << ITALIC,
+  STRIKE_MASK = 1 << STRIKE,
+  DIAGONAL_STRIKE_MASK = 1 << DIAGONAL_STRIKE,
+  UNDERLINE_MASK = 1 << UNDERLINE,
+};
+
 // Checks whether |range| contains |index|. This is not the same as calling
 // 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());
 }
@@ skipping 34 matching lines @@
     EXPECT_EQ(expected[i], render_text->selection_model());
     render_text->MoveCursor(CHARACTER_BREAK, direction, SELECTION_NONE);
   }
   // Check that cursoring is clamped at the line edge.
   EXPECT_EQ(expected.back(), render_text->selection_model());
   // Check that it is the line edge.
   render_text->MoveCursor(LINE_BREAK, direction, SELECTION_NONE);
   EXPECT_EQ(expected.back(), render_text->selection_model());
 }
 
+// Creates a RangedAttribute instance for a single character range at the
+// given |index| with the given |weight| and |style_mask|. |index| is the
+// index of the character in the DecoratedText instance and |font_index| is
+// used to retrieve the font used from |font_spans|.
+DecoratedText::RangedAttribute CreateRangedAttribute(
+    const std::vector<RenderText::FontSpan>& font_spans,
+    int index,
+    int font_index,
+    Font::Weight weight,
+    int style_mask) {
+  const auto iter =
+      std::find_if(font_spans.begin(), font_spans.end(),
+                   [font_index](const RenderText::FontSpan& span) {
+                     return IndexInRange(span.second, font_index);
+                   });
+  DCHECK(font_spans.end() != iter);
+  const Font& font = iter->first;
+
+  int font_style = Font::NORMAL;
+  if (style_mask & ITALIC_MASK)
+    font_style |= Font::ITALIC;
+  if (style_mask & UNDERLINE_MASK)
+    font_style |= Font::UNDERLINE;
+
+  const Font font_with_style = font.Derive(0, font_style, weight);
+  DecoratedText::RangedAttribute attributes(Range(index, index + 1),
+                                            font_with_style);
+  attributes.strike = style_mask & STRIKE_MASK;
+  attributes.diagonal_strike = style_mask & DIAGONAL_STRIKE_MASK;
+  return attributes;
+}
+
+// Verifies the given DecoratedText instances are equal by comparing the
+// respective strings and attributes for each index. Note, corresponding
+// ranged attributes from |expected| and |actual| can't be compared since the
+// partition of |actual| into RangedAttributes will depend on the text runs
+// generated.
+void VerifyDecoratedWordsAreEqual(const DecoratedText& expected,
+                                  const DecoratedText& actual) {
+  ASSERT_EQ(expected.text, actual.text);
+
+  // Compare attributes for each index.
+  for (size_t i = 0; i < expected.text.length(); i++) {
+    SCOPED_TRACE(base::StringPrintf("Comparing index[%" PRIuS "]", i));
+    auto find_attribute_func = [i](const DecoratedText::RangedAttribute& attr) {
+      return IndexInRange(attr.range, i);
+    };
+    const auto expected_attr =
+        std::find_if(expected.attributes.begin(), expected.attributes.end(),
+                     find_attribute_func);
+    const auto actual_attr =
+        std::find_if(actual.attributes.begin(), actual.attributes.end(),
+                     find_attribute_func);
+    ASSERT_NE(expected.attributes.end(), expected_attr);
+    ASSERT_NE(actual.attributes.end(), actual_attr);
+
+    EXPECT_EQ(expected_attr->strike, actual_attr->strike);
+    EXPECT_EQ(expected_attr->diagonal_strike, actual_attr->diagonal_strike);
+    EXPECT_EQ(expected_attr->font.GetFontName(),
+              actual_attr->font.GetFontName());
+    EXPECT_EQ(expected_attr->font.GetFontSize(),
+              actual_attr->font.GetFontSize());
+    EXPECT_EQ(expected_attr->font.GetWeight(), actual_attr->font.GetWeight());
+    EXPECT_EQ(expected_attr->font.GetStyle(), actual_attr->font.GetStyle());
+  }
+}
+
 // The class which records the drawing operations so that the test case can
 // verify where exactly the glyphs are drawn.
 class TestSkiaTextRenderer : public internal::SkiaTextRenderer {
  public:
   struct TextLog {
     TextLog() : glyph_count(0u), color(SK_ColorTRANSPARENT) {}
     PointF origin;
     size_t glyph_count;
     SkColor color;
   };
@@ skipping 3559 matching lines @@
     // SUBPIXEL_RENDERING_RGB set above should now take effect. But, after
     // checking, apply the override anyway to be explicit that it is suppressed.
     EXPECT_FALSE(GetRendererPaint().isLCDRenderText());
     GetHarfBuzzRunList()->runs()[0]->render_params.subpixel_rendering =
         FontRenderParams::SUBPIXEL_RENDERING_RGB;
     DrawVisualText();
 #endif
     EXPECT_FALSE(GetRendererPaint().isLCDRenderText());
 }
 
+// Verify GetDecoratedWordAtPoint returns the correct baseline point and
+// decorated word for an LTR string.
+TEST_P(RenderTextHarfBuzzTest, GetDecoratedWordAtPoint_LTR) {
+  const base::string16 ltr = ASCIIToUTF16("  ab  c ");
+  const int kWordOneStartIndex = 2;
+  const int kWordTwoStartIndex = 6;
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(100, 30));
+  render_text->SetText(ltr);
+  render_text->ApplyWeight(Font::Weight::SEMIBOLD, Range(0, 3));
+  render_text->ApplyStyle(UNDERLINE, true, Range(1, 5));
+  render_text->ApplyStyle(ITALIC, true, Range(3, 8));
+  render_text->ApplyStyle(DIAGONAL_STRIKE, true, Range(5, 7));
+  render_text->ApplyStyle(STRIKE, true, Range(1, 7));
+
+  const std::vector<RenderText::FontSpan> font_spans =
+      render_text->GetFontSpansForTesting();
+
+  // Create expected decorated text instances.
+  DecoratedText expected_word_1;
+  expected_word_1.text = ASCIIToUTF16("ab");
+  // Attributes for the characters 'a' and 'b' at logical indices 2 and 3
+  // respectively.
+  expected_word_1.attributes.push_back(CreateRangedAttribute(
+      font_spans, 0, kWordOneStartIndex, Font::Weight::SEMIBOLD,
+      UNDERLINE_MASK | STRIKE_MASK));
+  expected_word_1.attributes.push_back(CreateRangedAttribute(
+      font_spans, 1, kWordOneStartIndex + 1, Font::Weight::NORMAL,
+      UNDERLINE_MASK | ITALIC_MASK | STRIKE_MASK));
+  const Rect left_glyph_word_1 = render_text->GetCursorBounds(
+      SelectionModel(kWordOneStartIndex, CURSOR_FORWARD), false);
+
+  DecoratedText expected_word_2;
+  expected_word_2.text = ASCIIToUTF16("c");
+  // Attributes for character 'c' at logical index |kWordTwoStartIndex|.
+  expected_word_2.attributes.push_back(CreateRangedAttribute(
+      font_spans, 0, kWordTwoStartIndex, Font::Weight::NORMAL,
+      ITALIC_MASK | DIAGONAL_STRIKE_MASK | STRIKE_MASK));
+  const Rect left_glyph_word_2 = render_text->GetCursorBounds(
+      SelectionModel(kWordTwoStartIndex, CURSOR_FORWARD), false);
+
+  DecoratedText decorated_word;
+  Point baseline_point;
+
+  {
+    SCOPED_TRACE(base::StringPrintf("Query to the left of text bounds"));
+    EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(
+        Point(-5, 5), &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_1, decorated_word);
+    EXPECT_TRUE(left_glyph_word_1.Contains(baseline_point));
+  }
+  {
+    SCOPED_TRACE(base::StringPrintf("Query to the right of text bounds"));
+    EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(
+        Point(105, 5), &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_2, decorated_word);
+    EXPECT_TRUE(left_glyph_word_2.Contains(baseline_point));
+  }
+
+  for (size_t i = 0; i < render_text->text().length(); i++) {
+    SCOPED_TRACE(base::StringPrintf("Case[%" PRIuS "]", i));
+    // Query the decorated word using the origin of the i'th glyph's bounds.
+    const Point query =
+        render_text->GetCursorBounds(SelectionModel(i, CURSOR_FORWARD), false)
+            .origin();
+
+    EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(query, &decorated_word,
+                                                     &baseline_point));
+
+    if (i < kWordTwoStartIndex) {
+      VerifyDecoratedWordsAreEqual(expected_word_1, decorated_word);
+      EXPECT_TRUE(left_glyph_word_1.Contains(baseline_point));
+    } else {
+      VerifyDecoratedWordsAreEqual(expected_word_2, decorated_word);
+      EXPECT_TRUE(left_glyph_word_2.Contains(baseline_point));
+    }
+  }
+}
+
+// Verify GetDecoratedWordAtPoint returns the correct baseline point and
+// decorated word for an RTL string.
+TEST_P(RenderTextHarfBuzzTest, GetDecoratedWordAtPoint_RTL) {
+  const base::string16 rtl = WideToUTF16(
+      L" "
+      L"\x0634\x0632"
+      L"  "
+      L"\x0634");
+  const int kWordOneStartIndex = 1;
+  const int kWordTwoStartIndex = 5;
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(100, 30));
+  render_text->SetText(rtl);
+  render_text->ApplyWeight(Font::Weight::SEMIBOLD, Range(2, 3));
+  render_text->ApplyStyle(UNDERLINE, true, Range(3, 6));
+  render_text->ApplyStyle(ITALIC, true, Range(0, 3));
+  render_text->ApplyStyle(DIAGONAL_STRIKE, true, Range(0, 2));
+  render_text->ApplyStyle(STRIKE, true, Range(2, 5));
+
+  const std::vector<RenderText::FontSpan> font_spans =
+      render_text->GetFontSpansForTesting();
+
+  // Create expected decorated text instance.
+  DecoratedText expected_word_1;
+  expected_word_1.text = WideToUTF16(L"\x0634\x0632");
+  // Attributes for characters at logical indices 1 and 2.
+  expected_word_1.attributes.push_back(CreateRangedAttribute(
+      font_spans, 0, kWordOneStartIndex, Font::Weight::NORMAL,
+      ITALIC_MASK | DIAGONAL_STRIKE_MASK));
+  expected_word_1.attributes.push_back(
+      CreateRangedAttribute(font_spans, 1, kWordOneStartIndex + 1,
+                            Font::Weight::SEMIBOLD, ITALIC_MASK | STRIKE_MASK));
+  // The leftmost glyph is the one at logical index 2.
+  const Rect left_glyph_word_1 = render_text->GetCursorBounds(
+      SelectionModel(kWordOneStartIndex + 1, CURSOR_FORWARD), false);
+
+  DecoratedText expected_word_2;
+  expected_word_2.text = WideToUTF16(L"\x0634");
+  // Attributes for character at logical index |kWordTwoStartIndex|.
+  expected_word_2.attributes.push_back(CreateRangedAttribute(
+      font_spans, 0, kWordTwoStartIndex, Font::Weight::NORMAL, UNDERLINE_MASK));
+  const Rect left_glyph_word_2 = render_text->GetCursorBounds(
+      SelectionModel(kWordTwoStartIndex, CURSOR_FORWARD), false);
+
+  DecoratedText decorated_word;
+  Point baseline_point;
+
+  {
+    SCOPED_TRACE(base::StringPrintf("Query to the left of text bounds"));
+    EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(
+        Point(-5, 5), &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_2, decorated_word);
+    EXPECT_TRUE(left_glyph_word_2.Contains(baseline_point));
+  }
+  {
+    SCOPED_TRACE(base::StringPrintf("Query to the right of text bounds"));
+    EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(
+        Point(105, 5), &decorated_word, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_word_1, decorated_word);
+    EXPECT_TRUE(left_glyph_word_1.Contains(baseline_point));
+  }
+
+  for (size_t i = 0; i < render_text->text().length(); i++) {
+    SCOPED_TRACE(base::StringPrintf("Case[%" PRIuS "]", i));
+
+    // Query the decorated word using the top right point of the i'th glyph's
+    // bounds.
+    const Point query =
+        render_text->GetCursorBounds(SelectionModel(i, CURSOR_FORWARD), false)
+            .top_right();
+
+    EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(query, &decorated_word,
+                                                     &baseline_point));
+    if (i < kWordTwoStartIndex) {
+      VerifyDecoratedWordsAreEqual(expected_word_1, decorated_word);
+      EXPECT_TRUE(left_glyph_word_1.Contains(baseline_point));
+    } else {
+      VerifyDecoratedWordsAreEqual(expected_word_2, decorated_word);
+      EXPECT_TRUE(left_glyph_word_2.Contains(baseline_point));
+    }
+  }
+}
+
+// Verify the boolean return value of GetDecoratedWordAtPoint.
+TEST_P(RenderTextHarfBuzzTest, GetDecoratedWordAtPoint_Return) {
+  RenderText* render_text = GetRenderText();
+  render_text->SetText(ASCIIToUTF16("..."));
+
+  DecoratedText decorated_word;
+  Point baseline_point;
+
+  // False should be returned, when the text does not contain any word.
+  Point query =
+      render_text->GetCursorBounds(SelectionModel(0, CURSOR_FORWARD), false)
+          .origin();
+  EXPECT_FALSE(render_text->GetDecoratedWordAtPoint(query, &decorated_word,
+                                                    &baseline_point));
+
+  render_text->SetText(ASCIIToUTF16("abc"));
+  query = render_text->GetCursorBounds(SelectionModel(0, CURSOR_FORWARD), false)
+              .origin();
+  EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(query, &decorated_word,
+                                                   &baseline_point));
+
+  // False should be returned for obscured text.
+  render_text->SetObscured(true);
+  query = render_text->GetCursorBounds(SelectionModel(0, CURSOR_FORWARD), false)
+              .origin();
+  EXPECT_FALSE(render_text->GetDecoratedWordAtPoint(query, &decorated_word,
+                                                    &baseline_point));
+}
+
 // Prefix for test instantiations intentionally left blank since each test
 // fixture class has a single parameterization.
 #if defined(OS_MACOSX)
 INSTANTIATE_TEST_CASE_P(,
                         RenderTextTest,
                         ::testing::Values(RENDER_TEXT_HARFBUZZ,
                                           RENDER_TEXT_MAC),
                         PrintRenderTextBackend());
 INSTANTIATE_TEST_CASE_P(,
                         RenderTextMacTest,
                         ::testing::Values(RENDER_TEXT_MAC),
                         PrintRenderTextBackend());
 #else
 INSTANTIATE_TEST_CASE_P(,
                         RenderTextTest,
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 #endif
 
 INSTANTIATE_TEST_CASE_P(,
                         RenderTextHarfBuzzTest,
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 
 }  // namespace gfx