Gtk3 UI: Rename files in libgtkui containing gtk2 in their name

chrome/browser/ui/libgtkui/gtk_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/libgtkui/gtk2_key_bindings_handler.h"
+#include "chrome/browser/ui/libgtkui/gtk_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/libgtkui/gtk2_util.h"
+#include "chrome/browser/ui/libgtkui/gtk_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::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
@@ skipping 70 matching lines @@
 }
 
 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());
+  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;
+  gdk_event->type =
+      xevent->xany.type == KeyPress ? GDK_KEY_PRESS : GDK_KEY_RELEASE;
   gdk_event->time = xevent->xkey.time;
   gdk_event->state = static_cast<GdkModifierType>(xevent->xkey.state);
   gdk_event->hardware_keycode = xevent->xkey.keycode;
 
   if (has_xkb_) {
     gdk_event->group = XkbGroupForCoreState(xevent->xkey.state);
   } else {
     // The overwhelming majority of people will be using X servers that support
     // XKB. GDK has a fallback here that does some complicated stuff to detect
     // whether a modifier key affects the keybinding, but that should be
     // extremely rare.
     static bool logged = false;
     if (!logged) {
       NOTIMPLEMENTED();
       logged = true;
     }
     gdk_event->group = 0;
   }
 
   gdk_event->keyval = GDK_KEY_VoidSymbol;
   gdk_keymap_translate_keyboard_state(
-      keymap,
-      gdk_event->hardware_keycode,
-      static_cast<GdkModifierType>(gdk_event->state),
-      gdk_event->group,
-      &gdk_event->keyval,
-      NULL, NULL, &consumed);
+      keymap, gdk_event->hardware_keycode,
+      static_cast<GdkModifierType>(gdk_event->state), gdk_event->group,
+      &gdk_event->keyval, NULL, NULL, &consumed);
 
   state = static_cast<GdkModifierType>(gdk_event->state & ~consumed);
   gdk_keymap_add_virtual_modifiers(keymap, &state);
   gdk_event->state |= state;
 }
 
