Allow printing/saving a plugin through right click menu, even if it's in a fr...

views/controls/menu/native_menu_win.cc

 // Copyright (c) 2010 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 "views/controls/menu/native_menu_win.h"
 
 #include "app/l10n_util.h"
 #include "app/l10n_util_win.h"
 #include "app/win/hwnd_util.h"
 #include "base/logging.h"
+#include "base/message_loop.h"
 #include "base/stl_util-inl.h"
+#include "base/task.h"
 #include "gfx/canvas_skia.h"
 #include "gfx/font.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "views/accelerator.h"
 #include "views/controls/menu/menu_2.h"
 
 namespace views {
 
 // The width of an icon, including the pixels between the icon and
@@ skipping 23 matching lines @@
   NativeMenuWin* native_menu_win;
 
   // The index of the item within the menu's model.
   int model_index;
 };
 
 // A window that receives messages from Windows relevant to the native menu
 // structure we have constructed in NativeMenuWin.
 class NativeMenuWin::MenuHostWindow {
  public:
-  MenuHostWindow() {
+  MenuHostWindow(NativeMenuWin* parent)
+      : parent_(parent),
+        ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
     RegisterClass();
     hwnd_ = CreateWindowEx(l10n_util::GetExtendedStyles(), kWindowClassName,
                            L"", 0, 0, 0, 0, 0, HWND_MESSAGE, NULL, NULL, NULL);
     app::win::SetWindowUserData(hwnd_, this);
   }
 
   ~MenuHostWindow() {
     DestroyWindow(hwnd_);
   }
 
@@ skipping 11 matching lines @@
     wcex.cbSize = sizeof(WNDCLASSEX);
     wcex.style = CS_DBLCLKS;
     wcex.lpfnWndProc = &MenuHostWindowProc;
     wcex.hbrBackground = reinterpret_cast<HBRUSH>(COLOR_WINDOW+1);
     wcex.lpszClassName = kWindowClassName;
     ATOM clazz = RegisterClassEx(&wcex);
     DCHECK(clazz);
     registered = true;
   }
 
-  NativeMenuWin* GetNativeMenuWinFromHMENU(HMENU hmenu) const {
-    MENUINFO mi = {0};
-    mi.cbSize = sizeof(mi);
-    mi.fMask = MIM_MENUDATA | MIM_STYLE;
-    GetMenuInfo(hmenu, &mi);
-    return reinterpret_cast<NativeMenuWin*>(mi.dwMenuData);
-  }
-
   // Converts the WPARAM value passed to WM_MENUSELECT into an index
   // corresponding to the menu item that was selected.
   int GetMenuItemIndexFromWPARAM(HMENU menu, WPARAM w_param) const {
     int count = GetMenuItemCount(menu);
     // For normal command menu items, Windows passes a command id as the LOWORD
     // of WPARAM for WM_MENUSELECT. We need to walk forward through the menu
     // items to find an item with a matching ID. Ugh!
     for (int i = 0; i < count; ++i) {
       MENUITEMINFO mii = {0};
       mii.cbSize = sizeof(mii);
       mii.fMask = MIIM_ID;
       GetMenuItemInfo(menu, i, MF_BYPOSITION, &mii);
       if (mii.wID == w_param)
         return i;
     }
     // If we didn't find a matching command ID, this means a submenu has been
     // selected instead, and rather than passing a command ID in
     // LOWORD(w_param), Windows has actually passed us a position, so we just
     // return it.
     return w_param;
   }
 
   NativeMenuWin::ItemData* GetItemData(ULONG_PTR item_data) {
     return reinterpret_cast<NativeMenuWin::ItemData*>(item_data);
   }
 
   // Called when the user selects a specific item.
   void OnMenuCommand(int position, HMENU menu) {
-    NativeMenuWin* intergoat = GetNativeMenuWinFromHMENU(menu);
-    ui::MenuModel* model = intergoat->model_;
-    model->ActivatedAt(position);
+    parent_->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);
     if (position >= 0)
