Convert ui::MenuModel to use gfx::Image instead of ImageSkia.

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/event_utils.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 "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/image/image.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 283 matching lines @@
 
 GtkWidget* MenuGtk::AppendMenuItemWithLabel(int command_id,
                                             const std::string& 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) {
+                                           const gfx::Image& icon) {
   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 = ui::ConvertAcceleratorsFromWindowsStyle(label);
   GtkWidget* menu_item =
       gtk_check_menu_item_new_with_mnemonic(converted_label.c_str());
@@ skipping 79 matching lines @@
 
 GtkWidget* MenuGtk::BuildMenuItemWithImage(const std::string& label,
                                            GtkWidget* image) {
   GtkWidget* menu_item =
       gtk_image_menu_item_new_with_mnemonic(label.c_str());
   gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item), image);
   return menu_item;
 }
 
 GtkWidget* MenuGtk::BuildMenuItemWithImage(const std::string& label,
-                                           const SkBitmap& icon) {
-  GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(icon);
+                                           const gfx::Image& icon) {
   GtkWidget* menu_item = BuildMenuItemWithImage(label,
-      gtk_image_new_from_pixbuf(pixbuf));
-  g_object_unref(pixbuf);
+      gtk_image_new_from_pixbuf(icon.ToGdkPixbuf()));
   return menu_item;
 }
 
 GtkWidget* MenuGtk::BuildMenuItemWithLabel(const std::string& label,
                                            int command_id) {
   GtkWidget* img =
       delegate_ ? delegate_->GetImageForCommandId(command_id) :
                   MenuGtk::Delegate::GetDefaultImageForCommandId(command_id);
   return img ? BuildMenuItemWithImage(label, img) :
                gtk_menu_item_new_with_mnemonic(label.c_str());
 }
 
 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) {
-    gfx::ImageSkia icon;
+    gfx::Image icon;
     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:
@@ skipping 18 matching lines @@
         ui::ButtonMenuItemModel* button_menu_item_model =
             model->GetButtonMenuItemAt(i);
         menu_item = BuildButtonMenuItem(button_menu_item_model, menu);
         connect_to_activate = false;
         break;
       }
       case ui::MenuModel::TYPE_SUBMENU:
       case ui::MenuModel::TYPE_COMMAND: {
         int command_id = model->GetCommandIdAt(i);
         if (model->GetIconAt(i, &icon))
-          menu_item = BuildMenuItemWithImage(label, *icon.bitmap());
+          menu_item = BuildMenuItemWithImage(label, icon);
         else
           menu_item = BuildMenuItemWithLabel(label, command_id);
         if (delegate_ && delegate_->AlwaysShowIconForCmd(command_id) &&
             GTK_IS_IMAGE_MENU_ITEM(menu_item)) {
           gtk_util::SetAlwaysShowImage(menu_item);
         }
         break;
       }
 
       default:
@@ skipping 374 matching lines @@
     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 = 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)) {
-          gfx::ImageSkia icon;
+          gfx::Image icon;
           if (model->GetIconAt(id, &icon)) {
-            GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(*icon.bitmap());
             gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(widget),
-                                          gtk_image_new_from_pixbuf(pixbuf));
-            g_object_unref(pixbuf);
+                                          gtk_image_new_from_pixbuf(
+                                              icon.ToGdkPixbuf()));
           } 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);
     }
   }
 }