linux: Move linux_util.h from gfx/ to ui/base/gtk.

chrome/browser/ui/gtk/menu_gtk.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/gtk/menu_gtk.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/ui/gtk/gtk_custom_menu.h"
 #include "chrome/browser/ui/gtk/gtk_custom_menu_item.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "chrome/browser/ui/views/event_utils.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/accelerators/accelerator_gtk.h"
+#include "ui/base/gtk/menu_label_accelerator_util.h"
 #include "ui/base/models/button_menu_item_model.h"
 #include "ui/base/models/menu_model.h"
 #include "ui/gfx/gtk_util.h"
-#include "ui/gfx/linux_util.h"
 #include "webkit/glue/window_open_disposition.h"
 
 bool MenuGtk::block_activation_ = false;
 
 namespace {
 
 // Sets the ID of a menu item.
 void SetMenuItemID(GtkWidget* menu_item, int menu_id) {
   DCHECK_GE(menu_id, 0);
 
@@ skipping 271 matching lines @@
   // take a long time or even start a nested message loop.
   g_signal_connect(menu_, "show", G_CALLBACK(OnMenuShowThunk), this);
   g_signal_connect(menu_, "hide", G_CALLBACK(OnMenuHiddenThunk), this);
   GtkWidget *toplevel_window = gtk_widget_get_toplevel(menu_);
   signal_.Connect(toplevel_window, "focus-out-event",
                   G_CALLBACK(OnMenuFocusOutThunk), this);
 }
 
 GtkWidget* MenuGtk::AppendMenuItemWithLabel(int command_id,
                                             const std::string& label) {
-  std::string converted_label = gfx::ConvertAcceleratorsFromWindowsStyle(label);
+  std::string converted_label = ui::ConvertAcceleratorsFromWindowsStyle(label);
   GtkWidget* menu_item = BuildMenuItemWithLabel(label, command_id);
   return AppendMenuItem(command_id, menu_item);
 }
 
 GtkWidget* MenuGtk::AppendMenuItemWithIcon(int command_id,
                                            const std::string& label,
                                            const SkBitmap& icon) {
-  std::string converted_label = gfx::ConvertAcceleratorsFromWindowsStyle(label);
+  std::string converted_label = ui::ConvertAcceleratorsFromWindowsStyle(label);
   GtkWidget* menu_item = BuildMenuItemWithImage(converted_label, icon);
   return AppendMenuItem(command_id, menu_item);
 }
 
 GtkWidget* MenuGtk::AppendCheckMenuItemWithLabel(int command_id,
                                                  const std::string& label) {
-  std::string converted_label = gfx::ConvertAcceleratorsFromWindowsStyle(label);
+  std::string converted_label = ui::ConvertAcceleratorsFromWindowsStyle(label);
   GtkWidget* menu_item =
       gtk_check_menu_item_new_with_mnemonic(converted_label.c_str());
   return AppendMenuItem(command_id, menu_item);
 }
 
 GtkWidget* MenuGtk::AppendSeparator() {
   GtkWidget* menu_item = gtk_separator_menu_item_new();
   gtk_widget_show(menu_item);
   gtk_menu_shell_append(GTK_MENU_SHELL(menu_), menu_item);
   return menu_item;
@@ skipping 97 matching lines @@
 
 void MenuGtk::BuildMenuFromModel() {
   BuildSubmenuFromModel(model_, menu_);
 }
 
 void MenuGtk::BuildSubmenuFromModel(ui::MenuModel* model, GtkWidget* menu) {
   std::map<int, GtkWidget*> radio_groups;
   GtkWidget* menu_item = NULL;
   for (int i = 0; i < model->GetItemCount(); ++i) {
     SkBitmap icon;
-    std::string label =
-        gfx::ConvertAcceleratorsFromWindowsStyle(
-            UTF16ToUTF8(model->GetLabelAt(i)));
+    std::string label = ui::ConvertAcceleratorsFromWindowsStyle(
+        UTF16ToUTF8(model->GetLabelAt(i)));
     bool connect_to_activate = true;
 
     switch (model->GetTypeAt(i)) {
       case ui::MenuModel::TYPE_SEPARATOR:
         menu_item = gtk_separator_menu_item_new();
         break;
 
       case ui::MenuModel::TYPE_CHECK:
         menu_item = gtk_check_menu_item_new_with_mnemonic(label.c_str());
         break;
@@ skipping 61 matching lines @@
     g_object_set_data(G_OBJECT(menu_item), "model", model);
     AppendMenuItemToMenu(i, model, menu_item, menu, connect_to_activate);
 
     menu_item = NULL;
   }
 }
 
 GtkWidget* MenuGtk::BuildButtonMenuItem(ui::ButtonMenuItemModel* model,
                                         GtkWidget* menu) {
   GtkWidget* menu_item = gtk_custom_menu_item_new(
-      gfx::RemoveWindowsStyleAccelerators(UTF16ToUTF8(model->label())).c_str());
+      ui::RemoveWindowsStyleAccelerators(UTF16ToUTF8(model->label())).c_str());
 
   // Set up the callback to the model for when it is clicked.
   g_object_set_data(G_OBJECT(menu_item), "button-model", model);
   g_signal_connect(menu_item, "button-pushed",
                    G_CALLBACK(OnMenuButtonPressedThunk), this);
   g_signal_connect(menu_item, "try-button-pushed",
                    G_CALLBACK(OnMenuTryButtonPressedThunk), this);
 
   GtkSizeGroup* group = NULL;
   for (int i = 0; i < model->GetItemCount(); ++i) {
     GtkWidget* button = NULL;
 
     switch (model->GetTypeAt(i)) {
       case ui::ButtonMenuItemModel::TYPE_SPACE: {
         gtk_custom_menu_item_add_space(GTK_CUSTOM_MENU_ITEM(menu_item));
         break;
       }
       case ui::ButtonMenuItemModel::TYPE_BUTTON: {
         button = gtk_custom_menu_item_add_button(
             GTK_CUSTOM_MENU_ITEM(menu_item),
             model->GetCommandIdAt(i));
 
         int icon_idr;
         if (model->GetIconAt(i, &icon_idr)) {
           SetupImageIcon(button, menu, icon_idr, delegate_);
         } else {
           gtk_button_set_label(
               GTK_BUTTON(button),
-              gfx::RemoveWindowsStyleAccelerators(
+              ui::RemoveWindowsStyleAccelerators(
                   UTF16ToUTF8(model->GetLabelAt(i))).c_str());
         }
 
         SetUpButtonShowHandler(button, model, i);
         break;
       }
       case ui::ButtonMenuItemModel::TYPE_BUTTON_LABEL: {
         button = gtk_custom_menu_item_add_button_label(
             GTK_CUSTOM_MENU_ITEM(menu_item),
             model->GetCommandIdAt(i));
         gtk_button_set_label(
             GTK_BUTTON(button),
-            gfx::RemoveWindowsStyleAccelerators(
+            ui::RemoveWindowsStyleAccelerators(
                 UTF16ToUTF8(model->GetLabelAt(i))).c_str());
         SetUpButtonShowHandler(button, model, i);
         break;
       }
     }
 
     if (button && model->PartOfGroup(i)) {
       if (!group)
         group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 
@@ skipping 221 matching lines @@
 
 // static
 void MenuGtk::SetButtonItemInfo(GtkWidget* button, gpointer userdata) {
   ui::ButtonMenuItemModel* model =
       reinterpret_cast<ui::ButtonMenuItemModel*>(
           g_object_get_data(G_OBJECT(button), "button-model"));
   int index = GPOINTER_TO_INT(g_object_get_data(
       G_OBJECT(button), "button-model-id"));
 
   if (model->IsItemDynamicAt(index)) {
-    std::string label =
-        gfx::ConvertAcceleratorsFromWindowsStyle(
-            UTF16ToUTF8(model->GetLabelAt(index)));
+    std::string label = ui::ConvertAcceleratorsFromWindowsStyle(
+        UTF16ToUTF8(model->GetLabelAt(index)));
     gtk_button_set_label(GTK_BUTTON(button), label.c_str());
   }
 
   gtk_widget_set_sensitive(GTK_WIDGET(button), model->IsEnabledAt(index));
 }
 
 // static
 void MenuGtk::SetMenuItemInfo(GtkWidget* widget, gpointer userdata) {
   if (GTK_IS_SEPARATOR_MENU_ITEM(widget)) {
     // We need to explicitly handle this case because otherwise we'll ask the
@@ skipping 36 matching lines @@
                                         SetButtonItemInfo,
                                         userdata);
   }
 
   if (GTK_IS_MENU_ITEM(widget)) {
     gtk_widget_set_sensitive(widget, model->IsEnabledAt(id));
 
     if (model->IsVisibleAt(id)) {
       // Update the menu item label if it is dynamic.
       if (model->IsItemDynamicAt(id)) {
-        std::string label =
-            gfx::ConvertAcceleratorsFromWindowsStyle(
-                UTF16ToUTF8(model->GetLabelAt(id)));
+        std::string label = ui::ConvertAcceleratorsFromWindowsStyle(
+            UTF16ToUTF8(model->GetLabelAt(id)));
 
         gtk_menu_item_set_label(GTK_MENU_ITEM(widget), label.c_str());
         if (GTK_IS_IMAGE_MENU_ITEM(widget)) {
           SkBitmap icon;
           if (model->GetIconAt(id, &icon)) {
             GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(&icon);
             gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(widget),
                                           gtk_image_new_from_pixbuf(pixbuf));
             g_object_unref(pixbuf);
           } else {
             gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(widget), NULL);
           }
         }
       }
 
       gtk_widget_show(widget);
     } else {
       gtk_widget_hide(widget);
     }
 
     GtkWidget* submenu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(widget));
     if (submenu) {
       gtk_container_foreach(GTK_CONTAINER(submenu), &SetMenuItemInfo,
                             userdata);
     }
   }
 }