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

chrome/browser/ui/libgtk2ui/gtk2_key_bindings_handler.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 "chrome/browser/ui/libgtk2ui/gtk2_key_bindings_handler.h"
 
 #include <gdk/gdkkeysyms.h>
 #include <X11/Xlib.h>
 #include <stddef.h>
 #include <X11/XKBlib.h>
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/ui/libgtk2ui/gtk2_util.h"
 #include "content/public/browser/native_web_keyboard_event.h"
+#include "ui/base/ime/text_edit_commands.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/events/event.h"
 
-using ui::TextEditCommandAuraLinux;
+using ui::TextEditCommand;
 
 // TODO(erg): Rewrite the old gtk_key_bindings_handler_unittest.cc and get them
 // in a state that links. This code was adapted from the content layer GTK
 // code, which had some simple unit tests. However, the changes in the public
 // interface basically meant the tests need to be rewritten; this imposes weird
 // linking requirements regarding GTK+ as we don't have a libgtk2ui_unittests
 // yet. http://crbug.com/358297.
 
 namespace libgtk2ui {
 
@@ skipping 10 matching lines @@
                                &major, &minor);
 }
 
 Gtk2KeyBindingsHandler::~Gtk2KeyBindingsHandler() {
   gtk_widget_destroy(handler_);
   gtk_widget_destroy(fake_window_);
 }
 
 bool Gtk2KeyBindingsHandler::MatchEvent(
     const ui::Event& event,
-    std::vector<TextEditCommandAuraLinux>* edit_commands) {
+    std::vector<ui::TextEditCommandAuraLinux>* edit_commands) {
   CHECK(event.IsKeyEvent());
 
   const ui::KeyEvent& key_event = static_cast<const ui::KeyEvent&>(event);
   if (key_event.is_char() || !key_event.native_event())
     return false;
 
   GdkEventKey gdk_event;
   BuildGdkEventKeyFromXEvent(key_event.native_event(), &gdk_event);
 
   edit_commands_.clear();
@@ skipping 25 matching lines @@
   gtk_widget_set_size_request(GTK_WIDGET(handler), 0, 0);
 
   // Prevents it from handling any events by itself.
   gtk_widget_set_sensitive(GTK_WIDGET(handler), FALSE);
   gtk_widget_set_events(GTK_WIDGET(handler), 0);
   gtk_widget_set_can_focus(GTK_WIDGET(handler), TRUE);
 
   return GTK_WIDGET(handler);
 }
 
