Views Textfield fixes and cleanup.

ui/views/controls/textfield/textfield.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.h"
 
 #include <string>
 
 #include "base/debug/trace_event.h"
-#include "base/i18n/case_conversion.h"
 #include "grit/ui_strings.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/dragdrop/drag_utils.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_switches_util.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/insets.h"
@@ skipping 47 matching lines @@
   static const size_t system_value = ::GetCaretBlinkTime();
   if (system_value != 0)
     return (system_value == INFINITE) ? 0 : system_value;
 #endif
   return default_value;
 }
 
 Textfield::Textfield()
     : model_(new TextfieldModel(this)),
       controller_(NULL),
-      style_(STYLE_DEFAULT),
       read_only_(false),
       default_width_in_chars_(0),
       text_color_(SK_ColorBLACK),
       use_default_text_color_(true),
       background_color_(SK_ColorWHITE),
       use_default_background_color_(true),
       placeholder_text_color_(kDefaultPlaceholderTextColor),
       text_input_type_(ui::TEXT_INPUT_TYPE_TEXT),
       skip_input_method_cancel_composition_(false),
       cursor_visible_(false),
       drop_cursor_visible_(false),
       initiating_drag_(false),
       aggregated_clicks_(0),
       weak_ptr_factory_(this) {
   set_context_menu_controller(this);
   set_drag_controller(this);
   set_border(new FocusableBorder());
   SetFocusable(true);
 
   if (ViewsDelegate::views_delegate) {
-    obscured_reveal_duration_ = ViewsDelegate::views_delegate->
+    password_reveal_duration_ = ViewsDelegate::views_delegate->
         GetDefaultTextfieldObscuredRevealDuration();
   }
 
   if (NativeViewHost::kRenderNativeControlFocus)
     focus_painter_ = Painter::CreateDashedFocusPainter();
 }
 
-Textfield::Textfield(StyleFlags style)
-    : model_(new TextfieldModel(this)),
-      controller_(NULL),
-      style_(style),
-      read_only_(false),
-      default_width_in_chars_(0),
-      text_color_(SK_ColorBLACK),
-      use_default_text_color_(true),
-      background_color_(SK_ColorWHITE),
-      use_default_background_color_(true),
-      placeholder_text_color_(kDefaultPlaceholderTextColor),
-      text_input_type_(ui::TEXT_INPUT_TYPE_TEXT),
-      skip_input_method_cancel_composition_(false),
-      cursor_visible_(false),
-      drop_cursor_visible_(false),
-      initiating_drag_(false),
-      aggregated_clicks_(0),
-      weak_ptr_factory_(this) {
-  set_context_menu_controller(this);
-  set_drag_controller(this);
-  set_border(new FocusableBorder());
-  SetFocusable(true);
-
-  if (IsObscured())
-    SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
-
-  if (ViewsDelegate::views_delegate) {
-    obscured_reveal_duration_ = ViewsDelegate::views_delegate->
-        GetDefaultTextfieldObscuredRevealDuration();
-  }
-
-  if (NativeViewHost::kRenderNativeControlFocus)
-    focus_painter_ = Painter::CreateDashedFocusPainter();
-}
-
-Textfield::~Textfield() {
-}
-
-void Textfield::SetController(TextfieldController* controller) {
-  controller_ = controller;
-}
-
-TextfieldController* Textfield::GetController() const {
-  return controller_;
-}
+Textfield::~Textfield() {}
 
 void Textfield::SetReadOnly(bool read_only) {
   // Update read-only without changing the focusable state (or active, etc.).
   read_only_ = read_only;
   if (GetInputMethod())
     GetInputMethod()->OnTextInputTypeChanged(this);
   SetColor(GetTextColor());
   UpdateBackgroundColor();
 }
 
