Textfield: Move selection logic from GetCommandForKeyEvent to ExecuteCommand.

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 <utility>
 
 #include "base/trace_event/trace_event.h"
@@ skipping 65 matching lines @@
   switch (ui::ScopedAnimationDurationScaleMode::duration_scale_mode()) {
       case ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION: return 100;
       case ui::ScopedAnimationDurationScaleMode::FAST_DURATION:   return 25;
       case ui::ScopedAnimationDurationScaleMode::SLOW_DURATION:   return 400;
       case ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION:   return 1;
       case ui::ScopedAnimationDurationScaleMode::ZERO_DURATION:   return 0;
     }
   return 100;
 }
 
-// Get the default command for a given key |event| and selection state.
-int GetCommandForKeyEvent(const ui::KeyEvent& event, bool has_selection) {
+// Get the default command for a given key |event|.
+int GetCommandForKeyEvent(const ui::KeyEvent& event) {
   if (event.type() != ui::ET_KEY_PRESSED || event.IsUnicodeKeyCode())
     return kNoCommand;
 
   const bool shift = event.IsShiftDown();
   const bool control = event.IsControlDown();
   const bool alt = event.IsAltDown() || event.IsAltGrDown();
   switch (event.key_code()) {
     case ui::VKEY_Z:
       if (control && !shift && !alt)
         return IDS_APP_UNDO;
@@ skipping 24 matching lines @@
         return control ? IDS_MOVE_WORD_LEFT : IDS_MOVE_LEFT;
       return control ? IDS_MOVE_WORD_LEFT_AND_MODIFY_SELECTION :
                         IDS_MOVE_LEFT_AND_MODIFY_SELECTION;
     case ui::VKEY_HOME:
       return shift ? IDS_MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION :
                       IDS_MOVE_TO_BEGINNING_OF_LINE;
     case ui::VKEY_END:
       return shift ? IDS_MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION :
                       IDS_MOVE_TO_END_OF_LINE;
     case ui::VKEY_BACK:
-      if (!control || has_selection)
+      if (!control)
         return IDS_DELETE_BACKWARD;
 #if defined(OS_LINUX)
       // Only erase by line break on Linux and ChromeOS.
       if (shift)
         return IDS_DELETE_TO_BEGINNING_OF_LINE;
 #endif
       return IDS_DELETE_WORD_BACKWARD;
     case ui::VKEY_DELETE:
-      if (!control || has_selection)
-        return (shift && has_selection) ? IDS_APP_CUT : IDS_DELETE_FORWARD;
 #if defined(OS_LINUX)
       // Only erase by line break on Linux and ChromeOS.
-      if (shift)
+      if (shift && control)
         return IDS_DELETE_TO_END_OF_LINE;
 #endif
-      return IDS_DELETE_WORD_FORWARD;
+      if (control)
+        return IDS_DELETE_WORD_FORWARD;
+      return shift ? IDS_APP_CUT : IDS_DELETE_FORWARD;
     case ui::VKEY_INSERT:
       if (control && !shift)
         return IDS_APP_COPY;
       return (shift && !control) ? IDS_APP_PASTE : kNoCommand;
     default:
       return kNoCommand;
   }
 }
 
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
@@ skipping 564 matching lines @@
       if (IsCommandIdEnabled(command)) {
         ExecuteCommand(command);
         handled = true;
       }
     }
     return handled;
   }
 #endif
 
   if (edit_command == kNoCommand)
-    edit_command = GetCommandForKeyEvent(event, HasSelection());
+    edit_command = GetCommandForKeyEvent(event);
 
   if (!handled && IsCommandIdEnabled(edit_command)) {
     ExecuteCommand(edit_command);
     handled = true;
   }
   return handled;
 }
 
 void Textfield::OnGestureEvent(ui::GestureEvent* event) {
   switch (event->type()) {
@@ skipping 83 matching lines @@
       break;
     default:
       return;
   }
 }
 
 // This function is called by BrowserView to execute clipboard commands.
 bool Textfield::AcceleratorPressed(const ui::Accelerator& accelerator) {
   ui::KeyEvent event(accelerator.type(), accelerator.key_code(),
                      accelerator.modifiers());
-  ExecuteCommand(GetCommandForKeyEvent(event, HasSelection()));
+  ExecuteCommand(GetCommandForKeyEvent(event));
   return true;
 }
 
 bool Textfield::CanHandleAccelerators() const {
   return GetRenderText()->focused() && View::CanHandleAccelerators();
 }
 
 void Textfield::AboutToRequestFocusFromTabTraversal(bool reverse) {
   SelectAll(false);
 }
@@ skipping 448 matching lines @@
       *accelerator = ui::Accelerator(ui::VKEY_A, ui::EF_CONTROL_DOWN);
       return true;
 
     default:
       return false;
   }
 }
 
 void Textfield::ExecuteCommand(int command_id, int event_flags) {
   DestroyTouchSelection();
+
+  // Some codepaths may bypass GetCommandForKeyEvent, so any selection-dependent
+  // modifications of the command should happen here.
+  if (HasSelection()) {
+    switch (command_id) {
+      case IDS_DELETE_WORD_BACKWARD:
+      case IDS_DELETE_TO_BEGINNING_OF_LINE:
+        command_id = IDS_DELETE_BACKWARD;
+        break;
+      case IDS_DELETE_WORD_FORWARD:
+      case IDS_DELETE_TO_END_OF_LINE:
+        command_id = IDS_DELETE_FORWARD;
+        break;
+    }
+  }
+
   if (!IsCommandIdEnabled(command_id))
     return;
 
   bool text_changed = false;
   bool cursor_changed = false;
   bool rtl = GetTextDirection() == base::i18n::RIGHT_TO_LEFT;
   gfx::VisualCursorDirection begin = rtl ? gfx::CURSOR_RIGHT : gfx::CURSOR_LEFT;
   gfx::VisualCursorDirection end = rtl ? gfx::CURSOR_LEFT : gfx::CURSOR_RIGHT;
   gfx::SelectionModel selection_model = GetSelectionModel();
 
@@ skipping 597 matching lines @@
     RequestFocus();
   model_->MoveCursorTo(mouse);
   if (!selection_clipboard_text.empty()) {
     model_->InsertText(selection_clipboard_text);
     UpdateAfterChange(true, true);
   }
   OnAfterUserAction();
 }
 
 }  // namespace views