Views: Replace resource ids with ui::TextEditCommand enum for text editing commands in Textfield.

ui/views/cocoa/bridged_content_view.mm

 // Copyright 2014 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.
 
 #import "ui/views/cocoa/bridged_content_view.h"
 
 #include "base/logging.h"
 #import "base/mac/mac_util.h"
 #import "base/mac/scoped_nsobject.h"
 #include "base/strings/sys_string_conversions.h"
 #include "skia/ext/skia_utils_mac.h"
 #include "ui/base/cocoa/cocoa_base_utils.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/compositor/canvas_painter.h"
 #import "ui/events/cocoa/cocoa_event_utils.h"
 #include "ui/events/keycodes/dom/dom_code.h"
 #import "ui/events/keycodes/keyboard_code_conversion_mac.h"
 #include "ui/gfx/canvas_paint_mac.h"
 #include "ui/gfx/geometry/rect.h"
 #import "ui/gfx/mac/coordinate_conversion.h"
 #include "ui/gfx/path.h"
 #import "ui/gfx/path_mac.h"
 #include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
-#include "ui/strings/grit/ui_strings.h"
 #include "ui/views/controls/menu/menu_config.h"
 #include "ui/views/controls/menu/menu_controller.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 using views::MenuController;
 
 namespace {
 
 NSString* const kFullKeyboardAccessChangedNotification =
@@ skipping 162 matching lines @@
 }
 
 }  // namespace
 
 @interface BridgedContentView ()
 
 // Translates keycodes and modifiers on |theEvent| to ui::KeyEvents and passes
 // the event to the InputMethod for dispatch.
 - (void)handleKeyEvent:(NSEvent*)theEvent;
 
-// Handles an NSResponder Action Message by mapping it to a corresponding text
-// editing command from ui_strings.grd and, when not being sent to a
-// TextInputClient, the keyCode that toolkit-views expects internally.
+// Handles an NSResponder Action Message by mapping it to a corresponding
+// ui::TextEditCommand and, when not being sent to a TextInputClient, the
+// keyCode that toolkit-views expects internally.
 // For example, moveToLeftEndOfLine: would pass ui::VKEY_HOME in non-RTL locales
 // even though the Home key on Mac defaults to moveToBeginningOfDocument:.
 // This approach also allows action messages a user
 // may have remapped in ~/Library/KeyBindings/DefaultKeyBinding.dict to be
 // catered for.
 // Note: default key bindings in Mac can be read from StandardKeyBinding.dict
 // which lives in /System/Library/Frameworks/AppKit.framework/Resources. Do
 // `plutil -convert xml1 -o StandardKeyBinding.xml StandardKeyBinding.dict` to
 // get something readable.
-- (void)handleAction:(int)commandId
+- (void)handleAction:(ui::TextEditCommand)command
              keyCode:(ui::KeyboardCode)keyCode
              domCode:(ui::DomCode)domCode
           eventFlags:(int)eventFlags;
 
 // Notification handler invoked when the Full Keyboard Access mode is changed.
 - (void)onFullKeyboardAccessModeChanged:(NSNotification*)notification;
 
 // Menu action handlers.
 - (void)undo:(id)sender;
 - (void)redo:(id)sender;
@@ skipping 131 matching lines @@
     return;
 
   DCHECK(theEvent);
   ui::KeyEvent event(theEvent);
   if (DispatchEventToMenu(hostedView_->GetWidget(), event.key_code()))
     return;
 
   hostedView_->GetWidget()->GetInputMethod()->DispatchKeyEvent(&event);
 }
 
