Password support for NativeTextfieldViews, in the model

ui/views/controls/textfield/textfield_views_model.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/views/controls/textfield/textfield_views_model.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
+#include "base/utf_offset_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 #include "ui/base/range/range.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/render_text.h"
 #include "ui/views/controls/textfield/textfield.h"
 #include "ui/views/views_delegate.h"
 
 namespace views {
 
 namespace internal {
 
+// 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 kPasswordReplacementChar = '*';
+
 // An edit object holds enough information/state to undo/redo the
 // change. Two edits are merged when possible, for example, when
 // you type new characters in sequence.  |Commit()| can be used to
 // mark an edit as an independent edit and it shouldn't be merged.
 // (For example, when you did undo/redo, or a text is appended via
 // API)
 class Edit {
  public:
   enum Type {
     INSERT_EDIT,
@@ skipping 246 matching lines @@
     : delegate_(delegate),
       render_text_(gfx::RenderText::CreateRenderText()),
       current_edit_(edit_history_.end()) {
 }
 
 TextfieldViewsModel::~TextfieldViewsModel() {
   ClearEditHistory();
   ClearComposition();
 }
 
-const string16& TextfieldViewsModel::GetText() const {
-  return render_text_->text();
-}
-
 bool TextfieldViewsModel::SetText(const string16& text) {
   bool changed = false;
   if (HasCompositionText()) {
     ConfirmCompositionText();
     changed = true;
   }
   if (GetText() != text) {
     if (changed)  // No need to remember composition.
       Undo();
     size_t old_cursor = GetCursorPosition();
     size_t new_cursor = old_cursor > text.length() ? text.length() : old_cursor;
     SelectAll();
     // If there is a composition text, don't merge with previous edit.
     // Otherwise, force merge the edits.
     ExecuteAndRecordReplace(
         changed ? DO_NOT_MERGE : MERGE_WITH_PREVIOUS,
         old_cursor,
         new_cursor,
         text,
         0U);
-    render_text_->SetCursorPosition(new_cursor);
+    render_text_->SetCursorPosition(ToDisplayIndex(new_cursor));
   }
   ClearSelection();
   return changed;
 }
 
+void TextfieldViewsModel::SetObscured(bool obscured) {
+  if (obscured != obscured_) {
+    obscured_ = obscured;
+    render_text_->SetText(GetDisplayText());
+  }
+}
+
 void TextfieldViewsModel::Append(const string16& text) {
   if (HasCompositionText())
     ConfirmCompositionText();
-  size_t save = GetCursorPosition();
+  size_t save = render_text_->GetCursorPosition();
   MoveCursor(gfx::LINE_BREAK,
              render_text_->GetVisualDirectionOfLogicalEnd(),
              false);
   InsertText(text);
   render_text_->SetCursorPosition(save);
   ClearSelection();
 }
 
 bool TextfieldViewsModel::Delete() {
   if (HasCompositionText()) {
     // No undo/redo for composition text.
     CancelCompositionText();
     return true;
   }
   if (HasSelection()) {
     DeleteSelection();
     return true;
   }
   if (GetText().length() > GetCursorPosition()) {
     size_t cursor_position = GetCursorPosition();
-    size_t next_grapheme_index = render_text_->IndexOfAdjacentGrapheme(
-        cursor_position, gfx::CURSOR_FORWARD);
+    size_t next_grapheme_index =
+        FromDisplayIndex(render_text_->IndexOfAdjacentGrapheme(
+            ToDisplayIndex(cursor_position), gfx::CURSOR_FORWARD));
     ExecuteAndRecordDelete(cursor_position, next_grapheme_index, true);
     return true;
   }
   return false;
 }
 
 bool TextfieldViewsModel::Backspace() {
   if (HasCompositionText()) {
     // No undo/redo for composition text.
     CancelCompositionText();
     return true;
   }
   if (HasSelection()) {
     DeleteSelection();
     return true;
   }
-  if (GetCursorPosition() > 0) {
-    size_t cursor_position = GetCursorPosition();
-    ExecuteAndRecordDelete(cursor_position, cursor_position - 1, true);
+  size_t cursor_position = GetCursorPosition();
+  if (cursor_position > 0) {
+    size_t previous_char = Utf16OffsetToIndex(GetText(), cursor_position, -1);
+    ExecuteAndRecordDelete(cursor_position, previous_char, true);
     return true;
   }
   return false;
 }
 
 size_t TextfieldViewsModel::GetCursorPosition() const {
-  return render_text_->GetCursorPosition();
+  return FromDisplayIndex(render_text_->GetCursorPosition());
 }
 
 void TextfieldViewsModel::MoveCursor(gfx::BreakType break_type,
                                      gfx::VisualCursorDirection direction,
                                      bool select) {
   if (HasCompositionText())
     ConfirmCompositionText();
   render_text_->MoveCursor(break_type, direction, select);
 }
 
-bool TextfieldViewsModel::MoveCursorTo(const gfx::SelectionModel& selection) {
+bool TextfieldViewsModel::MoveCursorTo(const gfx::SelectionModel& sel) {
+  gfx::SelectionModel selection = ToDisplaySelection(sel);
   if (HasCompositionText()) {
     ConfirmCompositionText();
     // ConfirmCompositionText() updates cursor position. Need to reflect it in
     // the SelectionModel parameter of MoveCursorTo().
     if (render_text_->GetSelectionStart() != selection.selection_end())
       return render_text_->SelectRange(ui::Range(
           render_text_->GetSelectionStart(), selection.selection_end()));
     gfx::SelectionModel sel(selection.selection_end(),
                             selection.caret_pos(),
                             selection.caret_placement());
     return render_text_->MoveCursorTo(sel);
   }
   return render_text_->MoveCursorTo(selection);
 }
 
 bool TextfieldViewsModel::MoveCursorTo(const gfx::Point& point, bool select) {
   if (HasCompositionText())
     ConfirmCompositionText();
   return render_text_->MoveCursorTo(point, select);
 }
 
 string16 TextfieldViewsModel::GetSelectedText() const {
-  return GetText().substr(render_text_->MinOfSelection(),
-      (render_text_->MaxOfSelection() - render_text_->MinOfSelection()));
+  size_t lo = FromDisplayIndex(render_text_->MinOfSelection());
+  size_t hi = FromDisplayIndex(render_text_->MaxOfSelection());
+  return GetText().substr(lo, hi - lo);
 }
 
 void TextfieldViewsModel::GetSelectedRange(ui::Range* range) const {
-  range->set_start(render_text_->GetSelectionStart());
-  range->set_end(render_text_->GetCursorPosition());
+  *range = FromDisplayRange(ui::Range(
+      render_text_->GetSelectionStart(), render_text_->GetCursorPosition()));
 }
 
 void TextfieldViewsModel::SelectRange(const ui::Range& range) {
   if (HasCompositionText())
     ConfirmCompositionText();
-  render_text_->SelectRange(range);
+  render_text_->SelectRange(ToDisplayRange(range));
 }
 
 void TextfieldViewsModel::GetSelectionModel(gfx::SelectionModel* sel) const {
-  *sel = render_text_->selection_model();
+  *sel = FromDisplaySelection(render_text_->selection_model());
 }
 
 void TextfieldViewsModel::SelectSelectionModel(const gfx::SelectionModel& sel) {
   if (HasCompositionText())
     ConfirmCompositionText();
-  render_text_->MoveCursorTo(sel);
+  render_text_->MoveCursorTo(ToDisplaySelection(sel));
 }
 
 void TextfieldViewsModel::SelectAll() {
   if (HasCompositionText())
     ConfirmCompositionText();
   render_text_->SelectAll();
 }
 
 void TextfieldViewsModel::SelectWord() {
   if (HasCompositionText())
@@ skipping 51 matching lines @@
     current_edit_ = edit_history_.begin();
   else
     current_edit_ ++;
   string16 old = GetText();
   size_t old_cursor = GetCursorPosition();
   (*current_edit_)->Redo(this);
   return old != GetText() || old_cursor != GetCursorPosition();
 }
 
 bool TextfieldViewsModel::Cut() {
-  if (!HasCompositionText() && HasSelection()) {
+  if (!HasCompositionText() && HasSelection() && !is_obscured()) {
     ui::ScopedClipboardWriter(views::ViewsDelegate::views_delegate
         ->GetClipboard()).WriteText(GetSelectedText());
     // A trick to let undo/redo handle cursor correctly.
     // Undoing CUT moves the cursor to the end of the change rather
     // than beginning, unlike Delete/Backspace.
     // TODO(oshima): Change Delete/Backspace to use DeleteSelection,
     // update DeleteEdit and remove this trick.
     render_text_->SelectRange(ui::Range(render_text_->GetCursorPosition(),
                                         render_text_->GetSelectionStart()));
     DeleteSelection();
     return true;
   }
   return false;
 }
 
 bool TextfieldViewsModel::Copy() {
-  if (!HasCompositionText() && HasSelection()) {
+  if (!HasCompositionText() && HasSelection() && !is_obscured()) {
     ui::ScopedClipboardWriter(views::ViewsDelegate::views_delegate
         ->GetClipboard()).WriteText(GetSelectedText());
     return true;
   }
   return false;
 }
 
 bool TextfieldViewsModel::Paste() {
   string16 result;
   views::ViewsDelegate::views_delegate->GetClipboard()
       ->ReadText(ui::Clipboard::BUFFER_STANDARD, &result);
   if (!result.empty()) {
     InsertTextInternal(result, false);
     return true;
   }
   return false;
 }
 
 bool TextfieldViewsModel::HasSelection() const {
   return !render_text_->EmptySelection();
 }
 
 void TextfieldViewsModel::DeleteSelection() {
   DCHECK(!HasCompositionText());
   DCHECK(HasSelection());
-  ExecuteAndRecordDelete(render_text_->GetSelectionStart(),
-                         render_text_->GetCursorPosition(), false);
+  ExecuteAndRecordDelete(FromDisplayIndex(render_text_->GetSelectionStart()),
+                         FromDisplayIndex(render_text_->GetCursorPosition()),
+                         false);
 }
 
 void TextfieldViewsModel::DeleteSelectionAndInsertTextAt(
     const string16& text, size_t position) {
   if (HasCompositionText())
     CancelCompositionText();
   ExecuteAndRecordReplace(DO_NOT_MERGE,
                           GetCursorPosition(),
                           position + text.length(),
                           text,
@@ skipping 15 matching lines @@
   if (HasCompositionText())
     CancelCompositionText();
   else if (HasSelection())
     DeleteSelection();
 
   if (composition.text.empty())
     return;
 
   size_t cursor = GetCursorPosition();
   string16 new_text = GetText();
-  render_text_->SetText(new_text.insert(cursor, composition.text));
+  SetTextInternal(new_text.insert(cursor, composition.text));
   ui::Range range(cursor, cursor + composition.text.length());
-  render_text_->SetCompositionRange(range);
+  render_text_->SetCompositionRange(ToDisplayRange(range));
   // TODO(msw): Support multiple composition underline ranges.
 
   if (composition.selection.IsValid()) {
     size_t start =
         std::min(range.start() + composition.selection.start(), range.end());
     size_t end =
         std::min(range.start() + composition.selection.end(), range.end());
-    render_text_->SelectRange(ui::Range(start, end));
+    render_text_->SelectRange(ToDisplayRange(ui::Range(start, end)));
   } else {
-    render_text_->SetCursorPosition(range.end());
+    render_text_->SetCursorPosition(ToDisplayIndex(range.end()));
   }
 }
 
 void TextfieldViewsModel::ConfirmCompositionText() {
   DCHECK(HasCompositionText());
-  ui::Range range = render_text_->GetCompositionRange();
+  ui::Range range = FromDisplayRange(render_text_->GetCompositionRange());
   string16 text = GetText().substr(range.start(), range.length());
   // TODO(oshima): current behavior on ChromeOS is a bit weird and not
   // sure exactly how this should work. Find out and fix if necessary.
   AddOrMergeEditHistory(new InsertEdit(false, text, range.start()));
-  render_text_->SetCursorPosition(range.end());
+  render_text_->SetCursorPosition(ToDisplayIndex(range.end()));
   ClearComposition();
   if (delegate_)
     delegate_->OnCompositionTextConfirmedOrCleared();
 }
 
 void TextfieldViewsModel::CancelCompositionText() {
   DCHECK(HasCompositionText());
-  ui::Range range = render_text_->GetCompositionRange();
+  ui::Range range = FromDisplayRange(render_text_->GetCompositionRange());
   ClearComposition();
   string16 new_text = GetText();
-  render_text_->SetText(new_text.erase(range.start(), range.length()));
-  render_text_->SetCursorPosition(range.start());
+  SetTextInternal(new_text.erase(range.start(), range.length()));
+  render_text_->SetCursorPosition(ToDisplayIndex(range.start()));
   if (delegate_)
     delegate_->OnCompositionTextConfirmedOrCleared();
 }
 
 void TextfieldViewsModel::ClearComposition() {
   render_text_->SetCompositionRange(ui::Range::InvalidRange());
 }
 
 void TextfieldViewsModel::GetCompositionTextRange(ui::Range* range) const {
-  *range = ui::Range(render_text_->GetCompositionRange());
+  *range = ui::Range(FromDisplayRange(render_text_->GetCompositionRange()));
 }
 
 bool TextfieldViewsModel::HasCompositionText() const {
   return !render_text_->GetCompositionRange().is_empty();
 }
 
 /////////////////////////////////////////////////////////////////
 // TextfieldViewsModel: private
 
 void TextfieldViewsModel::InsertTextInternal(const string16& text,
@@ skipping 58 matching lines @@
   bool backward = from > to;
   Edit* edit = new DeleteEdit(mergeable, text, old_text_start, backward);
   bool delete_edit = AddOrMergeEditHistory(edit);
   edit->Redo(this);
   if (delete_edit)
     delete edit;
 }
 
 void TextfieldViewsModel::ExecuteAndRecordReplaceSelection(
     MergeType merge_type, const string16& new_text) {
-  size_t new_text_start = render_text_->MinOfSelection();
+  size_t new_text_start = FromDisplayIndex(render_text_->MinOfSelection());
   size_t new_cursor_pos = new_text_start + new_text.length();
   ExecuteAndRecordReplace(merge_type,
                           GetCursorPosition(),
                           new_cursor_pos,
                           new_text,
                           new_text_start);
 }
 
 void TextfieldViewsModel::ExecuteAndRecordReplace(MergeType merge_type,
                                                   size_t old_cursor_pos,
                                                   size_t new_cursor_pos,
                                                   const string16& new_text,
                                                   size_t new_text_start) {
-  size_t old_text_start = render_text_->MinOfSelection();
+  size_t old_text_start = FromDisplayIndex(render_text_->MinOfSelection());
   bool backward =
       render_text_->GetSelectionStart() > render_text_->GetCursorPosition();
   Edit* edit = new ReplaceEdit(merge_type,
                                GetSelectedText(),
                                old_cursor_pos,
                                old_text_start,
                                backward,
                                new_cursor_pos,
                                new_text,
                                new_text_start);
@@ skipping 35 matching lines @@
 
 void TextfieldViewsModel::ModifyText(size_t delete_from,
                                      size_t delete_to,
                                      const string16& new_text,
                                      size_t new_text_insert_at,
                                      size_t new_cursor_pos) {
   DCHECK_LE(delete_from, delete_to);
   string16 text = GetText();
   ClearComposition();
   if (delete_from != delete_to)
-    render_text_->SetText(text.erase(delete_from, delete_to - delete_from));
+    SetTextInternal(text.erase(delete_from, delete_to - delete_from));
   if (!new_text.empty())
-    render_text_->SetText(text.insert(new_text_insert_at, new_text));
-  render_text_->SetCursorPosition(new_cursor_pos);
+    SetTextInternal(text.insert(new_text_insert_at, new_text));
+  render_text_->SetCursorPosition(ToDisplayIndex(new_cursor_pos));
   // TODO(oshima): mac selects the text that is just undone (but gtk doesn't).
   // This looks fine feature and we may want to do the same.
 }
 
+void TextfieldViewsModel::SetTextInternal(const string16& new_text) {
+  text_ = new_text;
+  render_text_->SetText(GetDisplayText());
+}
+
+string16 TextfieldViewsModel::GetDisplayText() const {
+  if (!obscured_)
+    return text_;
+  size_t obscured_text_length =
+      static_cast<size_t>(Utf16IndexToOffset(text_, 0, text_.length()));
+  return string16(obscured_text_length, internal::kPasswordReplacementChar);
+}
+
+size_t TextfieldViewsModel::FromDisplayIndex(size_t index) const {
+  if (!is_obscured())
+    return index;
+  return Utf16OffsetToIndex(GetText(), 0, index);
+}
+size_t TextfieldViewsModel::ToDisplayIndex(size_t index) const {
+  if (!is_obscured())
+    return index;
+  return Utf16IndexToOffset(GetText(), 0, index);
+}
+ui::Range TextfieldViewsModel::FromDisplayRange(ui::Range range) const {
+  if (!is_obscured() || !range.IsValid())
+    return range;
+  return ui::Range(FromDisplayIndex(range.start()),
+                   FromDisplayIndex(range.end()));
+}
+ui::Range TextfieldViewsModel::ToDisplayRange(ui::Range range) const {
+  if (!is_obscured() || !range.IsValid())
+    return range;
+  return ui::Range(ToDisplayIndex(range.start()),
+                   ToDisplayIndex(range.end()));
+}
+gfx::SelectionModel TextfieldViewsModel::FromDisplaySelection(
+    const gfx::SelectionModel& model) const {
+  return gfx::SelectionModel(FromDisplayIndex(model.selection_start()),
+                             FromDisplayIndex(model.selection_end()),
+                             FromDisplayIndex(model.caret_pos()),
+                             model.caret_placement());
+}
+gfx::SelectionModel TextfieldViewsModel::ToDisplaySelection(
+    const gfx::SelectionModel& model) const {
+  return gfx::SelectionModel(ToDisplayIndex(model.selection_start()),
+                             ToDisplayIndex(model.selection_end()),
+                             ToDisplayIndex(model.caret_pos()),
+                             model.caret_placement());
+}
+
 }  // namespace views