Make back forward menu model a MenuModel....

chrome/browser/gtk/menu_gtk.cc

 // Copyright (c) 2009 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/gtk/menu_gtk.h"
 
 #include "app/gfx/gtk_util.h"
 #include "app/l10n_util.h"
+#include "app/menus/menu_model.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "chrome/browser/gtk/standard_menus.h"
 #include "chrome/common/gtk_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 using gtk_util::ConvertAcceleratorsFromWindowsStyle;
 
 bool MenuGtk::block_activation_ = false;
 
 MenuGtk::MenuGtk(MenuGtk::Delegate* delegate,
                  const MenuCreateMaterial* menu_data,
                  GtkAccelGroup* accel_group)
     : delegate_(delegate),
+      model_(NULL),
       dummy_accel_group_(gtk_accel_group_new()),
       menu_(gtk_menu_new()),
       factory_(this) {
   ConnectSignalHandlers();
   BuildMenuIn(menu_.get(), menu_data, accel_group);
 }
 
-MenuGtk::MenuGtk(MenuGtk::Delegate* delegate, bool load)
+MenuGtk::MenuGtk(MenuGtk::Delegate* delegate,
+                 menus::MenuModel* model)
     : delegate_(delegate),
+      model_(model),
       dummy_accel_group_(NULL),
       menu_(gtk_menu_new()),
       factory_(this) {
   ConnectSignalHandlers();
-  if (load)
-    BuildMenuFromDelegate();
+  if (model)
+    BuildMenuFromModel();
 }
 
 MenuGtk::~MenuGtk() {
   menu_.Destroy();
   STLDeleteContainerPointers(submenus_we_own_.begin(), submenus_we_own_.end());
   if (dummy_accel_group_)
     g_object_unref(dummy_accel_group_);
 }
 
 void MenuGtk::ConnectSignalHandlers() {
@@ skipping 86 matching lines @@
   for (; menu_data->type != MENU_END; ++menu_data) {
     GtkWidget* menu_item = NULL;
 
     std::string label;
     if (menu_data->label_argument) {
       label = l10n_util::GetStringFUTF8(
           menu_data->label_id,
           l10n_util::GetStringUTF16(menu_data->label_argument));
     } else if (menu_data->label_id) {
       label = l10n_util::GetStringUTF8(menu_data->label_id);
-    } else if (menu_data->type != MENU_SEPARATOR) {
-      label = delegate_->GetLabel(menu_data->id);
-      DCHECK(!label.empty());
     }
 
     label = ConvertAcceleratorsFromWindowsStyle(label);
 
     switch (menu_data->type) {
       case MENU_RADIO:
         if (GTK_IS_RADIO_MENU_ITEM(last_menu_item)) {
           menu_item = gtk_radio_menu_item_new_with_mnemonic_from_widget(
               GTK_RADIO_MENU_ITEM(last_menu_item), label.c_str());
         } else {
@@ skipping 57 matching lines @@
   GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(&icon);
   gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item),
                                 gtk_image_new_from_pixbuf(pixbuf));
   g_object_unref(pixbuf);
   if (delegate_->AlwaysShowImages())
     gtk_util::SetAlwaysShowImage(menu_item);
 
   return menu_item;
 }
 
-void MenuGtk::BuildMenuFromDelegate() {
-  // Note that the menu IDs start at 1, not 0.
-  for (int i = 1; i <= delegate_->GetItemCount(); ++i) {
+void MenuGtk::BuildMenuFromModel() {
+  for (int i = 0; i < model_->GetItemCount(); ++i) {
     GtkWidget* menu_item = NULL;
 
-    if (delegate_->IsItemSeparator(i)) {
+    // TODO(estade): support these commands.
+    DCHECK_NE(model_->GetTypeAt(i), menus::MenuModel::TYPE_CHECK);
+    DCHECK_NE(model_->GetTypeAt(i), menus::MenuModel::TYPE_RADIO);
+    DCHECK_NE(model_->GetTypeAt(i), menus::MenuModel::TYPE_SUBMENU);
+
+    SkBitmap icon;
+    if (model_->GetTypeAt(i) == menus::MenuModel::TYPE_SEPARATOR) {
       menu_item = gtk_separator_menu_item_new();
-    } else if (delegate_->HasIcon(i)) {
-      const SkBitmap* icon = delegate_->GetIcon(i);
-      menu_item = BuildMenuItemWithImage(delegate_->GetLabel(i), *icon);
+    } else if (model_->GetIconAt(i, &icon)) {
+      menu_item = BuildMenuItemWithImage(UTF16ToUTF8(model_->GetLabelAt(i)),
+                                         icon);
     } else {
-      menu_item = gtk_menu_item_new_with_label(delegate_->GetLabel(i).c_str());
+      menu_item = gtk_menu_item_new_with_label(
+          UTF16ToUTF8(model_->GetLabelAt(i)).c_str());
     }
 
     AppendMenuItem(i, menu_item);
   }
 }
 
 // static
 void MenuGtk::OnMenuItemActivated(GtkMenuItem* menuitem, MenuGtk* menu) {
   if (block_activation_)
     return;
@@ skipping 148 matching lines @@
     gtk_widget_set_sensitive(
         widget, menu->delegate_->IsCommandEnabled(id));
 
     GtkWidget* submenu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(widget));
     if (submenu) {
       gtk_container_foreach(GTK_CONTAINER(submenu), &SetMenuItemInfo,
                             userdata);
     }
   }
 }