views: Finally get rid of the deprecated Menu2 API.

ui/views/controls/menu/native_menu_win.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/views/controls/menu/native_menu_win.h"
 
 #include <Windowsx.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/win/wrapped_window_proc.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_win.h"
 #include "ui/base/models/menu_model.h"
 #include "ui/base/win/hwnd_util.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/rect.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/native_theme/native_theme_win.h"
-#include "ui/views/controls/menu/menu_2.h"
 #include "ui/views/controls/menu/menu_config.h"
+#include "ui/views/controls/menu/menu_insertion_delegate.h"
 #include "ui/views/controls/menu/menu_listener.h"
 
 using ui::NativeTheme;
 
 namespace views {
 
 // The width of an icon, including the pixels between the icon and
 // the item label.
 static const int kIconWidth = 23;
 // Margins between the top of the item and the label.
 static const int kItemTopMargin = 3;
 // Margins between the bottom of the item and the label.
 static const int kItemBottomMargin = 4;
 // Margins between the left of the item and the icon.
 static const int kItemLeftMargin = 4;
 // Margins between the right of the item and the label.
 static const int kItemRightMargin = 10;
 // The width for displaying the sub-menu arrow.
 static const int kArrowWidth = 10;
 
 struct NativeMenuWin::ItemData {
   // The Windows API requires that whoever creates the menus must own the
   // strings used for labels, and keep them around for the lifetime of the
   // created menu. So be it.
   string16 label;
 
   // Someone needs to own submenus, it may as well be us.
-  scoped_ptr<Menu2> submenu;
+  scoped_ptr<NativeMenuWin> submenu;
 
   // We need a pointer back to the containing menu in various circumstances.
   NativeMenuWin* native_menu_win;
 
   // The index of the item within the menu's model.
   int model_index;
 };
 
 // Returns the NativeMenuWin for a particular HMENU.
 static NativeMenuWin* GetNativeMenuWinFromHMENU(HMENU hmenu) {
@@ skipping 77 matching lines @@
   // Called when the user selects a specific item.
   void OnMenuCommand(int position, HMENU menu) {
     NativeMenuWin* menu_win = GetNativeMenuWinFromHMENU(menu);
     ui::MenuModel* model = menu_win->model_;
     NativeMenuWin* root_menu = menu_win;
     while (root_menu->parent_)
       root_menu = root_menu->parent_;
 
     // Only notify the model if it didn't already send out notification.
     // See comment in MenuMessageHook for details.
-    if (root_menu->menu_action_ == MenuWrapper::MENU_ACTION_NONE)
+    if (root_menu->menu_action_ == MENU_ACTION_NONE)
       model->ActivatedAt(position);
   }
 
   // Called as the user moves their mouse or arrows through the contents of the
   // menu.
   void OnMenuSelect(WPARAM w_param, HMENU menu) {
     if (!menu)
       return;  // menu is null when closing on XP.
 
     int position = GetMenuItemIndexFromWPARAM(menu, w_param);
@@ skipping 237 matching lines @@
       destroyed_flag_(NULL) {
 }
 
 NativeMenuWin::~NativeMenuWin() {
   if (destroyed_flag_)
     *destroyed_flag_ = true;
   STLDeleteContainerPointers(items_.begin(), items_.end());
   DestroyMenu(menu_);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// NativeMenuWin, MenuWrapper implementation:
-
 void NativeMenuWin::RunMenuAt(const gfx::Point& point, int alignment) {
   CreateHostWindow();
   UpdateStates();
   UINT flags = TPM_LEFTBUTTON | TPM_RIGHTBUTTON | TPM_RECURSE;
   flags |= GetAlignmentFlags(alignment);
   menu_action_ = MENU_ACTION_NONE;
 
   // Set a hook function so we can listen for keyboard events while the
   // menu is open, and store a pointer to this object in a static
   // variable so the hook has access to it (ugly, but it's the
@@ skipping 36 matching lines @@
   }
   // Send MenuClosed after we schedule the select, otherwise MenuClosed is
   // processed after the select (MenuClosed posts a delayed task too).
   model_->MenuClosed();
 }
 
 void NativeMenuWin::CancelMenu() {
   EndMenu();
 }
 
-void NativeMenuWin::Rebuild(InsertionDelegate* delegate) {
+void NativeMenuWin::Rebuild(MenuInsertionDelegate* delegate) {
   ResetNativeMenu();
   items_.clear();
 
   owner_draw_ = model_->HasIcons() || owner_draw_;
   first_item_index_ = delegate ? delegate->GetInsertionIndex(menu_) : 0;
   for (int menu_index = first_item_index_;
         menu_index < first_item_index_ + model_->GetItemCount(); ++menu_index) {
     int model_index = menu_index - first_item_index_;
     if (model_->GetTypeAt(model_index) == ui::MenuModel::TYPE_SEPARATOR)
       AddSeparatorItemAt(menu_index, model_index);
     else
       AddMenuItemAt(menu_index, model_index);
   }
 }
 
 void NativeMenuWin::UpdateStates() {
   // A depth-first walk of the menu items, updating states.
   int model_index = 0;
   std::vector<ItemData*>::const_iterator it;
   for (it = items_.begin(); it != items_.end(); ++it, ++model_index) {
     int menu_index = model_index + first_item_index_;
     SetMenuItemState(menu_index, model_->IsEnabledAt(model_index),
                      model_->IsItemCheckedAt(model_index), false);
     if (model_->IsItemDynamicAt(model_index)) {
       // TODO(atwilson): Update the icon as well (http://crbug.com/66508).
       SetMenuItemLabel(menu_index, model_index,
                        model_->GetLabelAt(model_index));
     }
-    Menu2* submenu = (*it)->submenu.get();
+    NativeMenuWin* submenu = (*it)->submenu.get();
     if (submenu)
       submenu->UpdateStates();
   }
 }
 
 HMENU NativeMenuWin::GetNativeMenu() const {
   return menu_;
 }
 
 NativeMenuWin::MenuAction NativeMenuWin::GetMenuAction() const {
@@ skipping 110 matching lines @@
   mii.fMask = MIIM_FTYPE | MIIM_ID | MIIM_DATA;
   if (!owner_draw_)
     mii.fType = MFT_STRING;
   else
     mii.fType = MFT_OWNERDRAW;
 
   ItemData* item_data = new ItemData;
   item_data->label = string16();
   ui::MenuModel::ItemType type = model_->GetTypeAt(model_index);
   if (type == ui::MenuModel::TYPE_SUBMENU) {
-    item_data->submenu.reset(new Menu2(model_->GetSubmenuModelAt(model_index)));
+    item_data->submenu.reset(
+        new NativeMenuWin(model_->GetSubmenuModelAt(model_index), NULL));

[tfarina, 2013/04/18 19:01:29]

Mike, I think we need to pass |this| here to avoid the crash.

What you think?

[tfarina, 2013/04/18 21:29:50]

Sorry, I'm wrong, the second parameter of NativeMenuWin is a HWND. This probably
needs to be |system_menu_for_|. Does that sounds right?

     mii.fMask |= MIIM_SUBMENU;
     mii.hSubMenu = item_data->submenu->GetNativeMenu();
     GetNativeMenuWinFromHMENU(mii.hSubMenu)->parent_ = this;
   } else {
     if (type == ui::MenuModel::TYPE_RADIO)
       mii.fType |= MFT_RADIOCHECK;
     mii.wID = model_->GetCommandIdAt(model_index);
   }
   item_data->native_menu_win = this;
   item_data->model_index = model_index;
@@ skipping 67 matching lines @@
   items_[model_index]->label = formatted;
 
   // Give Windows a pointer to the label string.
   mii->fMask |= MIIM_STRING;
   mii->dwTypeData =
       const_cast<wchar_t*>(items_[model_index]->label.c_str());
 }
 
 UINT NativeMenuWin::GetAlignmentFlags(int alignment) const {
   UINT alignment_flags = TPM_TOPALIGN;
-  if (alignment == Menu2::ALIGN_TOPLEFT)
+  if (alignment == ALIGN_TOPLEFT)
     alignment_flags |= TPM_LEFTALIGN;
-  else if (alignment == Menu2::ALIGN_TOPRIGHT)
+  else if (alignment == ALIGN_TOPRIGHT)
     alignment_flags |= TPM_RIGHTALIGN;
   return alignment_flags;
 }
 
 void NativeMenuWin::ResetNativeMenu() {
   if (IsWindow(system_menu_for_)) {
     if (menu_)
       GetSystemMenu(system_menu_for_, TRUE);
     menu_ = GetSystemMenu(system_menu_for_, FALSE);
   } else {
@@ skipping 13 matching lines @@
 }
 
 void NativeMenuWin::CreateHostWindow() {
   // This only gets called from RunMenuAt, and as such there is only ever one
   // host window per menu hierarchy, no matter how many NativeMenuWin objects
   // exist wrapping submenus.
   if (!host_window_.get())
     host_window_.reset(new MenuHostWindow(this));
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// MenuWrapper, public:
-
-// static
-MenuWrapper* MenuWrapper::CreateWrapper(ui::MenuModel* model) {
-  return new NativeMenuWin(model, NULL);
-}
-
 }  // namespace views