-void Gtk2KeyBindingsHandler::HandlerInit(Handler *self) {
+void Gtk2KeyBindingsHandler::HandlerInit(Handler* self) {
   self->owner = NULL;
 }
 
-void Gtk2KeyBindingsHandler::HandlerClassInit(HandlerClass *klass) {
+void Gtk2KeyBindingsHandler::HandlerClassInit(HandlerClass* klass) {
   GtkTextViewClass* text_view_class = GTK_TEXT_VIEW_CLASS(klass);
   GtkWidgetClass* widget_class = GTK_WIDGET_CLASS(klass);
 
   // Overrides all virtual methods related to editor key bindings.
   text_view_class->backspace = BackSpace;
   text_view_class->copy_clipboard = CopyClipboard;
   text_view_class->cut_clipboard = CutClipboard;
   text_view_class->delete_from_cursor = DeleteFromCursor;
   text_view_class->insert_at_cursor = InsertAtCursor;
   text_view_class->move_cursor = MoveCursor;
   text_view_class->paste_clipboard = PasteClipboard;
   text_view_class->set_anchor = SetAnchor;
   text_view_class->toggle_overwrite = ToggleOverwrite;
   widget_class->show_help = ShowHelp;
 
   // "move-focus", "move-viewport", "select-all" and "toggle-cursor-visible"
   // have no corresponding virtual methods. Since glib 2.18 (gtk 2.14),
   // g_signal_override_class_handler() is introduced to override a signal
   // handler.
-  g_signal_override_class_handler("move-focus",
-                                  G_TYPE_FROM_CLASS(klass),
+  g_signal_override_class_handler("move-focus", G_TYPE_FROM_CLASS(klass),
                                   G_CALLBACK(MoveFocus));
 
-  g_signal_override_class_handler("move-viewport",
-                                  G_TYPE_FROM_CLASS(klass),
+  g_signal_override_class_handler("move-viewport", G_TYPE_FROM_CLASS(klass),
                                   G_CALLBACK(MoveViewport));
 
-  g_signal_override_class_handler("select-all",
-                                  G_TYPE_FROM_CLASS(klass),
+  g_signal_override_class_handler("select-all", G_TYPE_FROM_CLASS(klass),
                                   G_CALLBACK(SelectAll));
 
   g_signal_override_class_handler("toggle-cursor-visible",
                                   G_TYPE_FROM_CLASS(klass),
                                   G_CALLBACK(ToggleCursorVisible));
 }
 
 GType Gtk2KeyBindingsHandler::HandlerGetType() {
   static volatile gsize type_id_volatile = 0;
   if (g_once_init_enter(&type_id_volatile)) {
     GType type_id = g_type_register_static_simple(
-        GTK_TYPE_TEXT_VIEW,
-        g_intern_static_string("Gtk2KeyBindingsHandler"),
+        GTK_TYPE_TEXT_VIEW, g_intern_static_string("Gtk2KeyBindingsHandler"),
         sizeof(HandlerClass),
-        reinterpret_cast<GClassInitFunc>(HandlerClassInit),
-        sizeof(Handler),
+        reinterpret_cast<GClassInitFunc>(HandlerClassInit), sizeof(Handler),
         reinterpret_cast<GInstanceInitFunc>(HandlerInit),
         static_cast<GTypeFlags>(0));
     g_once_init_leave(&type_id_volatile, type_id);
   }
   return type_id_volatile;
 }
 
 Gtk2KeyBindingsHandler* Gtk2KeyBindingsHandler::GetHandlerOwner(
     GtkTextView* text_view) {
-  Handler* handler = G_TYPE_CHECK_INSTANCE_CAST(
-      text_view, HandlerGetType(), Handler);
+  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(
       TextEditCommand::DELETE_BACKWARD, std::string());
 }
 
 void Gtk2KeyBindingsHandler::CopyClipboard(GtkTextView* text_view) {
   GetHandlerOwner(text_view)->EditCommandMatched(TextEditCommand::COPY,
                                                  std::string());
 }
 
 void Gtk2KeyBindingsHandler::CutClipboard(GtkTextView* text_view) {
   GetHandlerOwner(text_view)->EditCommandMatched(TextEditCommand::CUT,
                                                  std::string());
 }
 
-void Gtk2KeyBindingsHandler::DeleteFromCursor(
-    GtkTextView* text_view, GtkDeleteType type, gint count) {
+void Gtk2KeyBindingsHandler::DeleteFromCursor(GtkTextView* text_view,
+                                              GtkDeleteType type,
+                                              gint count) {
   if (!count)
     return;
 
   TextEditCommand commands[2] = {
       TextEditCommand::INVALID_COMMAND, TextEditCommand::INVALID_COMMAND,
   };
   switch (type) {
     case GTK_DELETE_CHARS:
       commands[0] = (count > 0 ? TextEditCommand::DELETE_FORWARD
                                : TextEditCommand::DELETE_BACKWARD);
@@ skipping 44 matching lines @@
 }
 
 void Gtk2KeyBindingsHandler::InsertAtCursor(GtkTextView* text_view,
                                             const gchar* str) {
   if (str && *str) {
     GetHandlerOwner(text_view)->EditCommandMatched(TextEditCommand::INSERT_TEXT,
                                                    str);
   }
 }
 
-void Gtk2KeyBindingsHandler::MoveCursor(
-    GtkTextView* text_view, GtkMovementStep step, gint count,
-    gboolean extend_selection) {
+void Gtk2KeyBindingsHandler::MoveCursor(GtkTextView* text_view,
+                                        GtkMovementStep step,
+                                        gint count,
+                                        gboolean extend_selection) {
   if (!count)
     return;
 
   TextEditCommand command;
   switch (step) {
     case GTK_MOVEMENT_LOGICAL_POSITIONS:
       if (extend_selection) {
         command =
             (count > 0 ? TextEditCommand::MOVE_FORWARD_AND_MODIFY_SELECTION
                        : TextEditCommand::MOVE_BACKWARD_AND_MODIFY_SELECTION);
@@ skipping 83 matching lines @@
       return;
   }
 
   Gtk2KeyBindingsHandler* owner = GetHandlerOwner(text_view);
   if (count < 0)
     count = -count;
   for (; count > 0; --count)
     owner->EditCommandMatched(command, std::string());
 }
 
-void Gtk2KeyBindingsHandler::MoveViewport(
-    GtkTextView* text_view, GtkScrollStep step, gint count) {
+void Gtk2KeyBindingsHandler::MoveViewport(GtkTextView* text_view,
+                                          GtkScrollStep step,
+                                          gint count) {
   // Not supported by webkit.
 }
 
 void Gtk2KeyBindingsHandler::PasteClipboard(GtkTextView* text_view) {
   GetHandlerOwner(text_view)->EditCommandMatched(TextEditCommand::PASTE,
                                                  std::string());
 }
 
 void Gtk2KeyBindingsHandler::SelectAll(GtkTextView* text_view,
                                        gboolean select) {
@@ skipping 20 matching lines @@
   // Just for disabling the default handler.
   return FALSE;
 }
 
 void Gtk2KeyBindingsHandler::MoveFocus(GtkWidget* widget,
                                        GtkDirectionType arg1) {
   // Just for disabling the default handler.
 }
 
 }  // namespace libgtkui