-- (void)handleAction:(int)commandId
+- (void)handleAction:(ui::TextEditCommand)command
              keyCode:(ui::KeyboardCode)keyCode
              domCode:(ui::DomCode)domCode
           eventFlags:(int)eventFlags {
   if (!hostedView_)
     return;
 
   if (DispatchEventToMenu(hostedView_->GetWidget(), keyCode))
     return;
 
   // If there's an active TextInputClient, schedule the editing command to be
   // performed.
-  if (commandId && textInputClient_ &&
-      textInputClient_->IsEditCommandEnabled(commandId))
-    textInputClient_->SetEditCommandForNextKeyEvent(commandId);
+  if (textInputClient_ && textInputClient_->IsEditCommandEnabled(command))
+    textInputClient_->SetEditCommandForNextKeyEvent(command);
 
   // Generate a synthetic event with the keycode toolkit-views expects.
   ui::KeyEvent event(ui::ET_KEY_PRESSED, keyCode, domCode, eventFlags);
   hostedView_->GetWidget()->GetInputMethod()->DispatchKeyEvent(&event);
 }
 
 - (void)onFullKeyboardAccessModeChanged:(NSNotification*)notification {
   DCHECK([[notification name]
       isEqualToString:kFullKeyboardAccessChangedNotification]);
   [self updateFullKeyboardAccess];
 }
 
 - (void)undo:(id)sender {
   // This DCHECK is more strict than a similar check in handleAction:. It can be
   // done here because the actors sending these actions should be calling
   // validateUserInterfaceItem: before enabling UI that allows these messages to
   // be sent. Checking it here would be too late to provide correct UI feedback
   // (e.g. there will be no "beep").
-  DCHECK(textInputClient_->IsEditCommandEnabled(IDS_APP_UNDO));
-  [self handleAction:IDS_APP_UNDO
+  DCHECK(textInputClient_->IsEditCommandEnabled(ui::TextEditCommand::UNDO));
+  [self handleAction:ui::TextEditCommand::UNDO
              keyCode:ui::VKEY_Z
              domCode:ui::DomCode::US_Z
           eventFlags:ui::EF_CONTROL_DOWN];
 }
 
 - (void)redo:(id)sender {
-  DCHECK(textInputClient_->IsEditCommandEnabled(IDS_APP_REDO));
-  [self handleAction:IDS_APP_REDO
+  DCHECK(textInputClient_->IsEditCommandEnabled(ui::TextEditCommand::REDO));
+  [self handleAction:ui::TextEditCommand::REDO
              keyCode:ui::VKEY_Z
              domCode:ui::DomCode::US_Z
           eventFlags:ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN];
 }
 
 - (void)cut:(id)sender {
-  DCHECK(textInputClient_->IsEditCommandEnabled(IDS_APP_CUT));
-  [self handleAction:IDS_APP_CUT
+  DCHECK(textInputClient_->IsEditCommandEnabled(ui::TextEditCommand::CUT));
+  [self handleAction:ui::TextEditCommand::CUT
              keyCode:ui::VKEY_X
              domCode:ui::DomCode::US_X
           eventFlags:ui::EF_CONTROL_DOWN];
 }
 
 - (void)copy:(id)sender {
-  DCHECK(textInputClient_->IsEditCommandEnabled(IDS_APP_COPY));
-  [self handleAction:IDS_APP_COPY
+  DCHECK(textInputClient_->IsEditCommandEnabled(ui::TextEditCommand::COPY));
+  [self handleAction:ui::TextEditCommand::COPY
              keyCode:ui::VKEY_C
              domCode:ui::DomCode::US_C
           eventFlags:ui::EF_CONTROL_DOWN];
 }
 
 - (void)paste:(id)sender {
-  DCHECK(textInputClient_->IsEditCommandEnabled(IDS_APP_PASTE));
-  [self handleAction:IDS_APP_PASTE
+  DCHECK(textInputClient_->IsEditCommandEnabled(ui::TextEditCommand::PASTE));
+  [self handleAction:ui::TextEditCommand::PASTE
              keyCode:ui::VKEY_V
              domCode:ui::DomCode::US_V
           eventFlags:ui::EF_CONTROL_DOWN];
 }
 
 - (void)selectAll:(id)sender {
-  DCHECK(textInputClient_->IsEditCommandEnabled(IDS_APP_SELECT_ALL));
-  [self handleAction:IDS_APP_SELECT_ALL
+  DCHECK(
+      textInputClient_->IsEditCommandEnabled(ui::TextEditCommand::SELECT_ALL));
+  [self handleAction:ui::TextEditCommand::SELECT_ALL
              keyCode:ui::VKEY_A
              domCode:ui::DomCode::US_A
           eventFlags:ui::EF_CONTROL_DOWN];
 }
 
 // BaseView implementation.
 
 // Don't use tracking areas from BaseView. BridgedContentView's tracks
 // NSTrackingCursorUpdate and Apple's documentation suggests it's incompatible.
 - (void)enableTracking {
@@ skipping 172 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NSResponder Action Messages. Keep sorted according NSResponder.h (from the
 // 10.9 SDK). The list should eventually be complete. Anything not defined will
 // beep when interpretKeyEvents: would otherwise call it.
 // TODO(tapted): Make this list complete, except for insert* methods which are
 // dispatched as regular key events in doCommandBySelector:.
 
 // views::Textfields are single-line only, map Paragraph and Document commands
-// to Line. Also, Up/Down commands correspond to beginning/end of line.
+// to Line. Also, some up/down commands are mapped to beginning/end of line
+// commands.
 
 // The insertText action message forwards to the TextInputClient unless a menu
 // is active. Note that NSResponder's interpretKeyEvents: implementation doesn't
 // direct insertText: through doCommandBySelector:, so this is still needed to
 // handle the case when inputContext: is nil. When inputContext: returns non-nil
 // text goes directly to insertText:replacementRange:.
 - (void)insertText:(id)text {
   [self insertText:text replacementRange:NSMakeRange(NSNotFound, 0)];
 }
 
 // Selection movement and scrolling.
 
 - (void)moveForward:(id)sender {
   IsTextRTL(textInputClient_) ? [self moveLeft:sender]
                               : [self moveRight:sender];
 }
 
 - (void)moveRight:(id)sender {
-  [self handleAction:IDS_MOVE_RIGHT
+  [self handleAction:ui::TextEditCommand::MOVE_RIGHT
              keyCode:ui::VKEY_RIGHT
              domCode:ui::DomCode::ARROW_RIGHT
           eventFlags:0];
 }
 
 - (void)moveBackward:(id)sender {
   IsTextRTL(textInputClient_) ? [self moveRight:sender]
                               : [self moveLeft:sender];
 }
 
 - (void)moveLeft:(id)sender {
-  [self handleAction:IDS_MOVE_LEFT
+  [self handleAction:ui::TextEditCommand::MOVE_LEFT
              keyCode:ui::VKEY_LEFT
              domCode:ui::DomCode::ARROW_LEFT
           eventFlags:0];
 }
 
 - (void)moveUp:(id)sender {
-  [self handleAction:IDS_MOVE_TO_BEGINNING_OF_LINE
+  [self handleAction:ui::TextEditCommand::MOVE_UP
              keyCode:ui::VKEY_UP
              domCode:ui::DomCode::ARROW_UP
           eventFlags:0];
 }
 
 - (void)moveDown:(id)sender {
-  [self handleAction:IDS_MOVE_TO_END_OF_LINE
+  [self handleAction:ui::TextEditCommand::MOVE_DOWN
              keyCode:ui::VKEY_DOWN
              domCode:ui::DomCode::ARROW_DOWN
           eventFlags:0];
 }
 
 - (void)moveWordForward:(id)sender {
   IsTextRTL(textInputClient_) ? [self moveWordLeft:sender]
                               : [self moveWordRight:sender];
 }
 
 - (void)moveWordBackward:(id)sender {
   IsTextRTL(textInputClient_) ? [self moveWordRight:sender]
                               : [self moveWordLeft:sender];
 }
 
 - (void)moveToBeginningOfLine:(id)sender {
-  [self handleAction:IDS_MOVE_TO_BEGINNING_OF_LINE
+  [self handleAction:ui::TextEditCommand::MOVE_TO_BEGINNING_OF_LINE
              keyCode:ui::VKEY_HOME
              domCode:ui::DomCode::HOME
           eventFlags:0];
 }
 
 - (void)moveToEndOfLine:(id)sender {
-  [self handleAction:IDS_MOVE_TO_END_OF_LINE
+  [self handleAction:ui::TextEditCommand::MOVE_TO_END_OF_LINE
              keyCode:ui::VKEY_END
              domCode:ui::DomCode::END
           eventFlags:0];
 }
 
 - (void)moveToBeginningOfParagraph:(id)sender {
   [self moveToBeginningOfLine:sender];
 }
 
 - (void)moveToEndOfParagraph:(id)sender {
   [self moveToEndOfLine:sender];
 }
 
 - (void)moveToEndOfDocument:(id)sender {
-  [self handleAction:IDS_MOVE_TO_END_OF_LINE
+  [self handleAction:ui::TextEditCommand::MOVE_TO_END_OF_LINE
              keyCode:ui::VKEY_END
              domCode:ui::DomCode::END
           eventFlags:ui::EF_CONTROL_DOWN];
 }
 
 - (void)moveToBeginningOfDocument:(id)sender {
-  [self handleAction:IDS_MOVE_TO_BEGINNING_OF_LINE
+  [self handleAction:ui::TextEditCommand::MOVE_TO_BEGINNING_OF_LINE
              keyCode:ui::VKEY_HOME
              domCode:ui::DomCode::HOME
           eventFlags:ui::EF_CONTROL_DOWN];
 }
 
 - (void)pageDown:(id)sender {
-  [self handleAction:IDS_MOVE_TO_END_OF_LINE
+  [self handleAction:ui::TextEditCommand::MOVE_PAGE_DOWN
              keyCode:ui::VKEY_NEXT
              domCode:ui::DomCode::PAGE_DOWN
           eventFlags:0];
 }
 
 - (void)pageUp:(id)sender {
-  [self handleAction:IDS_MOVE_TO_BEGINNING_OF_LINE
+  [self handleAction:ui::TextEditCommand::MOVE_PAGE_UP
              keyCode:ui::VKEY_PRIOR
              domCode:ui::DomCode::PAGE_UP
           eventFlags:0];
 }
 
 - (void)moveBackwardAndModifySelection:(id)sender {
   IsTextRTL(textInputClient_) ? [self moveRightAndModifySelection:sender]
                               : [self moveLeftAndModifySelection:sender];
 }
 
 - (void)moveForwardAndModifySelection:(id)sender {
   IsTextRTL(textInputClient_) ? [self moveLeftAndModifySelection:sender]
                               : [self moveRightAndModifySelection:sender];
 }
 
 - (void)moveWordForwardAndModifySelection:(id)sender {
   IsTextRTL(textInputClient_) ? [self moveWordLeftAndModifySelection:sender]
                               : [self moveWordRightAndModifySelection:sender];
 }
 
 - (void)moveWordBackwardAndModifySelection:(id)sender {
   IsTextRTL(textInputClient_) ? [self moveWordRightAndModifySelection:sender]
                               : [self moveWordLeftAndModifySelection:sender];
 }
 
 - (void)moveUpAndModifySelection:(id)sender {
-  [self handleAction:IDS_MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION
+  [self handleAction:ui::TextEditCommand::
+                         MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION
              keyCode:ui::VKEY_UP
              domCode:ui::DomCode::ARROW_UP
           eventFlags:ui::EF_SHIFT_DOWN];
 }
 
 - (void)moveDownAndModifySelection:(id)sender {
-  [self handleAction:IDS_MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION
-             keyCode:ui::VKEY_DOWN
-             domCode:ui::DomCode::ARROW_DOWN
-          eventFlags:ui::EF_SHIFT_DOWN];
+  [self
+      handleAction:ui::TextEditCommand::MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION
+           keyCode:ui::VKEY_DOWN
+           domCode:ui::DomCode::ARROW_DOWN
+        eventFlags:ui::EF_SHIFT_DOWN];
 }
 
 - (void)moveToBeginningOfLineAndModifySelection:(id)sender {
-  [self handleAction:IDS_MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION
+  [self handleAction:ui::TextEditCommand::
+                         MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION
              keyCode:ui::VKEY_HOME
              domCode:ui::DomCode::HOME
           eventFlags:ui::EF_SHIFT_DOWN];
 }
 
 - (void)moveToEndOfLineAndModifySelection:(id)sender {
-  [self handleAction:IDS_MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION
-             keyCode:ui::VKEY_END
-             domCode:ui::DomCode::END
-          eventFlags:ui::EF_SHIFT_DOWN];
+  [self
+      handleAction:ui::TextEditCommand::MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION
+           keyCode:ui::VKEY_END
+           domCode:ui::DomCode::END
+        eventFlags:ui::EF_SHIFT_DOWN];
 }
 
 - (void)moveToBeginningOfParagraphAndModifySelection:(id)sender {
   [self moveToBeginningOfLineAndModifySelection:sender];
 }
 
 - (void)moveToEndOfParagraphAndModifySelection:(id)sender {
   [self moveToEndOfLineAndModifySelection:sender];
 }
 
 - (void)moveToEndOfDocumentAndModifySelection:(id)sender {
-  [self handleAction:IDS_MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION
-             keyCode:ui::VKEY_END
-             domCode:ui::DomCode::END
-          eventFlags:ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN];
+  [self
+      handleAction:ui::TextEditCommand::MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION
+           keyCode:ui::VKEY_END
+           domCode:ui::DomCode::END
+        eventFlags:ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN];
 }
 
 - (void)moveToBeginningOfDocumentAndModifySelection:(id)sender {
-  [self handleAction:IDS_MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION
+  [self handleAction:ui::TextEditCommand::
+                         MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION
              keyCode:ui::VKEY_HOME
              domCode:ui::DomCode::HOME
           eventFlags:ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN];
 }
 
 - (void)pageDownAndModifySelection:(id)sender {
-  [self handleAction:IDS_MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION
-             keyCode:ui::VKEY_NEXT
-             domCode:ui::DomCode::PAGE_DOWN
-          eventFlags:ui::EF_SHIFT_DOWN];
+  [self
+      handleAction:ui::TextEditCommand::MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION
+           keyCode:ui::VKEY_NEXT
+           domCode:ui::DomCode::PAGE_DOWN
+        eventFlags:ui::EF_SHIFT_DOWN];
 }
 
 - (void)pageUpAndModifySelection:(id)sender {
-  [self handleAction:IDS_MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION
+  [self handleAction:ui::TextEditCommand::
+                         MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION
              keyCode:ui::VKEY_PRIOR
              domCode:ui::DomCode::PAGE_UP
           eventFlags:ui::EF_SHIFT_DOWN];
 }
 
 - (void)moveParagraphForwardAndModifySelection:(id)sender {
-  [self handleAction:IDS_MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION
-             keyCode:ui::VKEY_DOWN
-             domCode:ui::DomCode::ARROW_DOWN
-          eventFlags:ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN];
+  [self
+      handleAction:ui::TextEditCommand::MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION
+           keyCode:ui::VKEY_DOWN
+           domCode:ui::DomCode::ARROW_DOWN
+        eventFlags:ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN];
 }
 
 - (void)moveParagraphBackwardAndModifySelection:(id)sender {
-  [self handleAction:IDS_MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION
+  [self handleAction:ui::TextEditCommand::
+                         MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION
              keyCode:ui::VKEY_UP
              domCode:ui::DomCode::ARROW_UP
           eventFlags:ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN];
 }
 
 - (void)moveWordRight:(id)sender {
-  [self handleAction:IDS_MOVE_WORD_RIGHT
+  [self handleAction:ui::TextEditCommand::MOVE_WORD_RIGHT
              keyCode:ui::VKEY_RIGHT
              domCode:ui::DomCode::ARROW_RIGHT
           eventFlags:ui::EF_CONTROL_DOWN];
 }
 
 - (void)moveWordLeft:(id)sender {
-  [self handleAction:IDS_MOVE_WORD_LEFT
+  [self handleAction:ui::TextEditCommand::MOVE_WORD_LEFT
              keyCode:ui::VKEY_LEFT
              domCode:ui::DomCode::ARROW_LEFT
           eventFlags:ui::EF_CONTROL_DOWN];
 }
 
 - (void)moveRightAndModifySelection:(id)sender {
-  [self handleAction:IDS_MOVE_RIGHT_AND_MODIFY_SELECTION
+  [self handleAction:ui::TextEditCommand::MOVE_RIGHT_AND_MODIFY_SELECTION
              keyCode:ui::VKEY_RIGHT
              domCode:ui::DomCode::ARROW_RIGHT
           eventFlags:ui::EF_SHIFT_DOWN];
 }
 
 - (void)moveLeftAndModifySelection:(id)sender {
-  [self handleAction:IDS_MOVE_LEFT_AND_MODIFY_SELECTION
+  [self handleAction:ui::TextEditCommand::MOVE_LEFT_AND_MODIFY_SELECTION
              keyCode:ui::VKEY_LEFT
              domCode:ui::DomCode::ARROW_LEFT
           eventFlags:ui::EF_SHIFT_DOWN];
 }
 
 - (void)moveWordRightAndModifySelection:(id)sender {
-  [self handleAction:IDS_MOVE_WORD_RIGHT_AND_MODIFY_SELECTION
+  [self handleAction:ui::TextEditCommand::MOVE_WORD_RIGHT_AND_MODIFY_SELECTION
              keyCode:ui::VKEY_RIGHT
              domCode:ui::DomCode::ARROW_RIGHT
           eventFlags:ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN];
 }
 
 - (void)moveWordLeftAndModifySelection:(id)sender {
-  [self handleAction:IDS_MOVE_WORD_LEFT_AND_MODIFY_SELECTION
+  [self handleAction:ui::TextEditCommand::MOVE_WORD_LEFT_AND_MODIFY_SELECTION
              keyCode:ui::VKEY_LEFT
              domCode:ui::DomCode::ARROW_LEFT
           eventFlags:ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN];
 }
 
 - (void)moveToLeftEndOfLine:(id)sender {
   IsTextRTL(textInputClient_) ? [self moveToEndOfLine:sender]
                               : [self moveToBeginningOfLine:sender];
 }
 
@@ skipping 10 matching lines @@
 
 - (void)moveToRightEndOfLineAndModifySelection:(id)sender {
   IsTextRTL(textInputClient_)
       ? [self moveToBeginningOfLineAndModifySelection:sender]
       : [self moveToEndOfLineAndModifySelection:sender];
 }
 
 // Deletions.
 
 - (void)deleteForward:(id)sender {
-  [self handleAction:IDS_DELETE_FORWARD
+  [self handleAction:ui::TextEditCommand::DELETE_FORWARD
              keyCode:ui::VKEY_DELETE
              domCode:ui::DomCode::DEL
           eventFlags:0];
 }
 
 - (void)deleteBackward:(id)sender {
-  [self handleAction:IDS_DELETE_BACKWARD
+  [self handleAction:ui::TextEditCommand::DELETE_BACKWARD
              keyCode:ui::VKEY_BACK
              domCode:ui::DomCode::BACKSPACE
           eventFlags:0];
 }
 
 - (void)deleteWordForward:(id)sender {
-  [self handleAction:IDS_DELETE_WORD_FORWARD
+  [self handleAction:ui::TextEditCommand::DELETE_WORD_FORWARD
              keyCode:ui::VKEY_DELETE
              domCode:ui::DomCode::DEL
           eventFlags:ui::EF_CONTROL_DOWN];
 }
 
 - (void)deleteWordBackward:(id)sender {
-  [self handleAction:IDS_DELETE_WORD_BACKWARD
+  [self handleAction:ui::TextEditCommand::DELETE_WORD_BACKWARD
              keyCode:ui::VKEY_BACK
              domCode:ui::DomCode::BACKSPACE
           eventFlags:ui::EF_CONTROL_DOWN];
 }
 
 - (void)deleteToBeginningOfLine:(id)sender {
-  [self handleAction:IDS_DELETE_TO_BEGINNING_OF_LINE
+  [self handleAction:ui::TextEditCommand::DELETE_TO_BEGINNING_OF_LINE
              keyCode:ui::VKEY_BACK
              domCode:ui::DomCode::BACKSPACE
           eventFlags:ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN];
 }
 
 - (void)deleteToEndOfLine:(id)sender {
-  [self handleAction:IDS_DELETE_TO_END_OF_LINE
+  [self handleAction:ui::TextEditCommand::DELETE_TO_END_OF_LINE
              keyCode:ui::VKEY_DELETE
              domCode:ui::DomCode::DEL
           eventFlags:ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN];
 }
 
 - (void)deleteToBeginningOfParagraph:(id)sender {
   [self deleteToBeginningOfLine:sender];
 }
 
 - (void)deleteToEndOfParagraph:(id)sender {
   [self deleteToEndOfLine:sender];
 }
 
 // Cancellation.
 
 - (void)cancelOperation:(id)sender {
-  [self handleAction:0
+  [self handleAction:ui::TextEditCommand::INVALID_COMMAND
              keyCode:ui::VKEY_ESCAPE
              domCode:ui::DomCode::ESCAPE
           eventFlags:0];
 }
 
 // Support for Services in context menus.
 // Currently we only support reading and writing plain strings.
 - (id)validRequestorForSendType:(NSString*)sendType
                      returnType:(NSString*)returnType {
   BOOL canWrite = [sendType isEqualToString:NSStringPboardType] &&
@@ skipping 177 matching lines @@
 
 // NSUserInterfaceValidations protocol implementation.
 
 - (BOOL)validateUserInterfaceItem:(id<NSValidatedUserInterfaceItem>)item {
   if (!textInputClient_)
     return NO;
 
   SEL action = [item action];
 
   if (action == @selector(undo:))
-    return textInputClient_->IsEditCommandEnabled(IDS_APP_UNDO);
+    return textInputClient_->IsEditCommandEnabled(ui::TextEditCommand::UNDO);
   if (action == @selector(redo:))
-    return textInputClient_->IsEditCommandEnabled(IDS_APP_REDO);
+    return textInputClient_->IsEditCommandEnabled(ui::TextEditCommand::REDO);
   if (action == @selector(cut:))
-    return textInputClient_->IsEditCommandEnabled(IDS_APP_CUT);
+    return textInputClient_->IsEditCommandEnabled(ui::TextEditCommand::CUT);
   if (action == @selector(copy:))
-    return textInputClient_->IsEditCommandEnabled(IDS_APP_COPY);
+    return textInputClient_->IsEditCommandEnabled(ui::TextEditCommand::COPY);
   if (action == @selector(paste:))
-    return textInputClient_->IsEditCommandEnabled(IDS_APP_PASTE);
+    return textInputClient_->IsEditCommandEnabled(ui::TextEditCommand::PASTE);
   if (action == @selector(selectAll:))
-    return textInputClient_->IsEditCommandEnabled(IDS_APP_SELECT_ALL);
+    return textInputClient_->IsEditCommandEnabled(
+        ui::TextEditCommand::SELECT_ALL);
 
   return NO;
 }
 
 // NSAccessibility informal protocol implementation.
 
 - (id)accessibilityAttributeValue:(NSString*)attribute {
   if ([attribute isEqualToString:NSAccessibilityChildrenAttribute]) {
     return @[ hostedView_->GetNativeViewAccessible() ];
   }
 
   return [super accessibilityAttributeValue:attribute];
 }
 
 - (id)accessibilityHitTest:(NSPoint)point {
   return [hostedView_->GetNativeViewAccessible() accessibilityHitTest:point];
 }
 
 @end