Add 2-lines summary to CC/Address for Wallet items.

ui/base/models/simple_menu_model.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 "ui/base/models/simple_menu_model.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/image/image.h"
 
 namespace ui {
 
 const int kSeparatorId = -1;
 
 struct SimpleMenuModel::Item {
   int command_id;
   string16 label;
+  string16 sublabel;
   gfx::Image icon;
   ItemType type;
   int group_id;
   MenuModel* submenu;
   ButtonMenuItemModel* button_model;
   MenuSeparatorType separator_type;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // SimpleMenuModel::Delegate, public:
 
 bool SimpleMenuModel::Delegate::IsCommandIdVisible(int command_id) const {
   return true;
 }
 
 bool SimpleMenuModel::Delegate::IsItemForCommandIdDynamic(
     int command_id) const {
   return false;
 }
 
 string16 SimpleMenuModel::Delegate::GetLabelForCommandId(int command_id) const {
   return string16();
 }
 
+string16 SimpleMenuModel::Delegate::GetSublabelForCommandId(
+    int command_id) const {
+  return string16();
+}
+
 bool SimpleMenuModel::Delegate::GetIconForCommandId(
     int command_id, gfx::Image* image_skia) const {
   return false;
 }
 
 void SimpleMenuModel::Delegate::CommandIdHighlighted(int command_id) {
 }
 
 void SimpleMenuModel::Delegate::ExecuteCommand(
     int command_id, int event_flags) {
@@ skipping 12 matching lines @@
 SimpleMenuModel::SimpleMenuModel(Delegate* delegate)
     : delegate_(delegate),
       menu_model_delegate_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
 }
 
 SimpleMenuModel::~SimpleMenuModel() {
 }
 
 void SimpleMenuModel::AddItem(int command_id, const string16& label) {
-  Item item = { command_id, label, gfx::Image(), TYPE_COMMAND, -1, NULL,
-                NULL, NORMAL_SEPARATOR };
+  Item item = { command_id, label, string16(), gfx::Image(),
+                TYPE_COMMAND, -1, NULL, NULL, NORMAL_SEPARATOR };
   AppendItem(item);
 }
 
 void SimpleMenuModel::AddItemWithStringId(int command_id, int string_id) {
   AddItem(command_id, l10n_util::GetStringUTF16(string_id));
 }
 
 void SimpleMenuModel::AddCheckItem(int command_id, const string16& label) {
-  Item item = { command_id, label, gfx::Image(), TYPE_CHECK, -1, NULL,
-                NULL, NORMAL_SEPARATOR };
+  Item item = { command_id, label, string16(), gfx::Image(),
+                TYPE_CHECK, -1, NULL, NULL, NORMAL_SEPARATOR };
   AppendItem(item);
 }
 
 void SimpleMenuModel::AddCheckItemWithStringId(int command_id, int string_id) {
   AddCheckItem(command_id, l10n_util::GetStringUTF16(string_id));
 }
 
 void SimpleMenuModel::AddRadioItem(int command_id, const string16& label,
                                    int group_id) {
-  Item item = { command_id, label, gfx::Image(), TYPE_RADIO, group_id, NULL,
-                NULL, NORMAL_SEPARATOR };
+  Item item = { command_id, label, string16(), gfx::Image(),
+                TYPE_RADIO, group_id, NULL, NULL, NORMAL_SEPARATOR };
   AppendItem(item);
 }
 
 void SimpleMenuModel::AddRadioItemWithStringId(int command_id, int string_id,
                                                int group_id) {
   AddRadioItem(command_id, l10n_util::GetStringUTF16(string_id), group_id);
 }
 
 void SimpleMenuModel::AddSeparator(MenuSeparatorType separator_type) {
   if (items_.empty()) {
     if (separator_type == NORMAL_SEPARATOR) {
       return;
     }
     DCHECK_EQ(SPACING_SEPARATOR, separator_type);
   } else if (items_.back().type == TYPE_SEPARATOR) {
     DCHECK_EQ(NORMAL_SEPARATOR, separator_type);
     DCHECK_EQ(NORMAL_SEPARATOR, items_.back().separator_type);
     return;
   }
 #if !defined(USE_AURA)
   if (separator_type != NORMAL_SEPARATOR)
     NOTIMPLEMENTED();
 #endif
-  Item item = { kSeparatorId, string16(), gfx::Image(), TYPE_SEPARATOR,
-                -1, NULL, NULL , separator_type };
+  Item item = { kSeparatorId, string16(), string16(), gfx::Image(),
+                TYPE_SEPARATOR, -1, NULL, NULL , separator_type };
   AppendItem(item);
 }
 
 void SimpleMenuModel::RemoveTrailingSeparators() {
   while (!items_.empty() && items_.back().type == TYPE_SEPARATOR)
     items_.pop_back();
 }
 
 void SimpleMenuModel::AddButtonItem(int command_id,
                                     ButtonMenuItemModel* model) {
-  Item item = { command_id, string16(), gfx::Image(), TYPE_BUTTON_ITEM, -1,
-                NULL, model, NORMAL_SEPARATOR };
+  Item item = { command_id, string16(), string16(), gfx::Image(),
+                TYPE_BUTTON_ITEM, -1, NULL, model, NORMAL_SEPARATOR };
   AppendItem(item);
 }
 
 void SimpleMenuModel::AddSubMenu(int command_id, const string16& label,
                                  MenuModel* model) {
-  Item item = { command_id, label, gfx::Image(), TYPE_SUBMENU, -1, model,
-                NULL, NORMAL_SEPARATOR };
+  Item item = { command_id, label, string16(), gfx::Image(),
+                TYPE_SUBMENU, -1, model, NULL, NORMAL_SEPARATOR };
   AppendItem(item);
 }
 
 void SimpleMenuModel::AddSubMenuWithStringId(int command_id,
                                              int string_id, MenuModel* model) {
   AddSubMenu(command_id, l10n_util::GetStringUTF16(string_id), model);
 }
 
 void SimpleMenuModel::InsertItemAt(
     int index, int command_id, const string16& label) {
-  Item item = { command_id, label, gfx::Image(), TYPE_COMMAND, -1, NULL,
-                NULL, NORMAL_SEPARATOR };
+  Item item = { command_id, label, string16(), gfx::Image(),
+                TYPE_COMMAND, -1, NULL, NULL, NORMAL_SEPARATOR };
   InsertItemAtIndex(item, index);
 }
 
 void SimpleMenuModel::InsertItemWithStringIdAt(
     int index, int command_id, int string_id) {
   InsertItemAt(index, command_id, l10n_util::GetStringUTF16(string_id));
 }
 
 void SimpleMenuModel::InsertSeparatorAt(int index,
                                         MenuSeparatorType separator_type) {
 #if !defined(USE_AURA)
   if (separator_type != NORMAL_SEPARATOR) {
     NOTIMPLEMENTED();
   }
 #endif
-  Item item = { kSeparatorId, string16(), gfx::Image(), TYPE_SEPARATOR,
-                -1, NULL, NULL, separator_type };
+  Item item = { kSeparatorId, string16(), string16(), gfx::Image(),
+                TYPE_SEPARATOR, -1, NULL, NULL, separator_type };
   InsertItemAtIndex(item, index);
 }
 
 void SimpleMenuModel::InsertCheckItemAt(
     int index, int command_id, const string16& label) {
-  Item item = { command_id, label, gfx::Image(), TYPE_CHECK, -1, NULL,
-                NULL, NORMAL_SEPARATOR };
+  Item item = { command_id, label, string16(), gfx::Image(),
+                TYPE_CHECK, -1, NULL, NULL, NORMAL_SEPARATOR };
   InsertItemAtIndex(item, index);
 }
 
 void SimpleMenuModel::InsertCheckItemWithStringIdAt(
     int index, int command_id, int string_id) {
   InsertCheckItemAt(index, command_id, l10n_util::GetStringUTF16(string_id));
 }
 
 void SimpleMenuModel::InsertRadioItemAt(
     int index, int command_id, const string16& label, int group_id) {
-  Item item = { command_id, label, gfx::Image(), TYPE_RADIO, group_id, NULL,
-                NULL, NORMAL_SEPARATOR };
+  Item item = { command_id, label, string16(), gfx::Image(),
+                TYPE_RADIO, group_id, NULL, NULL, NORMAL_SEPARATOR };
   InsertItemAtIndex(item, index);
 }
 
 void SimpleMenuModel::InsertRadioItemWithStringIdAt(
     int index, int command_id, int string_id, int group_id) {
   InsertRadioItemAt(
       index, command_id, l10n_util::GetStringUTF16(string_id), group_id);
 }
 
 void SimpleMenuModel::InsertSubMenuAt(
     int index, int command_id, const string16& label, MenuModel* model) {
-  Item item = { command_id, label, gfx::Image(), TYPE_SUBMENU, -1, model,
-                NULL, NORMAL_SEPARATOR };
+  Item item = { command_id, label, string16(), gfx::Image(),
+                TYPE_SUBMENU, -1, model, NULL, NORMAL_SEPARATOR };
   InsertItemAtIndex(item, index);
 }
 
 void SimpleMenuModel::InsertSubMenuWithStringIdAt(
     int index, int command_id, int string_id, MenuModel* model) {
   InsertSubMenuAt(index, command_id, l10n_util::GetStringUTF16(string_id),
                   model);
 }
 
 void SimpleMenuModel::SetIcon(int index, const gfx::Image& icon) {
   items_[ValidateItemIndex(index)].icon = icon;
 }
 
+void SimpleMenuModel::SetSublabel(int index, const string16& sublabel) {
+  items_[ValidateItemIndex(index)].sublabel = sublabel;
+}
+
 void SimpleMenuModel::Clear() {
   items_.clear();
 }
 
 int SimpleMenuModel::GetIndexOfCommandId(int command_id) {
   for (ItemVector::iterator i = items_.begin(); i != items_.end(); ++i) {
     if (i->command_id == command_id)
       return static_cast<int>(std::distance(items_.begin(), i));
   }
   return -1;
@@ skipping 26 matching lines @@
 int SimpleMenuModel::GetCommandIdAt(int index) const {
   return items_[ValidateItemIndex(index)].command_id;
 }
 
 string16 SimpleMenuModel::GetLabelAt(int index) const {
   if (IsItemDynamicAt(index))
     return delegate_->GetLabelForCommandId(GetCommandIdAt(index));
   return items_[ValidateItemIndex(index)].label;
 }
 
+string16 SimpleMenuModel::GetSublabelAt(int index) const {
+  if (IsItemDynamicAt(index))
+    return delegate_->GetSublabelForCommandId(GetCommandIdAt(index));
+  return items_[ValidateItemIndex(index)].sublabel;
+}
+
 bool SimpleMenuModel::IsItemDynamicAt(int index) const {
   if (delegate_)
     return delegate_->IsItemForCommandIdDynamic(GetCommandIdAt(index));
   return false;
 }
 
 bool SimpleMenuModel::GetAcceleratorAt(int index,
                                        ui::Accelerator* accelerator) const {
   if (delegate_) {
     return delegate_->GetAcceleratorForCommandId(GetCommandIdAt(index),
@@ skipping 114 matching lines @@
 #ifndef NDEBUG
   if (item.type == TYPE_SEPARATOR) {
     DCHECK_EQ(item.command_id, kSeparatorId);
   } else {
     DCHECK_GE(item.command_id, 0);
   }
 #endif  // NDEBUG
 }
 
 }  // namespace ui