-void Gtk2KeyBindingsHandler::EditCommandMatched(
-    TextEditCommandAuraLinux::CommandId id,
-    const std::string& value,
-    bool extend_selection) {
-  edit_commands_.push_back(TextEditCommandAuraLinux(id,
-                                                    value,
-                                                    extend_selection));
+void Gtk2KeyBindingsHandler::EditCommandMatched(TextEditCommand command,
+                                                const std::string& value) {
+  edit_commands_.push_back(ui::TextEditCommandAuraLinux(command, value));
 }
 
 void Gtk2KeyBindingsHandler::BuildGdkEventKeyFromXEvent(
     const base::NativeEvent& xevent,
     GdkEventKey* gdk_event) {
   GdkKeymap *keymap = gdk_keymap_get_for_display(gdk_display_get_default());
   GdkModifierType consumed, state;
 
   gdk_event->type = xevent->xany.type == KeyPress ?
                     GDK_KEY_PRESS : GDK_KEY_RELEASE;
@@ skipping 89 matching lines @@
 
 Gtk2KeyBindingsHandler* Gtk2KeyBindingsHandler::GetHandlerOwner(
     GtkTextView* text_view) {
   Handler* handler = G_TYPE_CHECK_INSTANCE_CAST(
       text_view, HandlerGetType(), Handler);
   DCHECK(handler);
   return handler->owner;
 }
 
 void Gtk2KeyBindingsHandler::BackSpace(GtkTextView* text_view) {
-  GetHandlerOwner(text_view)
-      ->EditCommandMatched(
-          TextEditCommandAuraLinux::DELETE_BACKWARD, std::string(), false);
+  GetHandlerOwner(text_view)->EditCommandMatched(
+      TextEditCommand::DELETE_BACKWARD, std::string());
 }
 
 void Gtk2KeyBindingsHandler::CopyClipboard(GtkTextView* text_view) {
-  GetHandlerOwner(text_view)->EditCommandMatched(
-      TextEditCommandAuraLinux::COPY, std::string(), false);
+  GetHandlerOwner(text_view)->EditCommandMatched(TextEditCommand::COPY,
+                                                 std::string());
 }
 
 void Gtk2KeyBindingsHandler::CutClipboard(GtkTextView* text_view) {
-  GetHandlerOwner(text_view)->EditCommandMatched(
-      TextEditCommandAuraLinux::CUT, std::string(), false);
+  GetHandlerOwner(text_view)->EditCommandMatched(TextEditCommand::CUT,
+                                                 std::string());
 }
 
 void Gtk2KeyBindingsHandler::DeleteFromCursor(
     GtkTextView* text_view, GtkDeleteType type, gint count) {
   if (!count)
     return;
 
-  TextEditCommandAuraLinux::CommandId commands[2] = {
-    TextEditCommandAuraLinux::INVALID_COMMAND,
-    TextEditCommandAuraLinux::INVALID_COMMAND,
+  TextEditCommand commands[2] = {
+      TextEditCommand::INVALID_COMMAND, TextEditCommand::INVALID_COMMAND,
   };
   switch (type) {
     case GTK_DELETE_CHARS:
-      commands[0] = (count > 0 ?
-          TextEditCommandAuraLinux::DELETE_FORWARD :
-          TextEditCommandAuraLinux::DELETE_BACKWARD);
+      commands[0] = (count > 0 ? TextEditCommand::DELETE_FORWARD
+                               : TextEditCommand::DELETE_BACKWARD);
       break;
     case GTK_DELETE_WORD_ENDS:
-      commands[0] = (count > 0 ?
-          TextEditCommandAuraLinux::DELETE_WORD_FORWARD :
-          TextEditCommandAuraLinux::DELETE_WORD_BACKWARD);
+      commands[0] = (count > 0 ? TextEditCommand::DELETE_WORD_FORWARD
+                               : TextEditCommand::DELETE_WORD_BACKWARD);
       break;
     case GTK_DELETE_WORDS:
       if (count > 0) {
-        commands[0] = TextEditCommandAuraLinux::MOVE_WORD_FORWARD;
-        commands[1] = TextEditCommandAuraLinux::DELETE_WORD_BACKWARD;
+        commands[0] = TextEditCommand::MOVE_WORD_FORWARD;
+        commands[1] = TextEditCommand::DELETE_WORD_BACKWARD;
       } else {
-        commands[0] = TextEditCommandAuraLinux::MOVE_WORD_BACKWARD;
-        commands[1] = TextEditCommandAuraLinux::DELETE_WORD_FORWARD;
+        commands[0] = TextEditCommand::MOVE_WORD_BACKWARD;
+        commands[1] = TextEditCommand::DELETE_WORD_FORWARD;
       }
       break;
     case GTK_DELETE_DISPLAY_LINES:
-      commands[0] = TextEditCommandAuraLinux::MOVE_TO_BEGINING_OF_LINE;
-      commands[1] = TextEditCommandAuraLinux::DELETE_TO_END_OF_LINE;
+      commands[0] = TextEditCommand::MOVE_TO_BEGINNING_OF_LINE;
+      commands[1] = TextEditCommand::DELETE_TO_END_OF_LINE;
       break;
     case GTK_DELETE_DISPLAY_LINE_ENDS:
-      commands[0] = (count > 0 ?
-          TextEditCommandAuraLinux::DELETE_TO_END_OF_LINE :
-          TextEditCommandAuraLinux::DELETE_TO_BEGINING_OF_LINE);
+      commands[0] = (count > 0 ? TextEditCommand::DELETE_TO_END_OF_LINE
+                               : TextEditCommand::DELETE_TO_BEGINNING_OF_LINE);
       break;
     case GTK_DELETE_PARAGRAPH_ENDS:
-      commands[0] = (count > 0 ?
-          TextEditCommandAuraLinux::DELETE_TO_END_OF_PARAGRAPH :
-          TextEditCommandAuraLinux::DELETE_TO_BEGINING_OF_PARAGRAPH);
+      commands[0] =
+          (count > 0 ? TextEditCommand::DELETE_TO_END_OF_PARAGRAPH
+                     : TextEditCommand::DELETE_TO_BEGINNING_OF_PARAGRAPH);
       break;
     case GTK_DELETE_PARAGRAPHS:
-      commands[0] =
-          TextEditCommandAuraLinux::MOVE_TO_BEGINING_OF_PARAGRAPH;
-      commands[1] =
-          TextEditCommandAuraLinux::DELETE_TO_END_OF_PARAGRAPH;
+      commands[0] = TextEditCommand::MOVE_TO_BEGINNING_OF_PARAGRAPH;
+      commands[1] = TextEditCommand::DELETE_TO_END_OF_PARAGRAPH;
       break;
     default:
       // GTK_DELETE_WHITESPACE has no corresponding editor command.
       return;
   }
 
   Gtk2KeyBindingsHandler* owner = GetHandlerOwner(text_view);
   if (count < 0)
     count = -count;
   for (; count > 0; --count) {
     for (size_t i = 0; i < arraysize(commands); ++i)
-      if (commands[i] != TextEditCommandAuraLinux::INVALID_COMMAND)
-        owner->EditCommandMatched(commands[i], std::string(), false);
+      if (commands[i] != TextEditCommand::INVALID_COMMAND)
+        owner->EditCommandMatched(commands[i], std::string());
   }
 }
 
 void Gtk2KeyBindingsHandler::InsertAtCursor(GtkTextView* text_view,
                                             const gchar* str) {
-  if (str && *str)
-    GetHandlerOwner(text_view)->EditCommandMatched(
-        TextEditCommandAuraLinux::INSERT_TEXT, str, false);
+  if (str && *str) {
+    GetHandlerOwner(text_view)->EditCommandMatched(TextEditCommand::INSERT_TEXT,
+                                                   str);
+  }
 }
 
 void Gtk2KeyBindingsHandler::MoveCursor(
     GtkTextView* text_view, GtkMovementStep step, gint count,
     gboolean extend_selection) {
   if (!count)
     return;
 
-  TextEditCommandAuraLinux::CommandId command;
+  TextEditCommand command;
   switch (step) {
     case GTK_MOVEMENT_LOGICAL_POSITIONS:
-      command = (count > 0 ?
-                 TextEditCommandAuraLinux::MOVE_FORWARD :
-                 TextEditCommandAuraLinux::MOVE_BACKWARD);
+      if (extend_selection) {
+        command =
+            (count > 0 ? TextEditCommand::MOVE_FORWARD_AND_MODIFY_SELECTION
+                       : TextEditCommand::MOVE_BACKWARD_AND_MODIFY_SELECTION);
+      } else {
+        command = (count > 0 ? TextEditCommand::MOVE_FORWARD
+                             : TextEditCommand::MOVE_BACKWARD);
+      }
       break;
     case GTK_MOVEMENT_VISUAL_POSITIONS:
-      command = (count > 0 ?
-                 TextEditCommandAuraLinux::MOVE_RIGHT :
-                 TextEditCommandAuraLinux::MOVE_LEFT);
+      if (extend_selection) {
+        command = (count > 0 ? TextEditCommand::MOVE_RIGHT_AND_MODIFY_SELECTION
+                             : TextEditCommand::MOVE_LEFT_AND_MODIFY_SELECTION);
+      } else {
+        command = (count > 0 ? TextEditCommand::MOVE_RIGHT
+                             : TextEditCommand::MOVE_LEFT);
+      }
       break;
     case GTK_MOVEMENT_WORDS:
-      command = (count > 0 ?
-                 TextEditCommandAuraLinux::MOVE_WORD_RIGHT :
-                 TextEditCommandAuraLinux::MOVE_WORD_LEFT);
+      if (extend_selection) {
+        command =
+            (count > 0 ? TextEditCommand::MOVE_WORD_RIGHT_AND_MODIFY_SELECTION
+                       : TextEditCommand::MOVE_WORD_LEFT_AND_MODIFY_SELECTION);
+      } else {
+        command = (count > 0 ? TextEditCommand::MOVE_WORD_RIGHT
+                             : TextEditCommand::MOVE_WORD_LEFT);
+      }
       break;
     case GTK_MOVEMENT_DISPLAY_LINES:
-      command = (count > 0 ?
-                 TextEditCommandAuraLinux::MOVE_DOWN :
-                 TextEditCommandAuraLinux::MOVE_UP);
+      if (extend_selection) {
+        command = (count > 0 ? TextEditCommand::MOVE_DOWN_AND_MODIFY_SELECTION
+                             : TextEditCommand::MOVE_UP_AND_MODIFY_SELECTION);
+      } else {
+        command =
+            (count > 0 ? TextEditCommand::MOVE_DOWN : TextEditCommand::MOVE_UP);
+      }
       break;
     case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
-      command = (count > 0 ?
-                 TextEditCommandAuraLinux::MOVE_TO_END_OF_LINE :
-                 TextEditCommandAuraLinux::MOVE_TO_BEGINING_OF_LINE);
+      if (extend_selection) {
+        command =
+            (count > 0
+                 ? TextEditCommand::MOVE_TO_END_OF_LINE_AND_MODIFY_SELECTION
+                 : TextEditCommand::
+                       MOVE_TO_BEGINNING_OF_LINE_AND_MODIFY_SELECTION);
+      } else {
+        command = (count > 0 ? TextEditCommand::MOVE_TO_END_OF_LINE
+                             : TextEditCommand::MOVE_TO_BEGINNING_OF_LINE);
+      }
       break;
     case GTK_MOVEMENT_PARAGRAPH_ENDS:
-      command = (count > 0 ?
-                 TextEditCommandAuraLinux::MOVE_TO_END_OF_PARAGRAPH :
-                 TextEditCommandAuraLinux::MOVE_TO_BEGINING_OF_PARAGRAPH);
+      if (extend_selection) {
+        command =
+            (count > 0
+                 ? TextEditCommand::
+                       MOVE_TO_END_OF_PARAGRAPH_AND_MODIFY_SELECTION
+                 : TextEditCommand::
+                       MOVE_TO_BEGINNING_OF_PARAGRAPH_AND_MODIFY_SELECTION);
+      } else {
+        command = (count > 0 ? TextEditCommand::MOVE_TO_END_OF_PARAGRAPH
+                             : TextEditCommand::MOVE_TO_BEGINNING_OF_PARAGRAPH);
+      }
       break;
     case GTK_MOVEMENT_PAGES:
-      command = (count > 0 ? TextEditCommandAuraLinux::MOVE_PAGE_DOWN :
-                 TextEditCommandAuraLinux::MOVE_PAGE_UP);
+      if (extend_selection) {
+        command =
+            (count > 0 ? TextEditCommand::MOVE_PAGE_DOWN_AND_MODIFY_SELECTION
+                       : TextEditCommand::MOVE_PAGE_UP_AND_MODIFY_SELECTION);
+      } else {
+        command = (count > 0 ? TextEditCommand::MOVE_PAGE_DOWN
+                             : TextEditCommand::MOVE_PAGE_UP);
+      }
       break;
     case GTK_MOVEMENT_BUFFER_ENDS:
-      command = (count > 0 ? TextEditCommandAuraLinux::MOVE_TO_END_OF_DOCUMENT :
-                 TextEditCommandAuraLinux::MOVE_TO_BEGINING_OF_DOCUMENT);
+      if (extend_selection) {
+        command =
+            (count > 0
+                 ? TextEditCommand::MOVE_TO_END_OF_DOCUMENT_AND_MODIFY_SELECTION
+                 : TextEditCommand::
+                       MOVE_TO_BEGINNING_OF_DOCUMENT_AND_MODIFY_SELECTION);
+      } else {
+        command = (count > 0 ? TextEditCommand::MOVE_TO_END_OF_DOCUMENT
+                             : TextEditCommand::MOVE_TO_BEGINNING_OF_DOCUMENT);
+      }
       break;
     default:
       // GTK_MOVEMENT_PARAGRAPHS and GTK_MOVEMENT_HORIZONTAL_PAGES have
       // no corresponding editor commands.
       return;
   }
 
   Gtk2KeyBindingsHandler* owner = GetHandlerOwner(text_view);
   if (count < 0)
     count = -count;
   for (; count > 0; --count)
-    owner->EditCommandMatched(command, std::string(), extend_selection);
+    owner->EditCommandMatched(command, std::string());
 }
 
 void Gtk2KeyBindingsHandler::MoveViewport(
     GtkTextView* text_view, GtkScrollStep step, gint count) {
   // Not supported by webkit.
 }
 
 void Gtk2KeyBindingsHandler::PasteClipboard(GtkTextView* text_view) {
-  GetHandlerOwner(text_view)->EditCommandMatched(
-      TextEditCommandAuraLinux::PASTE, std::string(), false);
+  GetHandlerOwner(text_view)->EditCommandMatched(TextEditCommand::PASTE,
+                                                 std::string());
 }
 
 void Gtk2KeyBindingsHandler::SelectAll(GtkTextView* text_view,
                                        gboolean select) {
-  if (select) {
-    GetHandlerOwner(text_view)->EditCommandMatched(
-        TextEditCommandAuraLinux::SELECT_ALL, std::string(), false);
-  } else {
-    GetHandlerOwner(text_view)->EditCommandMatched(
-        TextEditCommandAuraLinux::UNSELECT, std::string(), false);
-  }
+  GetHandlerOwner(text_view)->EditCommandMatched(
+      select ? TextEditCommand::SELECT_ALL : TextEditCommand::UNSELECT,
+      std::string());
 }
 
 void Gtk2KeyBindingsHandler::SetAnchor(GtkTextView* text_view) {
-  GetHandlerOwner(text_view)->EditCommandMatched(
-      TextEditCommandAuraLinux::SET_MARK, std::string(), false);
+  GetHandlerOwner(text_view)->EditCommandMatched(TextEditCommand::SET_MARK,
+                                                 std::string());
 }
 
 void Gtk2KeyBindingsHandler::ToggleCursorVisible(GtkTextView* text_view) {
   // Not supported by webkit.
 }
 
 void Gtk2KeyBindingsHandler::ToggleOverwrite(GtkTextView* text_view) {
   // Not supported by webkit.
 }
 
 gboolean Gtk2KeyBindingsHandler::ShowHelp(GtkWidget* widget,
                                           GtkWidgetHelpType arg1) {
   // Just for disabling the default handler.
   return FALSE;
 }
 
 void Gtk2KeyBindingsHandler::MoveFocus(GtkWidget* widget,
                                        GtkDirectionType arg1) {
   // Just for disabling the default handler.
 }
 
 }  // namespace libgtk2ui