-bool Textfield::IsObscured() const {
-  return style_ & STYLE_OBSCURED;
-}
-
-void Textfield::SetObscured(bool obscured) {
-  if (obscured) {
-    style_ = static_cast<StyleFlags>(style_ | STYLE_OBSCURED);
-    SetTextInputType(ui::TEXT_INPUT_TYPE_PASSWORD);
-  } else {
-    style_ = static_cast<StyleFlags>(style_ & ~STYLE_OBSCURED);
-    SetTextInputType(ui::TEXT_INPUT_TYPE_TEXT);
-  }
-  GetRenderText()->SetObscured(obscured);
+void Textfield::SetTextInputType(ui::TextInputType type) {
+  GetRenderText()->SetObscured(type == ui::TEXT_INPUT_TYPE_PASSWORD);
+  text_input_type_ = type;
   OnCaretBoundsChanged();
   if (GetInputMethod())
     GetInputMethod()->OnTextInputTypeChanged(this);
   SchedulePaint();
 }
 
-void Textfield::SetTextInputType(ui::TextInputType type) {
-  text_input_type_ = type;
-  bool should_be_obscured = type == ui::TEXT_INPUT_TYPE_PASSWORD;
-  if (IsObscured() != should_be_obscured)
-    SetObscured(should_be_obscured);
-}
-
 void Textfield::SetText(const base::string16& new_text) {
-  model_->SetText(GetTextForDisplay(new_text));
+  model_->SetText(new_text);
   OnCaretBoundsChanged();
   SchedulePaint();
   NotifyAccessibilityEvent(ui::AccessibilityTypes::EVENT_TEXT_CHANGED, true);
 }
 
 void Textfield::AppendText(const base::string16& new_text) {
   if (new_text.empty())
     return;
-  model_->Append(GetTextForDisplay(new_text));
+  model_->Append(new_text);
   OnCaretBoundsChanged();
   SchedulePaint();
 }
 
 void Textfield::InsertOrReplaceText(const base::string16& new_text) {
   if (new_text.empty())
     return;
   model_->InsertText(new_text);
   OnCaretBoundsChanged();
   SchedulePaint();
@@ skipping 195 matching lines @@
     return true;
 
   // TODO(oshima): Refactor and consolidate with ExecuteCommand.
   if (event.type() == ui::ET_KEY_PRESSED) {
     ui::KeyboardCode key_code = event.key_code();
     if (key_code == ui::VKEY_TAB || event.IsUnicodeKeyCode())
       return false;
 
     gfx::RenderText* render_text = GetRenderText();
     const bool editable = !read_only();
-    const bool readable = !IsObscured();
+    const bool readable = text_input_type_ != ui::TEXT_INPUT_TYPE_PASSWORD;
     const bool shift = event.IsShiftDown();
     const bool control = event.IsControlDown();
     const bool alt = event.IsAltDown() || event.IsAltGrDown();
     bool text_changed = false;
     bool cursor_changed = false;
 
     OnBeforeUserAction();
     switch (key_code) {
       case ui::VKEY_Z:
         if (control && !shift && !alt && editable)
@@ skipping 210 matching lines @@
 
   // Border typically draws focus indicator.
   SchedulePaint();
 }
 
 void Textfield::GetAccessibleState(ui::AccessibleViewState* state) {
   state->role = ui::AccessibilityTypes::ROLE_TEXT;
   state->name = accessible_name_;
   if (read_only())
     state->state |= ui::AccessibilityTypes::STATE_READONLY;
-  if (IsObscured())
+  if (text_input_type_ == ui::TEXT_INPUT_TYPE_PASSWORD)
     state->state |= ui::AccessibilityTypes::STATE_PROTECTED;
   state->value = text();
 
   const gfx::Range range = GetSelectedRange();
   state->selection_start = range.start();
   state->selection_end = range.end();
 
   if (!read_only()) {
     state->set_value_callback =
         base::Bind(&Textfield::AccessibilitySetValue,
@@ skipping 178 matching lines @@
   gfx::RenderText* render_text = GetRenderText();
   DCHECK(!initiating_drag_ ||
          !render_text->IsPointInSelection(event.location()));
   OnBeforeUserAction();
   skip_input_method_cancel_composition_ = true;
 
   gfx::SelectionModel drop_destination_model =
       render_text->FindCursorPosition(event.location());
   base::string16 new_text;
   event.data().GetString(&new_text);
-  new_text = GetTextForDisplay(new_text);
 
   // Delete the current selection for a drag and drop within this view.
   const bool move = initiating_drag_ && !event.IsControlDown() &&
                     event.source_operations() & ui::DragDropTypes::DRAG_MOVE;
   if (move) {
     // Adjust the drop destination if it is on or after the current selection.
     size_t pos = drop_destination_model.caret_pos();
     pos -= render_text->selection().Intersect(gfx::Range(0, pos)).length();
     model_->DeleteSelectionAndInsertTextAt(new_text, pos);
   } else {
@@ skipping 62 matching lines @@
   drag_utils::SetDragImageOnDataObject(*canvas, size(),
                                        press_pt.OffsetFromOrigin(),
                                        data);
   if (controller_)
     controller_->OnWriteDragData(data);
 }
 
 int Textfield::GetDragOperationsForView(views::View* sender,
                                         const gfx::Point& p) {
   int drag_operations = ui::DragDropTypes::DRAG_COPY;
-  if (!enabled() || IsObscured() || !GetRenderText()->IsPointInSelection(p))
+  if (!enabled() || text_input_type_ == ui::TEXT_INPUT_TYPE_PASSWORD ||
+      !GetRenderText()->IsPointInSelection(p)) {
     drag_operations = ui::DragDropTypes::DRAG_NONE;
-  else if (sender == this && !read_only())
+  } else if (sender == this && !read_only()) {
     drag_operations =
         ui::DragDropTypes::DRAG_MOVE | ui::DragDropTypes::DRAG_COPY;
+  }
   if (controller_)
     controller_->OnGetDragOperationsForTextfield(&drag_operations);
   return drag_operations;
 }
 
 bool Textfield::CanStartDragForView(View* sender,
                                     const gfx::Point& press_pt,
                                     const gfx::Point& p) {
   return initiating_drag_ && GetRenderText()->IsPointInSelection(press_pt);
 }
@@ skipping 59 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // Textfield, ui::SimpleMenuModel::Delegate overrides:
 
 bool Textfield::IsCommandIdChecked(int command_id) const {
   return true;
 }
 
 bool Textfield::IsCommandIdEnabled(int command_id) const {
   base::string16 result;
   bool editable = !read_only();
+  bool readable = text_input_type_ != ui::TEXT_INPUT_TYPE_PASSWORD;
   switch (command_id) {
     case IDS_APP_UNDO:
       return editable && model_->CanUndo();
     case IDS_APP_CUT:
-      return editable && model_->HasSelection() && !IsObscured();
+      return editable && readable && model_->HasSelection();
     case IDS_APP_COPY:
-      return model_->HasSelection() && !IsObscured();
+      return readable && model_->HasSelection();
     case IDS_APP_PASTE:
       ui::Clipboard::GetForCurrentThread()->ReadText(
           ui::CLIPBOARD_TYPE_COPY_PASTE, &result);
       return editable && !result.empty();
     case IDS_APP_DELETE:
       return editable && model_->HasSelection();
     case IDS_APP_SELECT_ALL:
       return !text().empty();
     default:
       return false;
@@ skipping 93 matching lines @@
 }
 
 void Textfield::InsertText(const base::string16& new_text) {
   // TODO(suzhe): Filter invalid characters.
   if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE || new_text.empty())
     return;
 
   OnBeforeUserAction();
   skip_input_method_cancel_composition_ = true;
   if (GetRenderText()->insert_mode())
-    model_->InsertText(GetTextForDisplay(new_text));
+    model_->InsertText(new_text);
   else
-    model_->ReplaceText(GetTextForDisplay(new_text));
+    model_->ReplaceText(new_text);
   skip_input_method_cancel_composition_ = false;
   UpdateAfterChange(true, true);
   OnAfterUserAction();
 }
 
 void Textfield::InsertChar(base::char16 ch, int flags) {
   // Filter out all control characters, including tab and new line characters,
   // and all characters with Alt modifier. But allow characters with the AltGr
   // modifier. On Windows AltGr is represented by Alt+Ctrl, and on Linux it's a
   // different flag that we don't care about.
   const bool should_insert_char = ((ch >= 0x20 && ch < 0x7F) || ch > 0x9F) &&
       (flags & ~(ui::EF_SHIFT_DOWN | ui::EF_CAPS_LOCK_DOWN)) != ui::EF_ALT_DOWN;
   if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE || !should_insert_char)
     return;
 
   OnBeforeUserAction();
   skip_input_method_cancel_composition_ = true;
   if (GetRenderText()->insert_mode())
     model_->InsertChar(ch);
   else
     model_->ReplaceChar(ch);
   skip_input_method_cancel_composition_ = false;
 
-  model_->SetText(GetTextForDisplay(text()));
-
   UpdateAfterChange(true, true);
   OnAfterUserAction();
 
-  if (IsObscured() && obscured_reveal_duration_ != base::TimeDelta()) {
+  if (text_input_type_ == ui::TEXT_INPUT_TYPE_PASSWORD &&
+      password_reveal_duration_ != base::TimeDelta()) {
     const size_t change_offset = model_->GetCursorPosition();
     DCHECK_GT(change_offset, 0u);
-    RevealObscuredChar(change_offset - 1, obscured_reveal_duration_);
+    RevealPasswordChar(change_offset - 1);
   }
 }
 
 gfx::NativeWindow Textfield::GetAttachedWindow() const {
   // Imagine the following hierarchy.
   //   [NativeWidget A] - FocusManager
   //     [View]
   //     [NativeWidget B]
   //       [View]
   //         [View X]
@@ skipping 152 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // Textfield, protected:
 
 gfx::RenderText* Textfield::GetRenderText() const {
   return model_->render_text();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Textfield, private:
 
-base::string16 Textfield::GetTextForDisplay(const base::string16& raw) {
-  return style_ & Textfield::STYLE_LOWERCASE ? base::i18n::ToLower(raw) : raw;
-}
-
 void Textfield::AccessibilitySetValue(const base::string16& new_value) {
   if (!read_only()) {
     SetText(new_value);
     ClearSelection();
   }
 }
 
 void Textfield::UpdateBackgroundColor() {
   const SkColor color = GetBackgroundColor();
   set_background(Background::CreateSolidBackground(color));
@@ skipping 89 matching lines @@
   if (controller_)
     controller_->OnBeforeUserAction(this);
 }
 
 void Textfield::OnAfterUserAction() {
   if (controller_)
     controller_->OnAfterUserAction(this);
 }
 
 bool Textfield::Cut() {
-  if (!read_only() && !IsObscured() && model_->Cut()) {
+  if (!read_only() && text_input_type_ != ui::TEXT_INPUT_TYPE_PASSWORD &&
+      model_->Cut()) {
     if (controller_)
       controller_->OnAfterCutOrCopy();
     return true;
   }
   return false;
 }
 
 bool Textfield::Copy() {
-  if (!IsObscured() && model_->Copy()) {
+  if (text_input_type_ != ui::TEXT_INPUT_TYPE_PASSWORD && model_->Copy()) {
     if (controller_)
       controller_->OnAfterCutOrCopy();
     return true;
   }
   return false;
 }
 
 bool Textfield::Paste() {
-  if (read_only())
-    return false;
-
-  const base::string16 original_text = text();
-  if (model_->Paste()) {
-    // As Paste is handled in model_->Paste(), the RenderText may contain
-    // upper case characters. This is not consistent with other places
-    // which keeps RenderText only containing lower case characters.
-    base::string16 new_text = GetTextForDisplay(text());
-    model_->SetText(new_text);
+  if (!read_only() && model_->Paste()) {
     if (controller_)
       controller_->OnAfterPaste();
     return true;
   }
   return false;
 }
 
 void Textfield::UpdateContextMenu() {
   if (!context_menu_contents_.get()) {
     context_menu_contents_.reset(new ui::SimpleMenuModel(this));
@@ skipping 28 matching lines @@
     last_click_location_ = event.location();
   }
 }
 
 bool Textfield::ImeEditingAllowed() const {
   // Disallow input method editing of password fields.
   ui::TextInputType t = GetTextInputType();
   return (t != ui::TEXT_INPUT_TYPE_NONE && t != ui::TEXT_INPUT_TYPE_PASSWORD);
 }
 
-void Textfield::RevealObscuredChar(int index, const base::TimeDelta& duration) {
+void Textfield::RevealPasswordChar(int index) {
   GetRenderText()->SetObscuredRevealIndex(index);
   SchedulePaint();
 
   if (index != -1) {
-    obscured_reveal_timer_.Start(FROM_HERE, duration,
-        base::Bind(&Textfield::RevealObscuredChar, base::Unretained(this),
-                   -1, base::TimeDelta()));
+    password_reveal_timer_.Start(FROM_HERE, password_reveal_duration_,
+        base::Bind(&Textfield::RevealPasswordChar,
+                   weak_ptr_factory_.GetWeakPtr(), -1));
   }
 }
 
 void Textfield::CreateTouchSelectionControllerAndNotifyIt() {
   if (!touch_selection_controller_) {
     touch_selection_controller_.reset(
         ui::TouchSelectionController::create(this));
   }
   if (touch_selection_controller_)
     touch_selection_controller_->SelectionChanged();
 }
 
 }  // namespace views