-      GetNativeMenuWinFromHMENU(menu)->model_->HighlightChangedTo(position);
+      parent_->model_->HighlightChangedTo(position);
   }
 
   // Called by Windows to measure the size of an owner-drawn menu item.
   void OnMeasureItem(WPARAM w_param, MEASUREITEMSTRUCT* measure_item_struct) {
     NativeMenuWin::ItemData* data = GetItemData(measure_item_struct->itemData);
     if (data) {
       gfx::Font font;
       measure_item_struct->itemWidth = font.GetStringWidth(data->label) +
           kIconWidth + kItemLeftMargin + kItemRightMargin -
           GetSystemMetrics(SM_CXMENUCHECK);
@@ skipping 89 matching lines @@
       // Draw the separator
       draw_item_struct->rcItem.top +=
           (draw_item_struct->rcItem.bottom - draw_item_struct->rcItem.top) / 3;
       DrawEdge(dc, &draw_item_struct->rcItem, EDGE_ETCHED, BF_TOP);
     }
 
     SetBkColor(dc, prev_bg_color);
     SetTextColor(dc, prev_text_color);
   }
 
+  void OnMenuClosed() {
+    parent_->model_->MenuClosed();
+  }
+
   bool ProcessWindowMessage(HWND window,
                             UINT message,
                             WPARAM w_param,
                             LPARAM l_param,
                             LRESULT* l_result) {
     switch (message) {
       case WM_MENUCOMMAND:
         OnMenuCommand(w_param, reinterpret_cast<HMENU>(l_param));
         *l_result = 0;
         return true;
       case WM_MENUSELECT:
         OnMenuSelect(LOWORD(w_param), reinterpret_cast<HMENU>(l_param));
         *l_result = 0;
         return true;
       case WM_MEASUREITEM:
         OnMeasureItem(w_param, reinterpret_cast<MEASUREITEMSTRUCT*>(l_param));
         *l_result = 0;
         return true;
       case WM_DRAWITEM:
         OnDrawItem(w_param, reinterpret_cast<DRAWITEMSTRUCT*>(l_param));
         *l_result = 0;
         return true;
+      case WM_EXITMENULOOP:
+        // WM_MENUCOMMAND comes after this message, but still in the same
+        // callstack.  So use PostTask to guarantee that we'll tell the model
+        // that the menus is closed after any other notifications.
+        MessageLoop::current()->PostTask(
+            FROM_HERE,
+            method_factory_.NewRunnableMethod(&MenuHostWindow::OnMenuClosed));
+        return true;
       // TODO(beng): bring over owner draw from old menu system.
     }
     return false;
   }
 
   static LRESULT CALLBACK MenuHostWindowProc(HWND window,
                                              UINT message,
                                              WPARAM w_param,
                                              LPARAM l_param) {
     MenuHostWindow* host =
         reinterpret_cast<MenuHostWindow*>(app::win::GetWindowUserData(window));
     // host is null during initial construction.
     LRESULT l_result = 0;
     if (!host || !host->ProcessWindowMessage(window, message, w_param, l_param,
                                              &l_result)) {
       return DefWindowProc(window, message, w_param, l_param);
     }
     return l_result;
   }
 
   HWND hwnd_;
+  NativeMenuWin* parent_;
+  ScopedRunnableMethodFactory<MenuHostWindow> method_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MenuHostWindow);
 };
 
 // static
 const wchar_t* NativeMenuWin::MenuHostWindow::kWindowClassName =
     L"ViewsMenuHostWindow";
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeMenuWin, public:
@@ skipping 300 matching lines @@
     mi.dwMenuData = reinterpret_cast<ULONG_PTR>(this);
     SetMenuInfo(menu_, &mi);
   }
 }
 
 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());
+    host_window_.reset(new MenuHostWindow(this));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SystemMenuModel:
 
 SystemMenuModel::SystemMenuModel(ui::SimpleMenuModel::Delegate* delegate)
     : SimpleMenuModel(delegate) {
 }
 
 SystemMenuModel::~SystemMenuModel() {
 }
 
 int SystemMenuModel::GetFirstItemIndex(gfx::NativeMenu native_menu) const {
   // We allow insertions before last item (Close).
   return std::max(0, GetMenuItemCount(native_menu) - 1);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // MenuWrapper, public:
 
 // static
 MenuWrapper* MenuWrapper::CreateWrapper(Menu2* menu) {
   return new NativeMenuWin(menu->model(), NULL);
 }
 
 }  // namespace views