Reintroduce password support to NativeTextfieldViews

ui/gfx/render_text.cc

 // Copyright (c) 2011 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/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/canvas_skia.h"
 #include "unicode/uchar.h"
 
 namespace {
 
+// All chars are replaced by this char when the password style is set.
+// TODO(benrg): GTK uses the first of U+25CF, U+2022, U+2731, U+273A, '*'
+// that's available in the font (find_invisible_char() in gtkentry.c).
+const char16 PASSWORD_REPLACEMENT_CHAR = '*';

[msw, 2011/12/03 00:22:40]

Is this the correct style for a const char identifier?
I would have guess it'd be kPasswordReplacementChar.

[benrg, 2011/12/06 17:21:30]

Done. (I misremembered the coding guidelines.)

+
+// Color settings for text, backgrounds and cursor.
+// These are tentative, and should be derived from theme, system
+// settings and current settings.
+// TODO(oshima): Change this to match the standard chrome
+// before dogfooding textfield views.
+const SkColor kSelectedTextColor = SK_ColorWHITE;
+const SkColor kFocusedSelectionColor = SkColorSetRGB(30, 144, 255);
+const SkColor kUnfocusedSelectionColor = SK_ColorLTGRAY;
+const SkColor kCursorColor = SK_ColorBLACK;
+
 #ifndef NDEBUG
 // Check StyleRanges invariant conditions: sorted and non-overlapping ranges.
 void CheckStyleRanges(const gfx::StyleRanges& style_ranges, size_t length) {
   if (length == 0) {
     DCHECK(style_ranges.empty()) << "Style ranges exist for empty text.";
     return;
   }
   for (gfx::StyleRanges::size_type i = 0; i < style_ranges.size() - 1; i++) {
     const ui::Range& former = style_ranges[i].range;
     const ui::Range& latter = style_ranges[i + 1].range;
@@ skipping 92 matching lines @@
 #endif
   cached_bounds_and_offset_valid_ = false;
 
   // Reset selection model. SetText should always followed by SetSelectionModel
   // or SetCursorPosition in upper layer.
   SetSelectionModel(SelectionModel(0, 0, SelectionModel::LEADING));
 
   UpdateLayout();
 }
 
+string16 RenderText::GetCensoredText() const {
+  string16 txt = text();
+  if (password_) {
+    // TODO(benrg): There should probably be one bullet/asterisk per
+    // cursorable character, not one per UTF-16 word. However, I'm not sure
+    // it's worth the effort. GTK appears to use one per code point. Do people
+    // use non-BMP code points and combining diacritics in their passwords?
+    std::fill(txt.begin(), txt.end(), PASSWORD_REPLACEMENT_CHAR);
+  }
+  return txt;
+}
+
 void RenderText::ToggleInsertMode() {
   insert_mode_ = !insert_mode_;
   cached_bounds_and_offset_valid_ = false;
 }
 
+void RenderText::SetIsPassword(bool password) {
+  password_ = password;
+  cached_bounds_and_offset_valid_ = false;
+  UpdateLayout();
+}
+
 void RenderText::SetDisplayRect(const Rect& r) {
   display_rect_ = r;
   cached_bounds_and_offset_valid_ = false;
   UpdateLayout();
 }
 
 size_t RenderText::GetCursorPosition() const {
   return selection_model_.selection_end();
 }
 
@@ skipping 121 matching lines @@
 
 void RenderText::SelectAll() {
   SelectionModel sel(RightEndSelectionModel());
   sel.set_selection_start(LeftEndSelectionModel().selection_start());
   SetSelectionModel(sel);
 }
 
 void RenderText::SelectWord() {
   size_t cursor_position = GetCursorPosition();
 
-  base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD);
+  string16 txt = GetCensoredText();
+  base::i18n::BreakIterator iter(txt, base::i18n::BreakIterator::BREAK_WORD);
   bool success = iter.Init();
   DCHECK(success);
   if (!success)
     return;
 
   size_t selection_start = cursor_position;
   for (; selection_start != 0; --selection_start) {
     if (iter.IsStartOfWord(selection_start) ||
         iter.IsEndOfWord(selection_start))
       break;
   }
 
   if (selection_start == cursor_position)
     ++cursor_position;
 
-  for (; cursor_position < text().length(); ++cursor_position) {
+  for (; cursor_position < txt.length(); ++cursor_position) {
     if (iter.IsEndOfWord(cursor_position) ||
         iter.IsStartOfWord(cursor_position))
       break;
   }
 
   MoveCursorTo(selection_start, false);
   MoveCursorTo(cursor_position, true);
 }
 
 const ui::Range& RenderText::GetCompositionRange() const {
@@ skipping 32 matching lines @@
   UpdateLayout();
 }
 
 base::i18n::TextDirection RenderText::GetTextDirection() {
   if (base::i18n::IsRTL())
     return base::i18n::RIGHT_TO_LEFT;
   return base::i18n::LEFT_TO_RIGHT;
 }
 
 int RenderText::GetStringWidth() {
   return default_style_.font.GetStringWidth(text());

[msw, 2011/12/03 00:22:40]

Shouldn't this use GetCensoredText()?

[xji, 2011/12/06 01:24:04]

guess since it could be pure virtual, it does not make differences here. but it
is consistent to change them too.

[benrg, 2011/12/06 17:21:30]

This code is dead, see below.

 }
 
 void RenderText::Draw(Canvas* canvas) {
   EnsureLayout();
 
   if (!text().empty()) {
     DrawSelection(canvas);
     DrawVisualText(canvas);
   }
   DrawCursor(canvas);
 }
 
 SelectionModel RenderText::FindCursorPosition(const Point& point) {
   const Font& font = default_style_.font;
   int left = 0;
   int left_pos = 0;
   int right = font.GetStringWidth(text());

[msw, 2011/12/03 00:22:40]

Shouldn't this use GetCensoredText()?

[benrg, 2011/12/06 17:21:30]

This code is dead and seems unlikely to ever be resurrected (it's not
bidi-aware). Originally this CL deleted it. Then, because there was so much dead
code, I split it into a separate CL (issue 8742004). Then issue 8536047 landed,
making 8742004 obsolete. But it looks like 8536047 didn't remove all of the dead
code. I'll just delete RenderText::GetStringWidth and
RenderText::FindCursorPosition in this CL unless there's a reason not to.

   int right_pos = text().length();
 
   int x = point.x() - (display_rect_.x() + GetUpdatedDisplayOffset().x());
   if (x <= left) return SelectionModel(left_pos);
   if (x >= right) return SelectionModel(right_pos);
   // binary searching the cursor position.
   // TODO(oshima): use the center of character instead of edge.
   // Binary search may not work for language like Arabic.
   while (std::abs(static_cast<long>(right_pos - left_pos)) > 1) {
     int pivot_pos = left_pos + (right_pos - left_pos) / 2;
     int pivot = font.GetStringWidth(text().substr(0, pivot_pos));

[msw, 2011/12/03 00:22:40]

Shouldn't this use GetCensoredText()?

     if (pivot < x) {
       left = pivot;
       left_pos = pivot_pos;
     } else if (pivot == x) {
       return SelectionModel(pivot_pos);
     } else {
       right = pivot;
       right_pos = pivot_pos;
     }
   }
@@ skipping 25 matching lines @@
 
 RenderText::RenderText()
     : text_(),
       selection_model_(),
       cursor_bounds_(),
       cursor_visible_(false),
       insert_mode_(true),
       composition_range_(ui::Range::InvalidRange()),
       style_ranges_(),
       default_style_(),
+      password_(false),
       display_rect_(),
       display_offset_(),
       cached_bounds_and_offset_valid_(false) {
 }
 
 const Point& RenderText::GetUpdatedDisplayOffset() {
   UpdateCachedBoundsAndOffset();
   return display_offset_;
 }
 
 SelectionModel RenderText::GetLeftSelectionModel(const SelectionModel& current,
                                                  BreakType break_type) {
   if (break_type == LINE_BREAK)
     return LeftEndSelectionModel();
   size_t pos = std::max(static_cast<long>(current.selection_end() - 1),
                         static_cast<long>(0));
   if (break_type == CHARACTER_BREAK)
     return SelectionModel(pos, pos, SelectionModel::LEADING);
 
   // Notes: We always iterate words from the beginning.
   // This is probably fast enough for our usage, but we may
   // want to modify WordIterator so that it can start from the
   // middle of string and advance backwards.
-  base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD);
+  string16 txt = GetCensoredText();
+  base::i18n::BreakIterator iter(txt, base::i18n::BreakIterator::BREAK_WORD);
   bool success = iter.Init();
   DCHECK(success);
   if (!success)
     return current;
   while (iter.Advance()) {
     if (iter.IsWord()) {
       size_t begin = iter.pos() - iter.GetString().length();
       if (begin == current.selection_end()) {
         // The cursor is at the beginning of a word.
         // Move to previous word.
@@ skipping 15 matching lines @@
 SelectionModel RenderText::GetRightSelectionModel(const SelectionModel& current,
                                                   BreakType break_type) {
   if (text_.empty())
     return SelectionModel(0, 0, SelectionModel::LEADING);
   if (break_type == LINE_BREAK)
     return RightEndSelectionModel();
   size_t pos = std::min(current.selection_end() + 1, text().length());
   if (break_type == CHARACTER_BREAK)
     return SelectionModel(pos, pos, SelectionModel::LEADING);
 
-  base::i18n::BreakIterator iter(text(), base::i18n::BreakIterator::BREAK_WORD);
+  string16 txt = GetCensoredText();
+  base::i18n::BreakIterator iter(txt, base::i18n::BreakIterator::BREAK_WORD);
   bool success = iter.Init();
   DCHECK(success);
   if (!success)
     return current;
   while (iter.Advance()) {
     pos = iter.pos();
     if (iter.IsWord() && pos > current.selection_end())
       break;
   }
   return SelectionModel(pos, pos, SelectionModel::LEADING);
@@ skipping 122 matching lines @@
 void RenderText::DrawCursor(Canvas* canvas) {
   // Paint cursor. Replace cursor is drawn as rectangle for now.
   // TODO(msw): Draw a better cursor with a better indication of association.
   if (cursor_visible() && focused()) {
     Rect r(GetUpdatedCursorBounds());
     canvas->DrawRectInt(kCursorColor, r.x(), r.y(), r.width(), r.height());
   }
 }
 
 }  // namespace gfx