Home | History | Annotate | Download | only in textfield 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "ui/views/controls/textfield/textfield.h"
      6 
      7 #include <string>
      8 
      9 #include "base/debug/trace_event.h"
     10 #include "ui/accessibility/ax_view_state.h"
     11 #include "ui/base/clipboard/scoped_clipboard_writer.h"
     12 #include "ui/base/cursor/cursor.h"
     13 #include "ui/base/dragdrop/drag_drop_types.h"
     14 #include "ui/base/dragdrop/drag_utils.h"
     15 #include "ui/base/ui_base_switches_util.h"
     16 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
     17 #include "ui/events/event.h"
     18 #include "ui/events/keycodes/keyboard_codes.h"
     19 #include "ui/gfx/canvas.h"
     20 #include "ui/gfx/display.h"
     21 #include "ui/gfx/insets.h"
     22 #include "ui/gfx/screen.h"
     23 #include "ui/native_theme/native_theme.h"
     24 #include "ui/strings/grit/ui_strings.h"
     25 #include "ui/views/background.h"
     26 #include "ui/views/controls/focusable_border.h"
     27 #include "ui/views/controls/label.h"
     28 #include "ui/views/controls/menu/menu_runner.h"
     29 #include "ui/views/controls/native/native_view_host.h"
     30 #include "ui/views/controls/textfield/textfield_controller.h"
     31 #include "ui/views/drag_utils.h"
     32 #include "ui/views/ime/input_method.h"
     33 #include "ui/views/metrics.h"
     34 #include "ui/views/native_cursor.h"
     35 #include "ui/views/painter.h"
     36 #include "ui/views/views_delegate.h"
     37 #include "ui/views/widget/widget.h"
     38 
     39 #if defined(OS_WIN)
     40 #include "base/win/win_util.h"
     41 #endif
     42 
     43 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
     44 #include "base/strings/utf_string_conversions.h"
     45 #include "ui/events/linux/text_edit_command_auralinux.h"
     46 #include "ui/events/linux/text_edit_key_bindings_delegate_auralinux.h"
     47 #endif
     48 
     49 namespace views {
     50 
     51 namespace {
     52 
     53 // Default placeholder text color.
     54 const SkColor kDefaultPlaceholderTextColor = SK_ColorLTGRAY;
     55 
     56 const int kNoCommand = 0;
     57 
     58 void ConvertRectToScreen(const View* src, gfx::Rect* r) {
     59   DCHECK(src);
     60 
     61   gfx::Point new_origin = r->origin();
     62   View::ConvertPointToScreen(src, &new_origin);
     63   r->set_origin(new_origin);
     64 }
     65 
     66 // Get the drag selection timer delay, respecting animation scaling for testing.
     67 int GetDragSelectionDelay() {
     68   switch (ui::ScopedAnimationDurationScaleMode::duration_scale_mode()) {
     69       case ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION: return 100;
     70       case ui::ScopedAnimationDurationScaleMode::FAST_DURATION:   return 25;
     71       case ui::ScopedAnimationDurationScaleMode::SLOW_DURATION:   return 400;
     72       case ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION:   return 1;
     73       case ui::ScopedAnimationDurationScaleMode::ZERO_DURATION:   return 0;
     74     }
     75   return 100;
     76 }
     77 
     78 // Get the default command for a given key |event| and selection state.
     79 int GetCommandForKeyEvent(const ui::KeyEvent& event, bool has_selection) {
     80   if (event.type() != ui::ET_KEY_PRESSED || event.IsUnicodeKeyCode())
     81     return kNoCommand;
     82 
     83   const bool shift = event.IsShiftDown();
     84   const bool control = event.IsControlDown();
     85   const bool alt = event.IsAltDown() || event.IsAltGrDown();
     86   switch (event.key_code()) {
     87     case ui::VKEY_Z:
     88       if (control && !shift && !alt)
     89         return IDS_APP_UNDO;
     90       return (control && shift && !alt) ? IDS_APP_REDO : kNoCommand;
     91     case ui::VKEY_Y:
     92       return (control && !alt) ? IDS_APP_REDO : kNoCommand;
     93     case ui::VKEY_A:
     94       return (control && !alt) ? IDS_APP_SELECT_ALL : kNoCommand;
     95     case ui::VKEY_X:
     96       return (control && !alt) ? IDS_APP_CUT : kNoCommand;
     97     case ui::VKEY_C:
     98       return (control && !alt) ? IDS_APP_COPY : kNoCommand;
     99     case ui::VKEY_V:
    100       return (control && !alt) ? IDS_APP_PASTE : kNoCommand;
    101     case ui::VKEY_RIGHT:
    102       // Ignore alt+right, which may be a browser navigation shortcut.
    103       if (alt)
    104         return kNoCommand;
    105       if (!shift)
    106         return control ? IDS_MOVE_WORD_RIGHT : IDS_MOVE_RIGHT;
    107       return control ? IDS_MOVE_WORD_RIGHT_AND_MODIFY_SELECTION :
    108                         IDS_MOVE_RIGHT_AND_MODIFY_SELECTION;
    109     case ui::VKEY_LEFT:
    110       // Ignore alt+left, which may be a browser navigation shortcut.
    111       if (alt)
    112         return kNoCommand;
    113       if (!shift)
    114         return control ? IDS_MOVE_WORD_LEFT : IDS_MOVE_LEFT;
    115       return control ? IDS_MOVE_WORD_LEFT_AND_MODIFY_SELECTION :
    116                         IDS_MOVE_LEFT_AND_MODIFY_SELECTION;
    117     case ui::VKEY_HOME:
    118       return shift ? IDS_MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION :
    119                       IDS_MOVE_TO_BEGINNING_OF_LINE;
    120     case ui::VKEY_END:
    121       return shift ? IDS_MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION :
    122                       IDS_MOVE_TO_END_OF_LINE;
    123     case ui::VKEY_BACK:
    124       if (!control || has_selection)
    125         return IDS_DELETE_BACKWARD;
    126 #if defined(OS_LINUX)
    127       // Only erase by line break on Linux and ChromeOS.
    128       if (shift)
    129         return IDS_DELETE_TO_BEGINNING_OF_LINE;
    130 #endif
    131       return IDS_DELETE_WORD_BACKWARD;
    132     case ui::VKEY_DELETE:
    133       if (!control || has_selection)
    134         return (shift && has_selection) ? IDS_APP_CUT : IDS_DELETE_FORWARD;
    135 #if defined(OS_LINUX)
    136       // Only erase by line break on Linux and ChromeOS.
    137       if (shift)
    138         return IDS_DELETE_TO_END_OF_LINE;
    139 #endif
    140       return IDS_DELETE_WORD_FORWARD;
    141     case ui::VKEY_INSERT:
    142       if (control && !shift)
    143         return IDS_APP_COPY;
    144       return (shift && !control) ? IDS_APP_PASTE : kNoCommand;
    145     default:
    146       return kNoCommand;
    147   }
    148 }
    149 
    150 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
    151 // Convert a custom text edit |command| to the equivalent views command ID.
    152 int GetViewsCommand(const ui::TextEditCommandAuraLinux& command, bool rtl) {
    153   const bool select = command.extend_selection();
    154   switch (command.command_id()) {
    155     case ui::TextEditCommandAuraLinux::COPY:
    156       return IDS_APP_COPY;
    157     case ui::TextEditCommandAuraLinux::CUT:
    158       return IDS_APP_CUT;
    159     case ui::TextEditCommandAuraLinux::DELETE_BACKWARD:
    160       return IDS_DELETE_BACKWARD;
    161     case ui::TextEditCommandAuraLinux::DELETE_FORWARD:
    162       return IDS_DELETE_FORWARD;
    163     case ui::TextEditCommandAuraLinux::DELETE_TO_BEGINING_OF_LINE:
    164     case ui::TextEditCommandAuraLinux::DELETE_TO_BEGINING_OF_PARAGRAPH:
    165       return IDS_DELETE_TO_BEGINNING_OF_LINE;
    166     case ui::TextEditCommandAuraLinux::DELETE_TO_END_OF_LINE:
    167     case ui::TextEditCommandAuraLinux::DELETE_TO_END_OF_PARAGRAPH:
    168       return IDS_DELETE_TO_END_OF_LINE;
    169     case ui::TextEditCommandAuraLinux::DELETE_WORD_BACKWARD:
    170       return IDS_DELETE_WORD_BACKWARD;
    171     case ui::TextEditCommandAuraLinux::DELETE_WORD_FORWARD:
    172       return IDS_DELETE_WORD_FORWARD;
    173     case ui::TextEditCommandAuraLinux::INSERT_TEXT:
    174       return kNoCommand;
    175     case ui::TextEditCommandAuraLinux::MOVE_BACKWARD:
    176       if (rtl)
    177         return select ? IDS_MOVE_RIGHT_AND_MODIFY_SELECTION : IDS_MOVE_RIGHT;
    178       return select ? IDS_MOVE_LEFT_AND_MODIFY_SELECTION : IDS_MOVE_LEFT;
    179     case ui::TextEditCommandAuraLinux::MOVE_DOWN:
    180       return IDS_MOVE_DOWN;
    181     case ui::TextEditCommandAuraLinux::MOVE_FORWARD:
    182       if (rtl)
    183         return select ? IDS_MOVE_LEFT_AND_MODIFY_SELECTION : IDS_MOVE_LEFT;
    184       return select ? IDS_MOVE_RIGHT_AND_MODIFY_SELECTION : IDS_MOVE_RIGHT;
    185     case ui::TextEditCommandAuraLinux::MOVE_LEFT:
    186       return select ? IDS_MOVE_LEFT_AND_MODIFY_SELECTION : IDS_MOVE_LEFT;
    187     case ui::TextEditCommandAuraLinux::MOVE_PAGE_DOWN:
    188     case ui::TextEditCommandAuraLinux::MOVE_PAGE_UP:
    189       return kNoCommand;
    190     case ui::TextEditCommandAuraLinux::MOVE_RIGHT:
    191       return select ? IDS_MOVE_RIGHT_AND_MODIFY_SELECTION : IDS_MOVE_RIGHT;
    192     case ui::TextEditCommandAuraLinux::MOVE_TO_BEGINING_OF_DOCUMENT:
    193     case ui::TextEditCommandAuraLinux::MOVE_TO_BEGINING_OF_LINE:
    194     case ui::TextEditCommandAuraLinux::MOVE_TO_BEGINING_OF_PARAGRAPH:
    195       return select ? IDS_MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION :
    196                       IDS_MOVE_TO_BEGINNING_OF_LINE;
    197     case ui::TextEditCommandAuraLinux::MOVE_TO_END_OF_DOCUMENT:
    198     case ui::TextEditCommandAuraLinux::MOVE_TO_END_OF_LINE:
    199     case ui::TextEditCommandAuraLinux::MOVE_TO_END_OF_PARAGRAPH:
    200       return select ? IDS_MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION :
    201                       IDS_MOVE_TO_END_OF_LINE;
    202     case ui::TextEditCommandAuraLinux::MOVE_UP:
    203       return IDS_MOVE_UP;
    204     case ui::TextEditCommandAuraLinux::MOVE_WORD_BACKWARD:
    205       if (rtl) {
    206         return select ? IDS_MOVE_WORD_RIGHT_AND_MODIFY_SELECTION :
    207                         IDS_MOVE_WORD_RIGHT;
    208       }
    209       return select ? IDS_MOVE_WORD_LEFT_AND_MODIFY_SELECTION :
    210                       IDS_MOVE_WORD_LEFT;
    211     case ui::TextEditCommandAuraLinux::MOVE_WORD_FORWARD:
    212       if (rtl) {
    213         return select ? IDS_MOVE_WORD_LEFT_AND_MODIFY_SELECTION :
    214                         IDS_MOVE_WORD_LEFT;
    215       }
    216       return select ? IDS_MOVE_WORD_RIGHT_AND_MODIFY_SELECTION :
    217                       IDS_MOVE_WORD_RIGHT;
    218     case ui::TextEditCommandAuraLinux::MOVE_WORD_LEFT:
    219       return select ? IDS_MOVE_WORD_LEFT_AND_MODIFY_SELECTION :
    220                       IDS_MOVE_WORD_LEFT;
    221     case ui::TextEditCommandAuraLinux::MOVE_WORD_RIGHT:
    222       return select ? IDS_MOVE_WORD_RIGHT_AND_MODIFY_SELECTION :
    223                       IDS_MOVE_WORD_RIGHT;
    224     case ui::TextEditCommandAuraLinux::PASTE:
    225       return IDS_APP_PASTE;
    226     case ui::TextEditCommandAuraLinux::SELECT_ALL:
    227       return IDS_APP_SELECT_ALL;
    228     case ui::TextEditCommandAuraLinux::SET_MARK:
    229     case ui::TextEditCommandAuraLinux::UNSELECT:
    230     case ui::TextEditCommandAuraLinux::INVALID_COMMAND:
    231       return kNoCommand;
    232   }
    233   return kNoCommand;
    234 }
    235 #endif
    236 
    237 }  // namespace
    238 
    239 // static
    240 const char Textfield::kViewClassName[] = "Textfield";
    241 const int Textfield::kTextPadding = 3;
    242 
    243 // static
    244 size_t Textfield::GetCaretBlinkMs() {
    245   static const size_t default_value = 500;
    246 #if defined(OS_WIN)
    247   static const size_t system_value = ::GetCaretBlinkTime();
    248   if (system_value != 0)
    249     return (system_value == INFINITE) ? 0 : system_value;
    250 #endif
    251   return default_value;
    252 }
    253 
    254 Textfield::Textfield()
    255     : model_(new TextfieldModel(this)),
    256       controller_(NULL),
    257       read_only_(false),
    258       default_width_in_chars_(0),
    259       use_default_text_color_(true),
    260       use_default_background_color_(true),
    261       use_default_selection_text_color_(true),
    262       use_default_selection_background_color_(true),
    263       text_color_(SK_ColorBLACK),
    264       background_color_(SK_ColorWHITE),
    265       selection_text_color_(SK_ColorWHITE),
    266       selection_background_color_(SK_ColorBLUE),
    267       placeholder_text_color_(kDefaultPlaceholderTextColor),
    268       text_input_type_(ui::TEXT_INPUT_TYPE_TEXT),
    269       performing_user_action_(false),
    270       skip_input_method_cancel_composition_(false),
    271       cursor_visible_(false),
    272       drop_cursor_visible_(false),
    273       initiating_drag_(false),
    274       aggregated_clicks_(0),
    275       drag_start_display_offset_(0),
    276       touch_handles_hidden_due_to_scroll_(false),
    277       weak_ptr_factory_(this) {
    278   set_context_menu_controller(this);
    279   set_drag_controller(this);
    280   SetBorder(scoped_ptr<Border>(new FocusableBorder()));
    281   SetFocusable(true);
    282 
    283   if (ViewsDelegate::views_delegate) {
    284     password_reveal_duration_ = ViewsDelegate::views_delegate->
    285         GetDefaultTextfieldObscuredRevealDuration();
    286   }
    287 }
    288 
    289 Textfield::~Textfield() {}
    290 
    291 void Textfield::SetReadOnly(bool read_only) {
    292   // Update read-only without changing the focusable state (or active, etc.).
    293   read_only_ = read_only;
    294   if (GetInputMethod())
    295     GetInputMethod()->OnTextInputTypeChanged(this);
    296   SetColor(GetTextColor());
    297   UpdateBackgroundColor();
    298 }
    299 
    300 void Textfield::SetTextInputType(ui::TextInputType type) {
    301   GetRenderText()->SetObscured(type == ui::TEXT_INPUT_TYPE_PASSWORD);
    302   text_input_type_ = type;
    303   OnCaretBoundsChanged();
    304   if (GetInputMethod())
    305     GetInputMethod()->OnTextInputTypeChanged(this);
    306   SchedulePaint();
    307 }
    308 
    309 void Textfield::SetText(const base::string16& new_text) {
    310   model_->SetText(new_text);
    311   OnCaretBoundsChanged();
    312   SchedulePaint();
    313   NotifyAccessibilityEvent(ui::AX_EVENT_TEXT_CHANGED, true);
    314 }
    315 
    316 void Textfield::AppendText(const base::string16& new_text) {
    317   if (new_text.empty())
    318     return;
    319   model_->Append(new_text);
    320   OnCaretBoundsChanged();
    321   SchedulePaint();
    322 }
    323 
    324 void Textfield::InsertOrReplaceText(const base::string16& new_text) {
    325   if (new_text.empty())
    326     return;
    327   model_->InsertText(new_text);
    328   OnCaretBoundsChanged();
    329   SchedulePaint();
    330 }
    331 
    332 base::i18n::TextDirection Textfield::GetTextDirection() const {
    333   return GetRenderText()->GetTextDirection();
    334 }
    335 
    336 base::string16 Textfield::GetSelectedText() const {
    337   return model_->GetSelectedText();
    338 }
    339 
    340 void Textfield::SelectAll(bool reversed) {
    341   model_->SelectAll(reversed);
    342   UpdateSelectionClipboard();
    343   UpdateAfterChange(false, true);
    344 }
    345 
    346 void Textfield::SelectWordAt(const gfx::Point& point) {
    347   model_->MoveCursorTo(point, false);
    348   model_->SelectWord();
    349   UpdateAfterChange(false, true);
    350 }
    351 
    352 void Textfield::ClearSelection() {
    353   model_->ClearSelection();
    354   UpdateAfterChange(false, true);
    355 }
    356 
    357 bool Textfield::HasSelection() const {
    358   return !GetSelectedRange().is_empty();
    359 }
    360 
    361 SkColor Textfield::GetTextColor() const {
    362   if (!use_default_text_color_)
    363     return text_color_;
    364 
    365   return GetNativeTheme()->GetSystemColor(read_only() ?
    366       ui::NativeTheme::kColorId_TextfieldReadOnlyColor :
    367       ui::NativeTheme::kColorId_TextfieldDefaultColor);
    368 }
    369 
    370 void Textfield::SetTextColor(SkColor color) {
    371   text_color_ = color;
    372   use_default_text_color_ = false;
    373   SetColor(color);
    374 }
    375 
    376 void Textfield::UseDefaultTextColor() {
    377   use_default_text_color_ = true;
    378   SetColor(GetTextColor());
    379 }
    380 
    381 SkColor Textfield::GetBackgroundColor() const {
    382   if (!use_default_background_color_)
    383     return background_color_;
    384 
    385   return GetNativeTheme()->GetSystemColor(read_only() ?
    386       ui::NativeTheme::kColorId_TextfieldReadOnlyBackground :
    387       ui::NativeTheme::kColorId_TextfieldDefaultBackground);
    388 }
    389 
    390 void Textfield::SetBackgroundColor(SkColor color) {
    391   background_color_ = color;
    392   use_default_background_color_ = false;
    393   UpdateBackgroundColor();
    394 }
    395 
    396 void Textfield::UseDefaultBackgroundColor() {
    397   use_default_background_color_ = true;
    398   UpdateBackgroundColor();
    399 }
    400 
    401 SkColor Textfield::GetSelectionTextColor() const {
    402   return use_default_selection_text_color_ ?
    403       GetNativeTheme()->GetSystemColor(
    404           ui::NativeTheme::kColorId_TextfieldSelectionColor) :
    405       selection_text_color_;
    406 }
    407 
    408 void Textfield::SetSelectionTextColor(SkColor color) {
    409   selection_text_color_ = color;
    410   use_default_selection_text_color_ = false;
    411   GetRenderText()->set_selection_color(GetSelectionTextColor());
    412   SchedulePaint();
    413 }
    414 
    415 void Textfield::UseDefaultSelectionTextColor() {
    416   use_default_selection_text_color_ = true;
    417   GetRenderText()->set_selection_color(GetSelectionTextColor());
    418   SchedulePaint();
    419 }
    420 
    421 void Textfield::SetShadows(const gfx::ShadowValues& shadows) {
    422   GetRenderText()->set_shadows(shadows);
    423   SchedulePaint();
    424 }
    425 
    426 SkColor Textfield::GetSelectionBackgroundColor() const {
    427   return use_default_selection_background_color_ ?
    428       GetNativeTheme()->GetSystemColor(
    429           ui::NativeTheme::kColorId_TextfieldSelectionBackgroundFocused) :
    430       selection_background_color_;
    431 }
    432 
    433 void Textfield::SetSelectionBackgroundColor(SkColor color) {
    434   selection_background_color_ = color;
    435   use_default_selection_background_color_ = false;
    436   GetRenderText()->set_selection_background_focused_color(
    437       GetSelectionBackgroundColor());
    438   SchedulePaint();
    439 }
    440 
    441 void Textfield::UseDefaultSelectionBackgroundColor() {
    442   use_default_selection_background_color_ = true;
    443   GetRenderText()->set_selection_background_focused_color(
    444       GetSelectionBackgroundColor());
    445   SchedulePaint();
    446 }
    447 
    448 bool Textfield::GetCursorEnabled() const {
    449   return GetRenderText()->cursor_enabled();
    450 }
    451 
    452 void Textfield::SetCursorEnabled(bool enabled) {
    453   GetRenderText()->SetCursorEnabled(enabled);
    454 }
    455 
    456 const gfx::FontList& Textfield::GetFontList() const {
    457   return GetRenderText()->font_list();
    458 }
    459 
    460 void Textfield::SetFontList(const gfx::FontList& font_list) {
    461   GetRenderText()->SetFontList(font_list);
    462   OnCaretBoundsChanged();
    463   PreferredSizeChanged();
    464 }
    465 
    466 base::string16 Textfield::GetPlaceholderText() const {
    467   return placeholder_text_;
    468 }
    469 
    470 gfx::HorizontalAlignment Textfield::GetHorizontalAlignment() const {
    471   return GetRenderText()->horizontal_alignment();
    472 }
    473 
    474 void Textfield::SetHorizontalAlignment(gfx::HorizontalAlignment alignment) {
    475   GetRenderText()->SetHorizontalAlignment(alignment);
    476 }
    477 
    478 void Textfield::ShowImeIfNeeded() {
    479   if (enabled() && !read_only())
    480     GetInputMethod()->ShowImeIfNeeded();
    481 }
    482 
    483 bool Textfield::IsIMEComposing() const {
    484   return model_->HasCompositionText();
    485 }
    486 
    487 const gfx::Range& Textfield::GetSelectedRange() const {
    488   return GetRenderText()->selection();
    489 }
    490 
    491 void Textfield::SelectRange(const gfx::Range& range) {
    492   model_->SelectRange(range);
    493   UpdateAfterChange(false, true);
    494 }
    495 
    496 const gfx::SelectionModel& Textfield::GetSelectionModel() const {
    497   return GetRenderText()->selection_model();
    498 }
    499 
    500 void Textfield::SelectSelectionModel(const gfx::SelectionModel& sel) {
    501   model_->SelectSelectionModel(sel);
    502   UpdateAfterChange(false, true);
    503 }
    504 
    505 size_t Textfield::GetCursorPosition() const {
    506   return model_->GetCursorPosition();
    507 }
    508 
    509 void Textfield::SetColor(SkColor value) {
    510   GetRenderText()->SetColor(value);
    511   SchedulePaint();
    512 }
    513 
    514 void Textfield::ApplyColor(SkColor value, const gfx::Range& range) {
    515   GetRenderText()->ApplyColor(value, range);
    516   SchedulePaint();
    517 }
    518 
    519 void Textfield::SetStyle(gfx::TextStyle style, bool value) {
    520   GetRenderText()->SetStyle(style, value);
    521   SchedulePaint();
    522 }
    523 
    524 void Textfield::ApplyStyle(gfx::TextStyle style,
    525                            bool value,
    526                            const gfx::Range& range) {
    527   GetRenderText()->ApplyStyle(style, value, range);
    528   SchedulePaint();
    529 }
    530 
    531 void Textfield::ClearEditHistory() {
    532   model_->ClearEditHistory();
    533 }
    534 
    535 void Textfield::SetAccessibleName(const base::string16& name) {
    536   accessible_name_ = name;
    537 }
    538 
    539 void Textfield::ExecuteCommand(int command_id) {
    540   ExecuteCommand(command_id, ui::EF_NONE);
    541 }
    542 
    543 void Textfield::SetFocusPainter(scoped_ptr<Painter> focus_painter) {
    544   focus_painter_ = focus_painter.Pass();
    545 }
    546 
    547 bool Textfield::HasTextBeingDragged() {
    548   return initiating_drag_;
    549 }
    550 
    551 ////////////////////////////////////////////////////////////////////////////////
    552 // Textfield, View overrides:
    553 
    554 gfx::Insets Textfield::GetInsets() const {
    555   gfx::Insets insets = View::GetInsets();
    556   insets += gfx::Insets(kTextPadding, kTextPadding, kTextPadding, kTextPadding);
    557   return insets;
    558 }
    559 
    560 int Textfield::GetBaseline() const {
    561   return GetInsets().top() + GetRenderText()->GetBaseline();
    562 }
    563 
    564 gfx::Size Textfield::GetPreferredSize() const {
    565   const gfx::Insets& insets = GetInsets();
    566   return gfx::Size(GetFontList().GetExpectedTextWidth(default_width_in_chars_) +
    567                    insets.width(), GetFontList().GetHeight() + insets.height());
    568 }
    569 
    570 const char* Textfield::GetClassName() const {
    571   return kViewClassName;
    572 }
    573 
    574 gfx::NativeCursor Textfield::GetCursor(const ui::MouseEvent& event) {
    575   bool in_selection = GetRenderText()->IsPointInSelection(event.location());
    576   bool drag_event = event.type() == ui::ET_MOUSE_DRAGGED;
    577   bool text_cursor = !initiating_drag_ && (drag_event || !in_selection);
    578   return text_cursor ? GetNativeIBeamCursor() : gfx::kNullCursor;
    579 }
    580 
    581 bool Textfield::OnMousePressed(const ui::MouseEvent& event) {
    582   TrackMouseClicks(event);
    583 
    584   if (!controller_ || !controller_->HandleMouseEvent(this, event)) {
    585     if (event.IsOnlyLeftMouseButton() || event.IsOnlyRightMouseButton()) {
    586       RequestFocus();
    587       ShowImeIfNeeded();
    588     }
    589 
    590     if (event.IsOnlyLeftMouseButton()) {
    591       OnBeforeUserAction();
    592       initiating_drag_ = false;
    593       switch (aggregated_clicks_) {
    594         case 0:
    595           if (GetRenderText()->IsPointInSelection(event.location()))
    596             initiating_drag_ = true;
    597           else
    598             MoveCursorTo(event.location(), event.IsShiftDown());
    599           break;
    600         case 1:
    601           SelectWordAt(event.location());
    602           double_click_word_ = GetRenderText()->selection();
    603           break;
    604         case 2:
    605           SelectAll(false);
    606           break;
    607         default:
    608           NOTREACHED();
    609       }
    610       OnAfterUserAction();
    611     }
    612 
    613 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
    614     if (event.IsOnlyMiddleMouseButton()) {
    615       if (GetRenderText()->IsPointInSelection(event.location())) {
    616         OnBeforeUserAction();
    617         ClearSelection();
    618         ui::ScopedClipboardWriter(
    619             ui::CLIPBOARD_TYPE_SELECTION).WriteText(base::string16());
    620         OnAfterUserAction();
    621       } else if (!read_only()) {
    622         PasteSelectionClipboard(event);
    623       }
    624     }
    625 #endif
    626   }
    627 
    628   return true;
    629 }
    630 
    631 bool Textfield::OnMouseDragged(const ui::MouseEvent& event) {
    632   last_drag_location_ = event.location();
    633 
    634   // Don't adjust the cursor on a potential drag and drop, or if the mouse
    635   // movement from the last mouse click does not exceed the drag threshold.
    636   if (initiating_drag_ || !event.IsOnlyLeftMouseButton() ||
    637       !ExceededDragThreshold(last_drag_location_ - last_click_location_)) {
    638     return true;
    639   }
    640 
    641   // A timer is used to continuously scroll while selecting beyond side edges.
    642   if ((event.location().x() > 0 && event.location().x() < size().width()) ||
    643       GetDragSelectionDelay() == 0) {
    644     drag_selection_timer_.Stop();
    645     SelectThroughLastDragLocation();
    646   } else if (!drag_selection_timer_.IsRunning()) {
    647     drag_selection_timer_.Start(
    648         FROM_HERE, base::TimeDelta::FromMilliseconds(GetDragSelectionDelay()),
    649         this, &Textfield::SelectThroughLastDragLocation);
    650   }
    651 
    652   return true;
    653 }
    654 
    655 void Textfield::OnMouseReleased(const ui::MouseEvent& event) {
    656   OnBeforeUserAction();
    657   drag_selection_timer_.Stop();
    658   // Cancel suspected drag initiations, the user was clicking in the selection.
    659   if (initiating_drag_)
    660     MoveCursorTo(event.location(), false);
    661   initiating_drag_ = false;
    662   UpdateSelectionClipboard();
    663   OnAfterUserAction();
    664 }
    665 
    666 bool Textfield::OnKeyPressed(const ui::KeyEvent& event) {
    667   // Since HandleKeyEvent() might destroy |this|, get a weak pointer and verify
    668   // it isn't null before proceeding.
    669   base::WeakPtr<Textfield> textfield(weak_ptr_factory_.GetWeakPtr());
    670 
    671   bool handled = controller_ && controller_->HandleKeyEvent(this, event);
    672 
    673   if (!textfield)
    674     return handled;
    675 
    676 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
    677   ui::TextEditKeyBindingsDelegateAuraLinux* delegate =
    678       ui::GetTextEditKeyBindingsDelegate();
    679   std::vector<ui::TextEditCommandAuraLinux> commands;
    680   if (!handled && delegate && delegate->MatchEvent(event, &commands)) {
    681     const bool rtl = GetTextDirection() == base::i18n::RIGHT_TO_LEFT;
    682     for (size_t i = 0; i < commands.size(); ++i) {
    683       const int command = GetViewsCommand(commands[i], rtl);
    684       if (IsCommandIdEnabled(command)) {
    685         ExecuteCommand(command);
    686         handled = true;
    687       }
    688     }
    689     return handled;
    690   }
    691 #endif
    692 
    693   const int command = GetCommandForKeyEvent(event, HasSelection());
    694   if (!handled && IsCommandIdEnabled(command)) {
    695     ExecuteCommand(command);
    696     handled = true;
    697   }
    698   return handled;
    699 }
    700 
    701 ui::TextInputClient* Textfield::GetTextInputClient() {
    702   return read_only_ ? NULL : this;
    703 }
    704 
    705 void Textfield::OnGestureEvent(ui::GestureEvent* event) {
    706   switch (event->type()) {
    707     case ui::ET_GESTURE_TAP_DOWN:
    708       RequestFocus();
    709       ShowImeIfNeeded();
    710       event->SetHandled();
    711       break;
    712     case ui::ET_GESTURE_TAP:
    713       if (event->details().tap_count() == 1) {
    714         if (!GetRenderText()->IsPointInSelection(event->location())) {
    715           OnBeforeUserAction();
    716           MoveCursorTo(event->location(), false);
    717           OnAfterUserAction();
    718         }
    719       } else if (event->details().tap_count() == 2) {
    720         OnBeforeUserAction();
    721         SelectWordAt(event->location());
    722         OnAfterUserAction();
    723       } else {
    724         OnBeforeUserAction();
    725         SelectAll(false);
    726         OnAfterUserAction();
    727       }
    728       CreateTouchSelectionControllerAndNotifyIt();
    729 #if defined(OS_WIN)
    730       if (!read_only())
    731         base::win::DisplayVirtualKeyboard();
    732 #endif
    733       event->SetHandled();
    734       break;
    735     case ui::ET_GESTURE_LONG_PRESS:
    736       if (!GetRenderText()->IsPointInSelection(event->location())) {
    737         // If long-press happens outside selection, select word and try to
    738         // activate touch selection.
    739         OnBeforeUserAction();
    740         SelectWordAt(event->location());
    741         OnAfterUserAction();
    742         CreateTouchSelectionControllerAndNotifyIt();
    743         // If touch selection activated successfully, mark event as handled so
    744         // that the regular context menu is not shown.
    745         if (touch_selection_controller_)
    746           event->SetHandled();
    747       } else {
    748         // If long-press happens on the selection, deactivate touch selection
    749         // and try to initiate drag-drop. If drag-drop is not enabled, context
    750         // menu will be shown. Event is not marked as handled to let Views
    751         // handle drag-drop or context menu.
    752         DestroyTouchSelection();
    753         initiating_drag_ = switches::IsTouchDragDropEnabled();
    754       }
    755       break;
    756     case ui::ET_GESTURE_LONG_TAP:
    757       // If touch selection is enabled, the context menu on long tap will be
    758       // shown by the |touch_selection_controller_|, hence we mark the event
    759       // handled so Views does not try to show context menu on it.
    760       if (touch_selection_controller_)
    761         event->SetHandled();
    762       break;
    763     case ui::ET_GESTURE_SCROLL_BEGIN:
    764       touch_handles_hidden_due_to_scroll_ = touch_selection_controller_ != NULL;
    765       DestroyTouchSelection();
    766       drag_start_location_ = event->location();
    767       drag_start_display_offset_ =
    768           GetRenderText()->GetUpdatedDisplayOffset().x();
    769       event->SetHandled();
    770       break;
    771     case ui::ET_GESTURE_SCROLL_UPDATE: {
    772       int new_offset = drag_start_display_offset_ + event->location().x() -
    773           drag_start_location_.x();
    774       GetRenderText()->SetDisplayOffset(new_offset);
    775       SchedulePaint();
    776       event->SetHandled();
    777       break;
    778     }
    779     case ui::ET_GESTURE_SCROLL_END:
    780     case ui::ET_SCROLL_FLING_START:
    781       if (touch_handles_hidden_due_to_scroll_) {
    782         CreateTouchSelectionControllerAndNotifyIt();
    783         touch_handles_hidden_due_to_scroll_ = false;
    784       }
    785       event->SetHandled();
    786       break;
    787     default:
    788       return;
    789   }
    790 }
    791 
    792 void Textfield::AboutToRequestFocusFromTabTraversal(bool reverse) {
    793   SelectAll(false);
    794 }
    795 
    796 bool Textfield::SkipDefaultKeyEventProcessing(const ui::KeyEvent& event) {
    797 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
    798   // Skip any accelerator handling that conflicts with custom keybindings.
    799   ui::TextEditKeyBindingsDelegateAuraLinux* delegate =
    800       ui::GetTextEditKeyBindingsDelegate();
    801   std::vector<ui::TextEditCommandAuraLinux> commands;
    802   if (delegate && delegate->MatchEvent(event, &commands)) {
    803     const bool rtl = GetTextDirection() == base::i18n::RIGHT_TO_LEFT;
    804     for (size_t i = 0; i < commands.size(); ++i)
    805       if (IsCommandIdEnabled(GetViewsCommand(commands[i], rtl)))
    806         return true;
    807   }
    808 #endif
    809 
    810   // Skip backspace accelerator handling; editable textfields handle this key.
    811   // Also skip processing Windows [Alt]+<num-pad digit> Unicode alt-codes.
    812   const bool is_backspace = event.key_code() == ui::VKEY_BACK;
    813   return (is_backspace && !read_only()) || event.IsUnicodeKeyCode();
    814 }
    815 
    816 bool Textfield::GetDropFormats(
    817     int* formats,
    818     std::set<OSExchangeData::CustomFormat>* custom_formats) {
    819   if (!enabled() || read_only())
    820     return false;
    821   // TODO(msw): Can we support URL, FILENAME, etc.?
    822   *formats = ui::OSExchangeData::STRING;
    823   if (controller_)
    824     controller_->AppendDropFormats(formats, custom_formats);
    825   return true;
    826 }
    827 
    828 bool Textfield::CanDrop(const OSExchangeData& data) {
    829   int formats;
    830   std::set<OSExchangeData::CustomFormat> custom_formats;
    831   GetDropFormats(&formats, &custom_formats);
    832   return enabled() && !read_only() &&
    833       data.HasAnyFormat(formats, custom_formats);
    834 }
    835 
    836 int Textfield::OnDragUpdated(const ui::DropTargetEvent& event) {
    837   DCHECK(CanDrop(event.data()));
    838   gfx::RenderText* render_text = GetRenderText();
    839   const gfx::Range& selection = render_text->selection();
    840   drop_cursor_position_ = render_text->FindCursorPosition(event.location());
    841   bool in_selection = !selection.is_empty() &&
    842       selection.Contains(gfx::Range(drop_cursor_position_.caret_pos()));
    843   drop_cursor_visible_ = !in_selection;
    844   // TODO(msw): Pan over text when the user drags to the visible text edge.
    845   OnCaretBoundsChanged();
    846   SchedulePaint();
    847 
    848   if (initiating_drag_) {
    849     if (in_selection)
    850       return ui::DragDropTypes::DRAG_NONE;
    851     return event.IsControlDown() ? ui::DragDropTypes::DRAG_COPY :
    852                                    ui::DragDropTypes::DRAG_MOVE;
    853   }
    854   return ui::DragDropTypes::DRAG_COPY | ui::DragDropTypes::DRAG_MOVE;
    855 }
    856 
    857 void Textfield::OnDragExited() {
    858   drop_cursor_visible_ = false;
    859   SchedulePaint();
    860 }
    861 
    862 int Textfield::OnPerformDrop(const ui::DropTargetEvent& event) {
    863   DCHECK(CanDrop(event.data()));
    864   drop_cursor_visible_ = false;
    865 
    866   if (controller_) {
    867     int drag_operation = controller_->OnDrop(event.data());
    868     if (drag_operation != ui::DragDropTypes::DRAG_NONE)
    869       return drag_operation;
    870   }
    871 
    872   gfx::RenderText* render_text = GetRenderText();
    873   DCHECK(!initiating_drag_ ||
    874          !render_text->IsPointInSelection(event.location()));
    875   OnBeforeUserAction();
    876   skip_input_method_cancel_composition_ = true;
    877 
    878   gfx::SelectionModel drop_destination_model =
    879       render_text->FindCursorPosition(event.location());
    880   base::string16 new_text;
    881   event.data().GetString(&new_text);
    882 
    883   // Delete the current selection for a drag and drop within this view.
    884   const bool move = initiating_drag_ && !event.IsControlDown() &&
    885                     event.source_operations() & ui::DragDropTypes::DRAG_MOVE;
    886   if (move) {
    887     // Adjust the drop destination if it is on or after the current selection.
    888     size_t pos = drop_destination_model.caret_pos();
    889     pos -= render_text->selection().Intersect(gfx::Range(0, pos)).length();
    890     model_->DeleteSelectionAndInsertTextAt(new_text, pos);
    891   } else {
    892     model_->MoveCursorTo(drop_destination_model);
    893     // Drop always inserts text even if the textfield is not in insert mode.
    894     model_->InsertText(new_text);
    895   }
    896   skip_input_method_cancel_composition_ = false;
    897   UpdateAfterChange(true, true);
    898   OnAfterUserAction();
    899   return move ? ui::DragDropTypes::DRAG_MOVE : ui::DragDropTypes::DRAG_COPY;
    900 }
    901 
    902 void Textfield::OnDragDone() {
    903   initiating_drag_ = false;
    904   drop_cursor_visible_ = false;
    905 }
    906 
    907 void Textfield::GetAccessibleState(ui::AXViewState* state) {
    908   state->role = ui::AX_ROLE_TEXT_FIELD;
    909   state->name = accessible_name_;
    910   if (read_only())
    911     state->AddStateFlag(ui::AX_STATE_READ_ONLY);
    912   if (text_input_type_ == ui::TEXT_INPUT_TYPE_PASSWORD)
    913     state->AddStateFlag(ui::AX_STATE_PROTECTED);
    914   state->value = text();
    915 
    916   const gfx::Range range = GetSelectedRange();
    917   state->selection_start = range.start();
    918   state->selection_end = range.end();
    919 
    920   if (!read_only()) {
    921     state->set_value_callback =
    922         base::Bind(&Textfield::AccessibilitySetValue,
    923                    weak_ptr_factory_.GetWeakPtr());
    924   }
    925 }
    926 
    927 void Textfield::OnBoundsChanged(const gfx::Rect& previous_bounds) {
    928   // Textfield insets include a reasonable amount of whitespace on all sides of
    929   // the default font list. Fallback fonts with larger heights may paint over
    930   // the vertical whitespace as needed. Alternate solutions involve undesirable
    931   // behavior like changing the default font size, shrinking some fallback fonts
    932   // beyond their legibility, or enlarging controls dynamically with content.
    933   gfx::Rect bounds = GetContentsBounds();
    934   // GetContentsBounds() does not actually use the local GetInsets() override.
    935   bounds.Inset(gfx::Insets(0, kTextPadding, 0, kTextPadding));
    936   GetRenderText()->SetDisplayRect(bounds);
    937   OnCaretBoundsChanged();
    938 }
    939 
    940 bool Textfield::GetNeedsNotificationWhenVisibleBoundsChange() const {
    941   return true;
    942 }
    943 
    944 void Textfield::OnVisibleBoundsChanged() {
    945   if (touch_selection_controller_)
    946     touch_selection_controller_->SelectionChanged();
    947 }
    948 
    949 void Textfield::OnEnabledChanged() {
    950   View::OnEnabledChanged();
    951   if (GetInputMethod())
    952     GetInputMethod()->OnTextInputTypeChanged(this);
    953   SchedulePaint();
    954 }
    955 
    956 void Textfield::OnPaint(gfx::Canvas* canvas) {
    957   OnPaintBackground(canvas);
    958   PaintTextAndCursor(canvas);
    959   OnPaintBorder(canvas);
    960 }
    961 
    962 void Textfield::OnFocus() {
    963   GetRenderText()->set_focused(true);
    964   cursor_visible_ = true;
    965   SchedulePaint();
    966   GetInputMethod()->OnFocus();
    967   OnCaretBoundsChanged();
    968 
    969   const size_t caret_blink_ms = Textfield::GetCaretBlinkMs();
    970   if (caret_blink_ms != 0) {
    971     cursor_repaint_timer_.Start(FROM_HERE,
    972         base::TimeDelta::FromMilliseconds(caret_blink_ms), this,
    973         &Textfield::UpdateCursor);
    974   }
    975 
    976   View::OnFocus();
    977   SchedulePaint();
    978 }
    979 
    980 void Textfield::OnBlur() {
    981   GetRenderText()->set_focused(false);
    982   GetInputMethod()->OnBlur();
    983   cursor_repaint_timer_.Stop();
    984   if (cursor_visible_) {
    985     cursor_visible_ = false;
    986     RepaintCursor();
    987   }
    988 
    989   DestroyTouchSelection();
    990 
    991   // Border typically draws focus indicator.
    992   SchedulePaint();
    993 }
    994 
    995 gfx::Point Textfield::GetKeyboardContextMenuLocation() {
    996   return GetCaretBounds().bottom_right();
    997 }
    998 
    999 void Textfield::OnNativeThemeChanged(const ui::NativeTheme* theme) {
   1000   gfx::RenderText* render_text = GetRenderText();
   1001   render_text->SetColor(GetTextColor());
   1002   UpdateBackgroundColor();
   1003   render_text->set_cursor_color(GetTextColor());
   1004   render_text->set_selection_color(GetSelectionTextColor());
   1005   render_text->set_selection_background_focused_color(
   1006       GetSelectionBackgroundColor());
   1007 }
   1008 
   1009 ////////////////////////////////////////////////////////////////////////////////
   1010 // Textfield, TextfieldModel::Delegate overrides:
   1011 
   1012 void Textfield::OnCompositionTextConfirmedOrCleared() {
   1013   if (!skip_input_method_cancel_composition_)
   1014     GetInputMethod()->CancelComposition(this);
   1015 }
   1016 
   1017 ////////////////////////////////////////////////////////////////////////////////
   1018 // Textfield, ContextMenuController overrides:
   1019 
   1020 void Textfield::ShowContextMenuForView(View* source,
   1021                                        const gfx::Point& point,
   1022                                        ui::MenuSourceType source_type) {
   1023   UpdateContextMenu();
   1024   ignore_result(context_menu_runner_->RunMenuAt(GetWidget(),
   1025                                                 NULL,
   1026                                                 gfx::Rect(point, gfx::Size()),
   1027                                                 MENU_ANCHOR_TOPLEFT,
   1028                                                 source_type));
   1029 }
   1030 
   1031 ////////////////////////////////////////////////////////////////////////////////
   1032 // Textfield, DragController overrides:
   1033 
   1034 void Textfield::WriteDragDataForView(View* sender,
   1035                                      const gfx::Point& press_pt,
   1036                                      OSExchangeData* data) {
   1037   const base::string16& selected_text(GetSelectedText());
   1038   data->SetString(selected_text);
   1039   Label label(selected_text, GetFontList());
   1040   label.SetBackgroundColor(GetBackgroundColor());
   1041   label.SetSubpixelRenderingEnabled(false);
   1042   gfx::Size size(label.GetPreferredSize());
   1043   gfx::NativeView native_view = GetWidget()->GetNativeView();
   1044   gfx::Display display = gfx::Screen::GetScreenFor(native_view)->
   1045       GetDisplayNearestWindow(native_view);
   1046   size.SetToMin(gfx::Size(display.size().width(), height()));
   1047   label.SetBoundsRect(gfx::Rect(size));
   1048   scoped_ptr<gfx::Canvas> canvas(
   1049       GetCanvasForDragImage(GetWidget(), label.size()));
   1050   label.SetEnabledColor(GetTextColor());
   1051 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   1052   // Desktop Linux Aura does not yet support transparency in drag images.
   1053   canvas->DrawColor(GetBackgroundColor());
   1054 #endif
   1055   label.Paint(canvas.get(), views::CullSet());
   1056   const gfx::Vector2d kOffset(-15, 0);
   1057   drag_utils::SetDragImageOnDataObject(*canvas, kOffset, data);
   1058   if (controller_)
   1059     controller_->OnWriteDragData(data);
   1060 }
   1061 
   1062 int Textfield::GetDragOperationsForView(View* sender, const gfx::Point& p) {
   1063   int drag_operations = ui::DragDropTypes::DRAG_COPY;
   1064   if (!enabled() || text_input_type_ == ui::TEXT_INPUT_TYPE_PASSWORD ||
   1065       !GetRenderText()->IsPointInSelection(p)) {
   1066     drag_operations = ui::DragDropTypes::DRAG_NONE;
   1067   } else if (sender == this && !read_only()) {
   1068     drag_operations =
   1069         ui::DragDropTypes::DRAG_MOVE | ui::DragDropTypes::DRAG_COPY;
   1070   }
   1071   if (controller_)
   1072     controller_->OnGetDragOperationsForTextfield(&drag_operations);
   1073   return drag_operations;
   1074 }
   1075 
   1076 bool Textfield::CanStartDragForView(View* sender,
   1077                                     const gfx::Point& press_pt,
   1078                                     const gfx::Point& p) {
   1079   return initiating_drag_ && GetRenderText()->IsPointInSelection(press_pt);
   1080 }
   1081 
   1082 ////////////////////////////////////////////////////////////////////////////////
   1083 // Textfield, ui::TouchEditable overrides:
   1084 
   1085 void Textfield::SelectRect(const gfx::Point& start, const gfx::Point& end) {
   1086   if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE)
   1087     return;
   1088 
   1089   gfx::SelectionModel start_caret = GetRenderText()->FindCursorPosition(start);
   1090   gfx::SelectionModel end_caret = GetRenderText()->FindCursorPosition(end);
   1091   gfx::SelectionModel selection(
   1092       gfx::Range(start_caret.caret_pos(), end_caret.caret_pos()),
   1093       end_caret.caret_affinity());
   1094 
   1095   OnBeforeUserAction();
   1096   SelectSelectionModel(selection);
   1097   OnAfterUserAction();
   1098 }
   1099 
   1100 void Textfield::MoveCaretTo(const gfx::Point& point) {
   1101   SelectRect(point, point);
   1102 }
   1103 
   1104 void Textfield::GetSelectionEndPoints(gfx::Rect* p1, gfx::Rect* p2) {
   1105   gfx::RenderText* render_text = GetRenderText();
   1106   const gfx::SelectionModel& sel = render_text->selection_model();
   1107   gfx::SelectionModel start_sel =
   1108       render_text->GetSelectionModelForSelectionStart();
   1109   *p1 = render_text->GetCursorBounds(start_sel, true);
   1110   *p2 = render_text->GetCursorBounds(sel, true);
   1111 }
   1112 
   1113 gfx::Rect Textfield::GetBounds() {
   1114   return GetLocalBounds();
   1115 }
   1116 
   1117 gfx::NativeView Textfield::GetNativeView() const {
   1118   return GetWidget()->GetNativeView();
   1119 }
   1120 
   1121 void Textfield::ConvertPointToScreen(gfx::Point* point) {
   1122   View::ConvertPointToScreen(this, point);
   1123 }
   1124 
   1125 void Textfield::ConvertPointFromScreen(gfx::Point* point) {
   1126   View::ConvertPointFromScreen(this, point);
   1127 }
   1128 
   1129 bool Textfield::DrawsHandles() {
   1130   return false;
   1131 }
   1132 
   1133 void Textfield::OpenContextMenu(const gfx::Point& anchor) {
   1134   DestroyTouchSelection();
   1135   ShowContextMenu(anchor, ui::MENU_SOURCE_TOUCH_EDIT_MENU);
   1136 }
   1137 
   1138 void Textfield::DestroyTouchSelection() {
   1139   touch_selection_controller_.reset();
   1140 }
   1141 
   1142 ////////////////////////////////////////////////////////////////////////////////
   1143 // Textfield, ui::SimpleMenuModel::Delegate overrides:
   1144 
   1145 bool Textfield::IsCommandIdChecked(int command_id) const {
   1146   return true;
   1147 }
   1148 
   1149 bool Textfield::IsCommandIdEnabled(int command_id) const {
   1150   base::string16 result;
   1151   bool editable = !read_only();
   1152   bool readable = text_input_type_ != ui::TEXT_INPUT_TYPE_PASSWORD;
   1153   switch (command_id) {
   1154     case IDS_APP_UNDO:
   1155       return editable && model_->CanUndo();
   1156     case IDS_APP_REDO:
   1157       return editable && model_->CanRedo();
   1158     case IDS_APP_CUT:
   1159       return editable && readable && model_->HasSelection();
   1160     case IDS_APP_COPY:
   1161       return readable && model_->HasSelection();
   1162     case IDS_APP_PASTE:
   1163       ui::Clipboard::GetForCurrentThread()->ReadText(
   1164           ui::CLIPBOARD_TYPE_COPY_PASTE, &result);
   1165       return editable && !result.empty();
   1166     case IDS_APP_DELETE:
   1167       return editable && model_->HasSelection();
   1168     case IDS_APP_SELECT_ALL:
   1169       return !text().empty();
   1170     case IDS_DELETE_FORWARD:
   1171     case IDS_DELETE_BACKWARD:
   1172     case IDS_DELETE_TO_BEGINNING_OF_LINE:
   1173     case IDS_DELETE_TO_END_OF_LINE:
   1174     case IDS_DELETE_WORD_BACKWARD:
   1175     case IDS_DELETE_WORD_FORWARD:
   1176       return editable;
   1177     case IDS_MOVE_LEFT:
   1178     case IDS_MOVE_LEFT_AND_MODIFY_SELECTION:
   1179     case IDS_MOVE_RIGHT:
   1180     case IDS_MOVE_RIGHT_AND_MODIFY_SELECTION:
   1181     case IDS_MOVE_WORD_LEFT:
   1182     case IDS_MOVE_WORD_LEFT_AND_MODIFY_SELECTION:
   1183     case IDS_MOVE_WORD_RIGHT:
   1184     case IDS_MOVE_WORD_RIGHT_AND_MODIFY_SELECTION:
   1185     case IDS_MOVE_TO_BEGINNING_OF_LINE:
   1186     case IDS_MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION:
   1187     case IDS_MOVE_TO_END_OF_LINE:
   1188     case IDS_MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION:
   1189       return true;
   1190     default:
   1191       return false;
   1192   }
   1193 }
   1194 
   1195 bool Textfield::GetAcceleratorForCommandId(int command_id,
   1196                                            ui::Accelerator* accelerator) {
   1197   return false;
   1198 }
   1199 
   1200 void Textfield::ExecuteCommand(int command_id, int event_flags) {
   1201   DestroyTouchSelection();
   1202   if (!IsCommandIdEnabled(command_id))
   1203     return;
   1204 
   1205   bool text_changed = false;
   1206   bool cursor_changed = false;
   1207   bool rtl = GetTextDirection() == base::i18n::RIGHT_TO_LEFT;
   1208   gfx::VisualCursorDirection begin = rtl ? gfx::CURSOR_RIGHT : gfx::CURSOR_LEFT;
   1209   gfx::VisualCursorDirection end = rtl ? gfx::CURSOR_LEFT : gfx::CURSOR_RIGHT;
   1210   gfx::SelectionModel selection_model = GetSelectionModel();
   1211 
   1212   OnBeforeUserAction();
   1213   switch (command_id) {
   1214     case IDS_APP_UNDO:
   1215       text_changed = cursor_changed = model_->Undo();
   1216       break;
   1217     case IDS_APP_REDO:
   1218       text_changed = cursor_changed = model_->Redo();
   1219       break;
   1220     case IDS_APP_CUT:
   1221       text_changed = cursor_changed = Cut();
   1222       break;
   1223     case IDS_APP_COPY:
   1224       Copy();
   1225       break;
   1226     case IDS_APP_PASTE:
   1227       text_changed = cursor_changed = Paste();
   1228       break;
   1229     case IDS_APP_DELETE:
   1230       text_changed = cursor_changed = model_->Delete();
   1231       break;
   1232     case IDS_APP_SELECT_ALL:
   1233       SelectAll(false);
   1234       break;
   1235     case IDS_DELETE_BACKWARD:
   1236       text_changed = cursor_changed = model_->Backspace();
   1237       break;
   1238     case IDS_DELETE_FORWARD:
   1239       text_changed = cursor_changed = model_->Delete();
   1240       break;
   1241     case IDS_DELETE_TO_END_OF_LINE:
   1242       model_->MoveCursor(gfx::LINE_BREAK, end, true);
   1243       text_changed = cursor_changed = model_->Delete();
   1244       break;
   1245     case IDS_DELETE_TO_BEGINNING_OF_LINE:
   1246       model_->MoveCursor(gfx::LINE_BREAK, begin, true);
   1247       text_changed = cursor_changed = model_->Backspace();
   1248       break;
   1249     case IDS_DELETE_WORD_BACKWARD:
   1250       model_->MoveCursor(gfx::WORD_BREAK, begin, true);
   1251       text_changed = cursor_changed = model_->Backspace();
   1252       break;
   1253     case IDS_DELETE_WORD_FORWARD:
   1254       model_->MoveCursor(gfx::WORD_BREAK, end, true);
   1255       text_changed = cursor_changed = model_->Delete();
   1256       break;
   1257     case IDS_MOVE_LEFT:
   1258       model_->MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, false);
   1259       break;
   1260     case IDS_MOVE_LEFT_AND_MODIFY_SELECTION:
   1261       model_->MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_LEFT, true);
   1262       break;
   1263     case IDS_MOVE_RIGHT:
   1264       model_->MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, false);
   1265       break;
   1266     case IDS_MOVE_RIGHT_AND_MODIFY_SELECTION:
   1267       model_->MoveCursor(gfx::CHARACTER_BREAK, gfx::CURSOR_RIGHT, true);
   1268       break;
   1269     case IDS_MOVE_WORD_LEFT:
   1270       model_->MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, false);
   1271       break;
   1272     case IDS_MOVE_WORD_LEFT_AND_MODIFY_SELECTION:
   1273       model_->MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_LEFT, true);
   1274       break;
   1275     case IDS_MOVE_WORD_RIGHT:
   1276       model_->MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, false);
   1277       break;
   1278     case IDS_MOVE_WORD_RIGHT_AND_MODIFY_SELECTION:
   1279       model_->MoveCursor(gfx::WORD_BREAK, gfx::CURSOR_RIGHT, true);
   1280       break;
   1281     case IDS_MOVE_TO_BEGINNING_OF_LINE:
   1282       model_->MoveCursor(gfx::LINE_BREAK, begin, false);
   1283       break;
   1284     case IDS_MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION:
   1285       model_->MoveCursor(gfx::LINE_BREAK, begin, true);
   1286       break;
   1287     case IDS_MOVE_TO_END_OF_LINE:
   1288       model_->MoveCursor(gfx::LINE_BREAK, end, false);
   1289       break;
   1290     case IDS_MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION:
   1291       model_->MoveCursor(gfx::LINE_BREAK, end, true);
   1292       break;
   1293     default:
   1294       NOTREACHED();
   1295       break;
   1296   }
   1297 
   1298   cursor_changed |= GetSelectionModel() != selection_model;
   1299   if (cursor_changed)
   1300     UpdateSelectionClipboard();
   1301   UpdateAfterChange(text_changed, cursor_changed);
   1302   OnAfterUserAction();
   1303 }
   1304 
   1305 ////////////////////////////////////////////////////////////////////////////////
   1306 // Textfield, ui::TextInputClient overrides:
   1307 
   1308 void Textfield::SetCompositionText(const ui::CompositionText& composition) {
   1309   if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE)
   1310     return;
   1311 
   1312   OnBeforeUserAction();
   1313   skip_input_method_cancel_composition_ = true;
   1314   model_->SetCompositionText(composition);
   1315   skip_input_method_cancel_composition_ = false;
   1316   UpdateAfterChange(true, true);
   1317   OnAfterUserAction();
   1318 }
   1319 
   1320 void Textfield::ConfirmCompositionText() {
   1321   if (!model_->HasCompositionText())
   1322     return;
   1323 
   1324   OnBeforeUserAction();
   1325   skip_input_method_cancel_composition_ = true;
   1326   model_->ConfirmCompositionText();
   1327   skip_input_method_cancel_composition_ = false;
   1328   UpdateAfterChange(true, true);
   1329   OnAfterUserAction();
   1330 }
   1331 
   1332 void Textfield::ClearCompositionText() {
   1333   if (!model_->HasCompositionText())
   1334     return;
   1335 
   1336   OnBeforeUserAction();
   1337   skip_input_method_cancel_composition_ = true;
   1338   model_->CancelCompositionText();
   1339   skip_input_method_cancel_composition_ = false;
   1340   UpdateAfterChange(true, true);
   1341   OnAfterUserAction();
   1342 }
   1343 
   1344 void Textfield::InsertText(const base::string16& new_text) {
   1345   // TODO(suzhe): Filter invalid characters.
   1346   if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE || new_text.empty())
   1347     return;
   1348 
   1349   OnBeforeUserAction();
   1350   skip_input_method_cancel_composition_ = true;
   1351   if (GetRenderText()->insert_mode())
   1352     model_->InsertText(new_text);
   1353   else
   1354     model_->ReplaceText(new_text);
   1355   skip_input_method_cancel_composition_ = false;
   1356   UpdateAfterChange(true, true);
   1357   OnAfterUserAction();
   1358 }
   1359 
   1360 void Textfield::InsertChar(base::char16 ch, int flags) {
   1361   const int kControlModifierMask = ui::EF_CONTROL_DOWN | ui::EF_ALT_DOWN |
   1362                                    ui::EF_COMMAND_DOWN | ui::EF_ALTGR_DOWN |
   1363                                    ui::EF_MOD3_DOWN;
   1364 
   1365   // Filter out all control characters, including tab and new line characters,
   1366   // and all characters with Alt modifier. But allow characters with the AltGr
   1367   // modifier. On Windows AltGr is represented by Alt+Ctrl, and on Linux it's a
   1368   // different flag that we don't care about.
   1369   const bool should_insert_char =
   1370       ((ch >= 0x20 && ch < 0x7F) || ch > 0x9F) &&
   1371       (flags & kControlModifierMask) != ui::EF_ALT_DOWN;
   1372   if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE || !should_insert_char)
   1373     return;
   1374 
   1375   OnBeforeUserAction();
   1376   skip_input_method_cancel_composition_ = true;
   1377   if (GetRenderText()->insert_mode())
   1378     model_->InsertChar(ch);
   1379   else
   1380     model_->ReplaceChar(ch);
   1381   skip_input_method_cancel_composition_ = false;
   1382 
   1383   UpdateAfterChange(true, true);
   1384   OnAfterUserAction();
   1385 
   1386   if (text_input_type_ == ui::TEXT_INPUT_TYPE_PASSWORD &&
   1387       password_reveal_duration_ != base::TimeDelta()) {
   1388     const size_t change_offset = model_->GetCursorPosition();
   1389     DCHECK_GT(change_offset, 0u);
   1390     RevealPasswordChar(change_offset - 1);
   1391   }
   1392 }
   1393 
   1394 gfx::NativeWindow Textfield::GetAttachedWindow() const {
   1395   // Imagine the following hierarchy.
   1396   //   [NativeWidget A] - FocusManager
   1397   //     [View]
   1398   //     [NativeWidget B]
   1399   //       [View]
   1400   //         [View X]
   1401   // An important thing is that [NativeWidget A] owns Win32 input focus even
   1402   // when [View X] is logically focused by FocusManager. As a result, an Win32
   1403   // IME may want to interact with the native view of [NativeWidget A] rather
   1404   // than that of [NativeWidget B]. This is why we need to call
   1405   // GetTopLevelWidget() here.
   1406   return GetWidget()->GetTopLevelWidget()->GetNativeWindow();
   1407 }
   1408 
   1409 ui::TextInputType Textfield::GetTextInputType() const {
   1410   if (read_only() || !enabled())
   1411     return ui::TEXT_INPUT_TYPE_NONE;
   1412   return text_input_type_;
   1413 }
   1414 
   1415 ui::TextInputMode Textfield::GetTextInputMode() const {
   1416   return ui::TEXT_INPUT_MODE_DEFAULT;
   1417 }
   1418 
   1419 bool Textfield::CanComposeInline() const {
   1420   return true;
   1421 }
   1422 
   1423 gfx::Rect Textfield::GetCaretBounds() const {
   1424   gfx::Rect rect = GetRenderText()->GetUpdatedCursorBounds();
   1425   ConvertRectToScreen(this, &rect);
   1426   return rect;
   1427 }
   1428 
   1429 bool Textfield::GetCompositionCharacterBounds(uint32 index,
   1430                                               gfx::Rect* rect) const {
   1431   DCHECK(rect);
   1432   if (!HasCompositionText())
   1433     return false;
   1434   gfx::RenderText* render_text = GetRenderText();
   1435   const gfx::Range& composition_range = render_text->GetCompositionRange();
   1436   DCHECK(!composition_range.is_empty());
   1437 
   1438   size_t text_index = composition_range.start() + index;
   1439   if (composition_range.end() <= text_index)
   1440     return false;
   1441   if (!render_text->IsValidCursorIndex(text_index)) {
   1442     text_index = render_text->IndexOfAdjacentGrapheme(
   1443         text_index, gfx::CURSOR_BACKWARD);
   1444   }
   1445   if (text_index < composition_range.start())
   1446     return false;
   1447   const gfx::SelectionModel caret(text_index, gfx::CURSOR_BACKWARD);
   1448   *rect = render_text->GetCursorBounds(caret, false);
   1449   ConvertRectToScreen(this, rect);
   1450   return true;
   1451 }
   1452 
   1453 bool Textfield::HasCompositionText() const {
   1454   return model_->HasCompositionText();
   1455 }
   1456 
   1457 bool Textfield::GetTextRange(gfx::Range* range) const {
   1458   if (!ImeEditingAllowed())
   1459     return false;
   1460 
   1461   model_->GetTextRange(range);
   1462   return true;
   1463 }
   1464 
   1465 bool Textfield::GetCompositionTextRange(gfx::Range* range) const {
   1466   if (!ImeEditingAllowed())
   1467     return false;
   1468 
   1469   model_->GetCompositionTextRange(range);
   1470   return true;
   1471 }
   1472 
   1473 bool Textfield::GetSelectionRange(gfx::Range* range) const {
   1474   if (!ImeEditingAllowed())
   1475     return false;
   1476   *range = GetRenderText()->selection();
   1477   return true;
   1478 }
   1479 
   1480 bool Textfield::SetSelectionRange(const gfx::Range& range) {
   1481   if (!ImeEditingAllowed() || !range.IsValid())
   1482     return false;
   1483   OnBeforeUserAction();
   1484   SelectRange(range);
   1485   OnAfterUserAction();
   1486   return true;
   1487 }
   1488 
   1489 bool Textfield::DeleteRange(const gfx::Range& range) {
   1490   if (!ImeEditingAllowed() || range.is_empty())
   1491     return false;
   1492 
   1493   OnBeforeUserAction();
   1494   model_->SelectRange(range);
   1495   if (model_->HasSelection()) {
   1496     model_->DeleteSelection();
   1497     UpdateAfterChange(true, true);
   1498   }
   1499   OnAfterUserAction();
   1500   return true;
   1501 }
   1502 
   1503 bool Textfield::GetTextFromRange(const gfx::Range& range,
   1504                                  base::string16* range_text) const {
   1505   if (!ImeEditingAllowed() || !range.IsValid())
   1506     return false;
   1507 
   1508   gfx::Range text_range;
   1509   if (!GetTextRange(&text_range) || !text_range.Contains(range))
   1510     return false;
   1511 
   1512   *range_text = model_->GetTextFromRange(range);
   1513   return true;
   1514 }
   1515 
   1516 void Textfield::OnInputMethodChanged() {}
   1517 
   1518 bool Textfield::ChangeTextDirectionAndLayoutAlignment(
   1519     base::i18n::TextDirection direction) {
   1520   // Restore text directionality mode when the indicated direction matches the
   1521   // current forced mode; otherwise, force the mode indicated. This helps users
   1522   // manage BiDi text layout without getting stuck in forced LTR or RTL modes.
   1523   const gfx::DirectionalityMode mode = direction == base::i18n::RIGHT_TO_LEFT ?
   1524       gfx::DIRECTIONALITY_FORCE_RTL : gfx::DIRECTIONALITY_FORCE_LTR;
   1525   if (mode == GetRenderText()->directionality_mode())
   1526     GetRenderText()->SetDirectionalityMode(gfx::DIRECTIONALITY_FROM_TEXT);
   1527   else
   1528     GetRenderText()->SetDirectionalityMode(mode);
   1529   SchedulePaint();
   1530   return true;
   1531 }
   1532 
   1533 void Textfield::ExtendSelectionAndDelete(size_t before, size_t after) {
   1534   gfx::Range range = GetRenderText()->selection();
   1535   DCHECK_GE(range.start(), before);
   1536 
   1537   range.set_start(range.start() - before);
   1538   range.set_end(range.end() + after);
   1539   gfx::Range text_range;
   1540   if (GetTextRange(&text_range) && text_range.Contains(range))
   1541     DeleteRange(range);
   1542 }
   1543 
   1544 void Textfield::EnsureCaretInRect(const gfx::Rect& rect) {}
   1545 
   1546 void Textfield::OnCandidateWindowShown() {}
   1547 
   1548 void Textfield::OnCandidateWindowUpdated() {}
   1549 
   1550 void Textfield::OnCandidateWindowHidden() {}
   1551 
   1552 bool Textfield::IsEditingCommandEnabled(int command_id) {
   1553   return IsCommandIdEnabled(command_id);
   1554 }
   1555 
   1556 void Textfield::ExecuteEditingCommand(int command_id) {
   1557   ExecuteCommand(command_id);
   1558 }
   1559 
   1560 ////////////////////////////////////////////////////////////////////////////////
   1561 // Textfield, protected:
   1562 
   1563 gfx::RenderText* Textfield::GetRenderText() const {
   1564   return model_->render_text();
   1565 }
   1566 
   1567 base::string16 Textfield::GetSelectionClipboardText() const {
   1568   base::string16 selection_clipboard_text;
   1569   ui::Clipboard::GetForCurrentThread()->ReadText(
   1570       ui::CLIPBOARD_TYPE_SELECTION, &selection_clipboard_text);
   1571   return selection_clipboard_text;
   1572 }
   1573 
   1574 ////////////////////////////////////////////////////////////////////////////////
   1575 // Textfield, private:
   1576 
   1577 void Textfield::AccessibilitySetValue(const base::string16& new_value) {
   1578   if (!read_only()) {
   1579     SetText(new_value);
   1580     ClearSelection();
   1581   }
   1582 }
   1583 
   1584 void Textfield::UpdateBackgroundColor() {
   1585   const SkColor color = GetBackgroundColor();
   1586   set_background(Background::CreateSolidBackground(color));
   1587   GetRenderText()->set_background_is_transparent(SkColorGetA(color) != 0xFF);
   1588   SchedulePaint();
   1589 }
   1590 
   1591 void Textfield::UpdateAfterChange(bool text_changed, bool cursor_changed) {
   1592   if (text_changed) {
   1593     if (controller_)
   1594       controller_->ContentsChanged(this, text());
   1595     NotifyAccessibilityEvent(ui::AX_EVENT_TEXT_CHANGED, true);
   1596   }
   1597   if (cursor_changed) {
   1598     cursor_visible_ = true;
   1599     RepaintCursor();
   1600     if (cursor_repaint_timer_.IsRunning())
   1601       cursor_repaint_timer_.Reset();
   1602     if (!text_changed) {
   1603       // TEXT_CHANGED implies TEXT_SELECTION_CHANGED, so we only need to fire
   1604       // this if only the selection changed.
   1605       NotifyAccessibilityEvent(ui::AX_EVENT_TEXT_SELECTION_CHANGED, true);
   1606     }
   1607   }
   1608   if (text_changed || cursor_changed) {
   1609     OnCaretBoundsChanged();
   1610     SchedulePaint();
   1611   }
   1612 }
   1613 
   1614 void Textfield::UpdateCursor() {
   1615   const size_t caret_blink_ms = Textfield::GetCaretBlinkMs();
   1616   cursor_visible_ = !cursor_visible_ || (caret_blink_ms == 0);
   1617   RepaintCursor();
   1618 }
   1619 
   1620 void Textfield::RepaintCursor() {
   1621   gfx::Rect r(GetRenderText()->GetUpdatedCursorBounds());
   1622   r.Inset(-1, -1, -1, -1);
   1623   SchedulePaintInRect(r);
   1624 }
   1625 
   1626 void Textfield::PaintTextAndCursor(gfx::Canvas* canvas) {
   1627   TRACE_EVENT0("views", "Textfield::PaintTextAndCursor");
   1628   canvas->Save();
   1629 
   1630   // Draw placeholder text if needed.
   1631   gfx::RenderText* render_text = GetRenderText();
   1632   if (text().empty() && !GetPlaceholderText().empty()) {
   1633     canvas->DrawStringRect(GetPlaceholderText(), GetFontList(),
   1634         placeholder_text_color(), render_text->display_rect());
   1635   }
   1636 
   1637   // Draw the text, cursor, and selection.
   1638   render_text->set_cursor_visible(cursor_visible_ && !drop_cursor_visible_ &&
   1639                                   !HasSelection());
   1640   render_text->Draw(canvas);
   1641 
   1642   // Draw the detached drop cursor that marks where the text will be dropped.
   1643   if (drop_cursor_visible_)
   1644     render_text->DrawCursor(canvas, drop_cursor_position_);
   1645 
   1646   canvas->Restore();
   1647 }
   1648 
   1649 void Textfield::MoveCursorTo(const gfx::Point& point, bool select) {
   1650   if (model_->MoveCursorTo(point, select))
   1651     UpdateAfterChange(false, true);
   1652 }
   1653 
   1654 void Textfield::SelectThroughLastDragLocation() {
   1655   OnBeforeUserAction();
   1656   model_->MoveCursorTo(last_drag_location_, true);
   1657   if (aggregated_clicks_ == 1) {
   1658     model_->SelectWord();
   1659     // Expand the selection so the initially selected word remains selected.
   1660     gfx::Range selection = GetRenderText()->selection();
   1661     const size_t min = std::min(selection.GetMin(),
   1662                                 double_click_word_.GetMin());
   1663     const size_t max = std::max(selection.GetMax(),
   1664                                 double_click_word_.GetMax());
   1665     const bool reversed = selection.is_reversed();
   1666     selection.set_start(reversed ? max : min);
   1667     selection.set_end(reversed ? min : max);
   1668     model_->SelectRange(selection);
   1669   }
   1670   UpdateAfterChange(false, true);
   1671   OnAfterUserAction();
   1672 }
   1673 
   1674 void Textfield::OnCaretBoundsChanged() {
   1675   if (GetInputMethod())
   1676     GetInputMethod()->OnCaretBoundsChanged(this);
   1677   if (touch_selection_controller_)
   1678     touch_selection_controller_->SelectionChanged();
   1679 }
   1680 
   1681 void Textfield::OnBeforeUserAction() {
   1682   DCHECK(!performing_user_action_);
   1683   performing_user_action_ = true;
   1684   if (controller_)
   1685     controller_->OnBeforeUserAction(this);
   1686 }
   1687 
   1688 void Textfield::OnAfterUserAction() {
   1689   if (controller_)
   1690     controller_->OnAfterUserAction(this);
   1691   DCHECK(performing_user_action_);
   1692   performing_user_action_ = false;
   1693 }
   1694 
   1695 bool Textfield::Cut() {
   1696   if (!read_only() && text_input_type_ != ui::TEXT_INPUT_TYPE_PASSWORD &&
   1697       model_->Cut()) {
   1698     if (controller_)
   1699       controller_->OnAfterCutOrCopy(ui::CLIPBOARD_TYPE_COPY_PASTE);
   1700     return true;
   1701   }
   1702   return false;
   1703 }
   1704 
   1705 bool Textfield::Copy() {
   1706   if (text_input_type_ != ui::TEXT_INPUT_TYPE_PASSWORD && model_->Copy()) {
   1707     if (controller_)
   1708       controller_->OnAfterCutOrCopy(ui::CLIPBOARD_TYPE_COPY_PASTE);
   1709     return true;
   1710   }
   1711   return false;
   1712 }
   1713 
   1714 bool Textfield::Paste() {
   1715   if (!read_only() && model_->Paste()) {
   1716     if (controller_)
   1717       controller_->OnAfterPaste();
   1718     return true;
   1719   }
   1720   return false;
   1721 }
   1722 
   1723 void Textfield::UpdateContextMenu() {
   1724   if (!context_menu_contents_.get()) {
   1725     context_menu_contents_.reset(new ui::SimpleMenuModel(this));
   1726     context_menu_contents_->AddItemWithStringId(IDS_APP_UNDO, IDS_APP_UNDO);
   1727     context_menu_contents_->AddSeparator(ui::NORMAL_SEPARATOR);
   1728     context_menu_contents_->AddItemWithStringId(IDS_APP_CUT, IDS_APP_CUT);
   1729     context_menu_contents_->AddItemWithStringId(IDS_APP_COPY, IDS_APP_COPY);
   1730     context_menu_contents_->AddItemWithStringId(IDS_APP_PASTE, IDS_APP_PASTE);
   1731     context_menu_contents_->AddItemWithStringId(IDS_APP_DELETE, IDS_APP_DELETE);
   1732     context_menu_contents_->AddSeparator(ui::NORMAL_SEPARATOR);
   1733     context_menu_contents_->AddItemWithStringId(IDS_APP_SELECT_ALL,
   1734                                                 IDS_APP_SELECT_ALL);
   1735     if (controller_)
   1736       controller_->UpdateContextMenu(context_menu_contents_.get());
   1737   }
   1738   context_menu_runner_.reset(
   1739       new MenuRunner(context_menu_contents_.get(),
   1740                      MenuRunner::HAS_MNEMONICS | MenuRunner::CONTEXT_MENU));
   1741 }
   1742 
   1743 void Textfield::TrackMouseClicks(const ui::MouseEvent& event) {
   1744   if (event.IsOnlyLeftMouseButton()) {
   1745     base::TimeDelta time_delta = event.time_stamp() - last_click_time_;
   1746     if (time_delta.InMilliseconds() <= GetDoubleClickInterval() &&
   1747         !ExceededDragThreshold(event.location() - last_click_location_)) {
   1748       // Upon clicking after a triple click, the count should go back to double
   1749       // click and alternate between double and triple. This assignment maps
   1750       // 0 to 1, 1 to 2, 2 to 1.
   1751       aggregated_clicks_ = (aggregated_clicks_ % 2) + 1;
   1752     } else {
   1753       aggregated_clicks_ = 0;
   1754     }
   1755     last_click_time_ = event.time_stamp();
   1756     last_click_location_ = event.location();
   1757   }
   1758 }
   1759 
   1760 bool Textfield::ImeEditingAllowed() const {
   1761   // Disallow input method editing of password fields.
   1762   ui::TextInputType t = GetTextInputType();
   1763   return (t != ui::TEXT_INPUT_TYPE_NONE && t != ui::TEXT_INPUT_TYPE_PASSWORD);
   1764 }
   1765 
   1766 void Textfield::RevealPasswordChar(int index) {
   1767   GetRenderText()->SetObscuredRevealIndex(index);
   1768   SchedulePaint();
   1769 
   1770   if (index != -1) {
   1771     password_reveal_timer_.Start(FROM_HERE, password_reveal_duration_,
   1772         base::Bind(&Textfield::RevealPasswordChar,
   1773                    weak_ptr_factory_.GetWeakPtr(), -1));
   1774   }
   1775 }
   1776 
   1777 void Textfield::CreateTouchSelectionControllerAndNotifyIt() {
   1778   if (!HasFocus())
   1779     return;
   1780 
   1781   if (!touch_selection_controller_) {
   1782     touch_selection_controller_.reset(
   1783         ui::TouchSelectionController::create(this));
   1784   }
   1785   if (touch_selection_controller_)
   1786     touch_selection_controller_->SelectionChanged();
   1787 }
   1788 
   1789 void Textfield::UpdateSelectionClipboard() const {
   1790 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   1791   if (performing_user_action_ && HasSelection()) {
   1792     ui::ScopedClipboardWriter(
   1793         ui::CLIPBOARD_TYPE_SELECTION).WriteText(GetSelectedText());
   1794     if (controller_)
   1795       controller_->OnAfterCutOrCopy(ui::CLIPBOARD_TYPE_SELECTION);
   1796   }
   1797 #endif
   1798 }
   1799 
   1800 void Textfield::PasteSelectionClipboard(const ui::MouseEvent& event) {
   1801   DCHECK(event.IsOnlyMiddleMouseButton());
   1802   DCHECK(!read_only());
   1803   base::string16 selection_clipboard_text = GetSelectionClipboardText();
   1804   if (!selection_clipboard_text.empty()) {
   1805     OnBeforeUserAction();
   1806     gfx::Range range = GetSelectionModel().selection();
   1807     gfx::LogicalCursorDirection affinity = GetSelectionModel().caret_affinity();
   1808     const gfx::SelectionModel mouse =
   1809         GetRenderText()->FindCursorPosition(event.location());
   1810     model_->MoveCursorTo(mouse);
   1811     model_->InsertText(selection_clipboard_text);
   1812     // Update the new selection range as needed.
   1813     if (range.GetMin() >= mouse.caret_pos()) {
   1814       const size_t length = selection_clipboard_text.length();
   1815       range = gfx::Range(range.start() + length, range.end() + length);
   1816     }
   1817     model_->MoveCursorTo(gfx::SelectionModel(range, affinity));
   1818     UpdateAfterChange(true, true);
   1819     OnAfterUserAction();
   1820   }
   1821 }
   1822 
   1823 }  // namespace views
   1824