MacViews: Use bullets for displaying obscured text.

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 106 matching lines @@
  private:
   RenderText* render_text_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderTextTestApi);
 };
 
 }  // namespace test
 
 namespace {
 
+#if defined(OS_MACOSX)

[sky, 2016/10/21 15:06:41]

Move kPasswordReplacementChar to header so you aren't duplicating the define.

[karandeepb, 2016/10/24 12:09:54]

Done.

+const base::char16 kPasswordReplacementChar = 0x2022;
+#else
+const base::char16 kPasswordReplacementChar = '*';
+#endif
+
 // An enum specifying the different RenderText implementations to be tested.
 enum RenderTextBackend {
   RENDER_TEXT_HARFBUZZ,
   RENDER_TEXT_MAC,
 };
 
 // Parameterised test name generator for tests depending on RenderTextBackend.
 struct PrintRenderTextBackend {
   template <class ParamType>
   std::string operator()(const testing::TestParamInfo<ParamType>& info) const {
@@ skipping 139 matching lines @@
     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());
   }
 }
 
+// Helper method to return an obscured string of the given |length|, with the
+// |reveal_index| filled with |reveal_char|.
+base::string16 GetObscuredString(size_t length,
+                                 int reveal_index,
+                                 base::char16 reveal_char) {
+  std::vector<base::char16> arr(length, kPasswordReplacementChar);
+  arr[reveal_index] = reveal_char;
+  return base::string16(arr.begin(), arr.end());
+}
+
+// Helper method to return an obscured string of the given |length|.
+base::string16 GetObscuredString(size_t length) {
+  return base::string16(length, kPasswordReplacementChar);
+}
+
 // 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 432 matching lines @@
   render_text->MoveCursor(WORD_BREAK, CURSOR_RIGHT, selection_behavior);
   EXPECT_EQ(SelectionModel(Range(select ? 0 : len, len), CURSOR_FORWARD),
             render_text->selection_model());
   render_text->MoveCursor(WORD_BREAK, CURSOR_LEFT, selection_behavior);
   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
 }
 
 // TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
 TEST_P(RenderTextHarfBuzzTest, ObscuredText) {
   const base::string16 seuss = ASCIIToUTF16("hop on pop");
-  const base::string16 no_seuss = ASCIIToUTF16("**********");
+  const base::string16 no_seuss = GetObscuredString(seuss.length());
   RenderText* render_text = GetRenderText();
 
-  // GetLayoutText() returns asterisks when the obscured bit is set.
+  // GetDisplayText() returns a string filled with kPasswordReplacementChar when
+  // the obscured bit is set.
   render_text->SetText(seuss);
   render_text->SetObscured(true);
   EXPECT_EQ(seuss, render_text->text());
   EXPECT_EQ(no_seuss, render_text->GetDisplayText());
   render_text->SetObscured(false);
   EXPECT_EQ(seuss, render_text->text());
   EXPECT_EQ(seuss, render_text->GetDisplayText());
 
   render_text->SetObscured(true);
 
   // Surrogate pairs are counted as one code point.
   const base::char16 invalid_surrogates[] = {0xDC00, 0xD800, 0};
   render_text->SetText(invalid_surrogates);
-  EXPECT_EQ(ASCIIToUTF16("**"), render_text->GetDisplayText());
+  EXPECT_EQ(GetObscuredString(2), render_text->GetDisplayText());
   const base::char16 valid_surrogates[] = {0xD800, 0xDC00, 0};
   render_text->SetText(valid_surrogates);
-  EXPECT_EQ(ASCIIToUTF16("*"), render_text->GetDisplayText());
+  EXPECT_EQ(GetObscuredString(1), render_text->GetDisplayText());
   EXPECT_EQ(0U, render_text->cursor_position());
   render_text->MoveCursor(CHARACTER_BREAK, CURSOR_RIGHT, SELECTION_NONE);
   EXPECT_EQ(2U, render_text->cursor_position());
 
   // Test index conversion and cursor validity with a valid surrogate pair.
   EXPECT_EQ(0U, test_api()->TextIndexToDisplayIndex(0U));
   EXPECT_EQ(1U, test_api()->TextIndexToDisplayIndex(1U));
   EXPECT_EQ(1U, test_api()->TextIndexToDisplayIndex(2U));
   EXPECT_EQ(0U, test_api()->DisplayIndexToTextIndex(0U));
   EXPECT_EQ(2U, test_api()->DisplayIndexToTextIndex(1U));
@@ skipping 22 matching lines @@
   };
   for (size_t i = 0; i < arraysize(texts); ++i) {
     base::string16 text = WideToUTF16(texts[i]);
     TestVisualCursorMotionInObscuredField(render_text, text, SELECTION_NONE);
     TestVisualCursorMotionInObscuredField(render_text, text, SELECTION_RETAIN);
   }
 }
 
 TEST_P(RenderTextTest, RevealObscuredText) {
   const base::string16 seuss = ASCIIToUTF16("hop on pop");
-  const base::string16 no_seuss = ASCIIToUTF16("**********");
+  const base::string16 no_seuss = GetObscuredString(seuss.length());
   RenderText* render_text = GetRenderText();
 
   render_text->SetText(seuss);
   render_text->SetObscured(true);
   EXPECT_EQ(seuss, render_text->text());
   EXPECT_EQ(no_seuss, render_text->GetDisplayText());
 
   // Valid reveal index and new revealed index clears previous one.
   render_text->RenderText::SetObscuredRevealIndex(0);
-  EXPECT_EQ(ASCIIToUTF16("h*********"), render_text->GetDisplayText());
+  EXPECT_EQ(GetObscuredString(seuss.length(), 0, 'h'),
+            render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(1);
-  EXPECT_EQ(ASCIIToUTF16("*o********"), render_text->GetDisplayText());
+  EXPECT_EQ(GetObscuredString(seuss.length(), 1, 'o'),
+            render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(2);
-  EXPECT_EQ(ASCIIToUTF16("**p*******"), render_text->GetDisplayText());
+  EXPECT_EQ(GetObscuredString(seuss.length(), 2, 'p'),
+            render_text->GetDisplayText());
 
   // Invalid reveal index.
   render_text->RenderText::SetObscuredRevealIndex(-1);
   EXPECT_EQ(no_seuss, render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(seuss.length() + 1);
   EXPECT_EQ(no_seuss, render_text->GetDisplayText());
 
   // SetObscured clears the revealed index.
   render_text->RenderText::SetObscuredRevealIndex(0);
-  EXPECT_EQ(ASCIIToUTF16("h*********"), render_text->GetDisplayText());
+  EXPECT_EQ(GetObscuredString(seuss.length(), 0, 'h'),
+            render_text->GetDisplayText());
   render_text->SetObscured(false);
   EXPECT_EQ(seuss, render_text->GetDisplayText());
   render_text->SetObscured(true);
   EXPECT_EQ(no_seuss, render_text->GetDisplayText());
 
   // SetText clears the revealed index.
   render_text->SetText(ASCIIToUTF16("new"));
-  EXPECT_EQ(ASCIIToUTF16("***"), render_text->GetDisplayText());
+  EXPECT_EQ(GetObscuredString(3), render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(2);
-  EXPECT_EQ(ASCIIToUTF16("**w"), render_text->GetDisplayText());
+  EXPECT_EQ(GetObscuredString(3, 2, 'w'), render_text->GetDisplayText());
   render_text->SetText(ASCIIToUTF16("new longer"));
-  EXPECT_EQ(ASCIIToUTF16("**********"), render_text->GetDisplayText());
+  EXPECT_EQ(GetObscuredString(10), render_text->GetDisplayText());
 
   // Text with invalid surrogates.
   const base::char16 invalid_surrogates[] = {0xDC00, 0xD800, 'h', 'o', 'p', 0};
   render_text->SetText(invalid_surrogates);
-  EXPECT_EQ(ASCIIToUTF16("*****"), render_text->GetDisplayText());
+  EXPECT_EQ(GetObscuredString(5), render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(0);
-  const base::char16 invalid_expect_0[] = {0xDC00, '*', '*', '*', '*', 0};
-  EXPECT_EQ(invalid_expect_0, render_text->GetDisplayText());
+  EXPECT_EQ(GetObscuredString(5, 0, 0xDC00), render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(1);
-  const base::char16 invalid_expect_1[] = {'*', 0xD800, '*', '*', '*', 0};
-  EXPECT_EQ(invalid_expect_1, render_text->GetDisplayText());
+  EXPECT_EQ(GetObscuredString(5, 1, 0xD800), render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(2);
-  EXPECT_EQ(ASCIIToUTF16("**h**"), render_text->GetDisplayText());
+  EXPECT_EQ(GetObscuredString(5, 2, 'h'), render_text->GetDisplayText());
 
   // Text with valid surrogates before and after the reveal index.
   const base::char16 valid_surrogates[] =
       {0xD800, 0xDC00, 'h', 'o', 'p', 0xD800, 0xDC00, 0};
   render_text->SetText(valid_surrogates);
-  EXPECT_EQ(ASCIIToUTF16("*****"), render_text->GetDisplayText());
+  EXPECT_EQ(GetObscuredString(5), render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(0);
-  const base::char16 valid_expect_0_and_1[] =
-      {0xD800, 0xDC00, '*', '*', '*', '*', 0};
+  const base::char16 valid_expect_0_and_1[] = {0xD800,
+                                               0xDC00,
+                                               kPasswordReplacementChar,
+                                               kPasswordReplacementChar,
+                                               kPasswordReplacementChar,
+                                               kPasswordReplacementChar,
+                                               0};
   EXPECT_EQ(valid_expect_0_and_1, render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(1);
   EXPECT_EQ(valid_expect_0_and_1, render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(2);
-  EXPECT_EQ(ASCIIToUTF16("*h***"), render_text->GetDisplayText());
+  EXPECT_EQ(GetObscuredString(5, 1, 'h'), render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(5);
-  const base::char16 valid_expect_5_and_6[] =
-      {'*', '*', '*', '*', 0xD800, 0xDC00, 0};
+  const base::char16 valid_expect_5_and_6[] = {kPasswordReplacementChar,
+                                               kPasswordReplacementChar,
+                                               kPasswordReplacementChar,
+                                               kPasswordReplacementChar,
+                                               0xD800,
+                                               0xDC00,
+                                               0};
   EXPECT_EQ(valid_expect_5_and_6, render_text->GetDisplayText());
   render_text->RenderText::SetObscuredRevealIndex(6);
   EXPECT_EQ(valid_expect_5_and_6, render_text->GetDisplayText());
 }
 
 TEST_P(RenderTextTest, ObscuredEmoji) {
   // Ensures text itemization doesn't crash on obscured multi-char glyphs.
   RenderText* render_text = GetRenderText();
   render_text->SetObscured(true);
   // Test the "Grinning face with smiling eyes" character followed by 'y'.
@@ skipping 218 matching lines @@
         << "For case " << i << ": " << cases[i].text;
   }
 }
 
 TEST_P(RenderTextTest, TruncatedObscuredText) {
   RenderText* render_text = GetRenderText();
   render_text->set_truncate_length(3);
   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->GetDisplayText());
+  EXPECT_EQ(GetObscuredString(3, 2, 0x2026), render_text->GetDisplayText());
 }
 
 // TODO(asvitkine): RenderTextMac cursor movements. http://crbug.com/131618
 TEST_P(RenderTextHarfBuzzTest, TruncatedCursorMovementLTR) {
   RenderText* render_text = GetRenderText();
   render_text->set_truncate_length(2);
   render_text->SetText(WideToUTF16(L"abcd"));
 
   EXPECT_EQ(SelectionModel(0, CURSOR_BACKWARD), render_text->selection_model());
   render_text->MoveCursor(LINE_BREAK, CURSOR_RIGHT, SELECTION_NONE);
@@ skipping 2947 matching lines @@
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 #endif
 
 INSTANTIATE_TEST_CASE_P(,
                         RenderTextHarfBuzzTest,
                         ::testing::Values(RENDER_TEXT_HARFBUZZ),
                         PrintRenderTextBackend());
 
 }  // namespace gfx