[MacViews] Implemented text context menu

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 3980 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) {
+// Verify GetDecoratedWordAndBaselineAtRange returns the correct baseline point

[msw, 2017/02/01 01:52:28]

nit: GetDecoratedTextAndBaselineAtRange

[spqchan, 2017/02/02 20:35:05]

Done.

+// and decorated word.
+TEST_P(RenderTextHarfBuzzTest, GetDecoratedWordAndBaselineAtRange) {

[msw, 2017/02/01 01:52:28]

nit: GetDecoratedTextAndBaselineAtRange

[spqchan, 2017/02/02 20:35:05]

Done.

+  const base::string16 text = ASCIIToUTF16("yellow boxfish");
+  const Range kWordOneRange = Range(0, 6);
+  const Range kWordTwoRange = Range(7, 14);
+
+  RenderText* render_text = GetRenderText();
+  render_text->SetDisplayRect(Rect(100, 30));
+  render_text->SetText(text);
+  render_text->ApplyWeight(Font::Weight::NORMAL, kWordOneRange);
+  render_text->ApplyWeight(Font::Weight::SEMIBOLD, kWordTwoRange);
+  render_text->ApplyStyle(UNDERLINE, true, kWordOneRange);
+  render_text->ApplyStyle(ITALIC, true, kWordTwoRange);
+
+  const std::vector<RenderText::FontSpan> font_spans =
+      render_text->GetFontSpansForTesting();
+
+  DecoratedText expected_text_1;
+  expected_text_1.text = ASCIIToUTF16("yellow");
+  for (size_t i = 0; i < expected_text_1.text.length(); i++) {

[msw, 2017/02/01 01:52:28]

Can you do this without a loop, like:
expected_text_1.attributes.push_back(CreateRangedAttribute(font_spans, 0,
expected_text_1.text.length(), Font::Weight::NORMAL, UNDERLINE_MASK));

[spqchan, 2017/02/02 20:35:05]

No, it's weird like that. You need to apply an attribute to every character on
the text.

[msw, 2017/02/02 22:16:08]

There are numerous other places in the code that call CreateRangedAttribute once
with a non-empty range... why is this different?

+    expected_text_1.attributes.push_back(CreateRangedAttribute(
+        font_spans, i, i, Font::Weight::NORMAL, UNDERLINE_MASK));
+  }
+
+  const Rect left_glyph_1 =
+      render_text->GetCursorBounds(SelectionModel(0, CURSOR_FORWARD), false);
+
+  DecoratedText decorated_text;
+  Point baseline_point;
+
+  {

[msw, 2017/02/01 01:52:28]

Remove this block if you're not using SCOPED_TRACE

[spqchan, 2017/02/02 20:35:05]

Done.

+    EXPECT_TRUE(render_text->GetDecoratedTextAndBaselineForRange(
+        kWordOneRange, &decorated_text, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_text_1, decorated_text);
+    EXPECT_TRUE(left_glyph_1.Contains(baseline_point));
+  }
+
+  DecoratedText expected_text_2;
+  expected_text_2.text = ASCIIToUTF16("boxfish");

[msw, 2017/02/01 01:52:28]

It seems like the point of this new function is to handle ranges that don't
exactly match a word (eg. multiple words, part of a word, parts of multiple
words), am I right? If so, please modify one or both of your test cases to check
a range that isn't exactly one word.

[spqchan, 2017/02/02 20:35:05]

Sure thing, it now checks for both words

+  for (size_t i = 0; i < expected_text_2.text.length(); i++) {

[msw, 2017/02/01 01:52:28]

Can you do this without a loop, like:
expected_text_2.attributes.push_back(CreateRangedAttribute(font_spans, 0,
expected_text_2.text.length(), Font::Weight::SEMIBOLD, ITALIC_MASK));

[spqchan, 2017/02/02 20:35:05]

Ditto from above.

+    expected_text_2.attributes.push_back(CreateRangedAttribute(
+        font_spans, i, i, Font::Weight::SEMIBOLD, ITALIC_MASK));
+  }
+
+  const Rect left_glyph_2 = render_text->GetCursorBounds(
+      SelectionModel(kWordTwoRange.start(), CURSOR_FORWARD), false);
+
+  {

[msw, 2017/02/01 01:52:28]

Remove this block if you're not using SCOPED_TRACE

[spqchan, 2017/02/02 20:35:05]

Done.

+    EXPECT_TRUE(render_text->GetDecoratedTextAndBaselineForRange(
+        kWordTwoRange, &decorated_text, &baseline_point));
+    VerifyDecoratedWordsAreEqual(expected_text_2, decorated_text);
+    EXPECT_TRUE(left_glyph_2.Contains(baseline_point));
+  }
+}
+
+// Verify GetDecoratedWordAndBaselineAtPoint returns the correct baseline point
+// and decorated word for an LTR string.
+TEST_P(RenderTextHarfBuzzTest, GetDecoratedWordAndBaselineAtPoint_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));
@@ skipping 25 matching lines @@
       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(
+    EXPECT_TRUE(render_text->GetDecoratedWordAndBaselineAtPoint(
         Point(-5, cursor_y), &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(
+    EXPECT_TRUE(render_text->GetDecoratedWordAndBaselineAtPoint(
         Point(105, cursor_y), &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));
+    EXPECT_TRUE(render_text->GetDecoratedWordAndBaselineAtPoint(
+        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
+// Verify GetDecoratedWordAndBaselineAtPoint returns the correct baseline point
+// and
 // decorated word for an RTL string.
-TEST_P(RenderTextHarfBuzzTest, GetDecoratedWordAtPoint_RTL) {
+TEST_P(RenderTextHarfBuzzTest, GetDecoratedWordAndBaselineAtPoint_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));
@@ skipping 28 matching lines @@
   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(
+    EXPECT_TRUE(render_text->GetDecoratedWordAndBaselineAtPoint(
         Point(-5, cursor_y), &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(
+    EXPECT_TRUE(render_text->GetDecoratedWordAndBaselineAtPoint(
         Point(105, cursor_y), &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));
+    EXPECT_TRUE(render_text->GetDecoratedWordAndBaselineAtPoint(
+        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));
     }
   }
 }
 
-// Test that GetDecoratedWordAtPoint behaves correctly for multiline text.
-TEST_P(RenderTextHarfBuzzTest, GetDecoratedWordAtPoint_Multiline) {
+// Test that GetDecoratedWordAndBaselineAtPoint behaves correctly for multiline
+// text.
+TEST_P(RenderTextHarfBuzzTest, GetDecoratedWordAndBaselineAtPoint_Multiline) {
   const base::string16 text = ASCIIToUTF16("a b\n..\ncd.");
   const size_t kWordOneIndex = 0;    // Index of character 'a'.
   const size_t kWordTwoIndex = 2;    // Index of character 'b'.
   const size_t kWordThreeIndex = 7;  // Index of character 'c'.
 
   // Set up render text.
   RenderText* render_text = GetRenderText();
   render_text->SetMultiline(true);
   render_text->SetDisplayRect(Rect(500, 500));
   render_text->SetText(text);
@@ skipping 29 matching lines @@
   expected_word_3.attributes.push_back(CreateRangedAttribute(
       font_spans, 1, kWordThreeIndex + 1, Font::Weight::NORMAL, ITALIC_MASK));
 
   const Rect left_glyph_word_3 =
       GetSubstringBoundsUnion(Range(kWordThreeIndex, kWordThreeIndex + 1));
 
   DecoratedText decorated_word;
   Point baseline_point;
   {
     // Query to the left of the first line.
-    EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(
+    EXPECT_TRUE(render_text->GetDecoratedWordAndBaselineAtPoint(
         Point(-5, GetCursorYForTesting(0)), &decorated_word, &baseline_point));
     VerifyDecoratedWordsAreEqual(expected_word_1, decorated_word);
     EXPECT_TRUE(left_glyph_word_1.Contains(baseline_point));
   }
   {
     // Query on the second line.
-    EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(
+    EXPECT_TRUE(render_text->GetDecoratedWordAndBaselineAtPoint(
         Point(5, GetCursorYForTesting(1)), &decorated_word, &baseline_point));
     VerifyDecoratedWordsAreEqual(expected_word_2, decorated_word);
     EXPECT_TRUE(left_glyph_word_2.Contains(baseline_point));
   }
   {
     // Query at the center point of the character 'c'.
-    EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(
+    EXPECT_TRUE(render_text->GetDecoratedWordAndBaselineAtPoint(
         left_glyph_word_3.CenterPoint(), &decorated_word, &baseline_point));
     VerifyDecoratedWordsAreEqual(expected_word_3, decorated_word);
     EXPECT_TRUE(left_glyph_word_3.Contains(baseline_point));
   }
   {
     // Query to the right of the third line.
-    EXPECT_TRUE(render_text->GetDecoratedWordAtPoint(
+    EXPECT_TRUE(render_text->GetDecoratedWordAndBaselineAtPoint(
         Point(505, GetCursorYForTesting(2)), &decorated_word, &baseline_point));
     VerifyDecoratedWordsAreEqual(expected_word_3, decorated_word);
     EXPECT_TRUE(left_glyph_word_3.Contains(baseline_point));
   }
 }
 
-// Verify the boolean return value of GetDecoratedWordAtPoint.
-TEST_P(RenderTextHarfBuzzTest, GetDecoratedWordAtPoint_Return) {
+// Verify the boolean return value of GetDecoratedWordAndBaselineAtPoint.
+TEST_P(RenderTextHarfBuzzTest, GetDecoratedWordAndBaselineAtPoint_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));
+  EXPECT_FALSE(render_text->GetDecoratedWordAndBaselineAtPoint(
+      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));
+  EXPECT_TRUE(render_text->GetDecoratedWordAndBaselineAtPoint(
+      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));
+  EXPECT_FALSE(render_text->GetDecoratedWordAndBaselineAtPoint(
+      query, &decorated_word, &baseline_point));
 }
 
 // Tests text selection made at end points of individual lines of multiline
 // text.
 TEST_P(RenderTextHarfBuzzTest, LineEndSelections) {
   const wchar_t* const ltr = L"abc\n\ndef";
   const wchar_t* const rtl = L"\x5d0\x5d1\x5d2\n\n\x5d3\x5d4\x5d5";
   const int left_x = -100;
   const int right_x = 200;
   struct {
@@ skipping 83 matching lines @@
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 #endif
 
 INSTANTIATE_TEST_CASE_P(,
                         RenderTextHarfBuzzTest,
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 
 }  // namespace gfx