Mac[Views]: Make native menus more responsive by pumping private runloop modes.

ui/base/cocoa/menu_controller.mm

 // Copyright 2013 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.
 
 #import "ui/base/cocoa/menu_controller.h"
 
+#include "base/cancelable_callback.h"
 #include "base/logging.h"
+#include "base/mac/bind_objc_block.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/sys_string_conversions.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/accelerators/platform_accelerator_cocoa.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 #include "ui/base/models/simple_menu_model.h"
 #import "ui/events/event_utils.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/text_elider.h"
 
 NSString* const kMenuControllerMenuWillOpenNotification =
     @"MenuControllerMenuWillOpen";
 NSString* const kMenuControllerMenuDidCloseNotification =
     @"MenuControllerMenuDidClose";
 
-@interface MenuController (Private)
-- (void)addSeparatorToMenu:(NSMenu*)menu
-                   atIndex:(int)index;
+// Internal methods.
+@interface MenuController ()
+// Adds a separator item at the given index. As the separator doesn't need
+// anything from the model, this method doesn't need the model index as the
+// other method below does.
+- (void)addSeparatorToMenu:(NSMenu*)menu atIndex:(int)index;
+
+// Called via a private API hook shortly after the event that selects a menu
+// item arrives.
+- (void)itemWillBeSelected:(NSMenuItem*)sender;
+
+// Called when the user chooses a particular menu item. AppKit sends this only
+// after the menu has fully faded out. |sender| is the menu item chosen.
+- (void)itemSelected:(id)sender;
+
+// Called by the posted task to selected an item during menu fade out.
+// |uiEventFlags| are the ui::EventFlags captured from the triggering NSEvent.
+- (void)itemSelected:(id)sender uiEventFlags:(int)uiEventFlags;
 @end
 
-@implementation MenuController
+@interface ResponsiveNSMenuItem : NSMenuItem
+@end
+
+@implementation MenuController {
+  BOOL useWithPopUpButtonCell_;  // If YES, 0th item is blank
+  BOOL isMenuOpen_;
+  BOOL postItemSelectedAsTask_;
+  std::unique_ptr<base::CancelableClosure> postedItemSelectedTask_;
+}
 
 @synthesize model = model_;
 @synthesize useWithPopUpButtonCell = useWithPopUpButtonCell_;
+@synthesize postItemSelectedAsTask = postItemSelectedAsTask_;
 
 + (base::string16)elideMenuTitle:(const base::string16&)title
                          toWidth:(int)width {
   NSFont* nsfont = [NSFont menuBarFontOfSize:0];  // 0 means "default"
   return gfx::ElideText(title, gfx::FontList(gfx::Font(nsfont)), width,
                         gfx::ELIDE_TAIL);
 }
 
 - (id)init {
   self = [super init];
@@ skipping 22 matching lines @@
 }
 
 - (void)cancel {
   if (isMenuOpen_) {
     [menu_ cancelTracking];
     model_->MenuWillClose();
     isMenuOpen_ = NO;
   }
 }
 
-// Creates a NSMenu from the given model. If the model has submenus, this can
-// be invoked recursively.
 - (NSMenu*)menuFromModel:(ui::MenuModel*)model {
   NSMenu* menu = [[[NSMenu alloc] initWithTitle:@""] autorelease];
 
   const int count = model->GetItemCount();
   for (int index = 0; index < count; index++) {
     if (model->GetTypeAt(index) == ui::MenuModel::TYPE_SEPARATOR)
       [self addSeparatorToMenu:menu atIndex:index];
     else
       [self addItemToMenu:menu atIndex:index fromModel:model];
   }
 
   return menu;
 }
 
 - (int)maxWidthForMenuModel:(ui::MenuModel*)model
                  modelIndex:(int)modelIndex {
   return -1;
 }
 
-// Adds a separator item at the given index. As the separator doesn't need
-// anything from the model, this method doesn't need the model index as the
-// other method below does.
 - (void)addSeparatorToMenu:(NSMenu*)menu
                    atIndex:(int)index {
   NSMenuItem* separator = [NSMenuItem separatorItem];
   [menu insertItem:separator atIndex:index];
 }
 
-// Adds an item or a hierarchical menu to the item at the |index|,
-// associated with the entry in the model identified by |modelIndex|.
 - (void)addItemToMenu:(NSMenu*)menu
               atIndex:(NSInteger)index
             fromModel:(ui::MenuModel*)model {
   base::string16 label16 = model->GetLabelAt(index);
   int maxWidth = [self maxWidthForMenuModel:model modelIndex:index];
   if (maxWidth != -1)
     label16 = [MenuController elideMenuTitle:label16 toWidth:maxWidth];
 
   NSString* label = l10n_util::FixUpWindowsStyleLabel(label16);
-  base::scoped_nsobject<NSMenuItem> item(
-      [[NSMenuItem alloc] initWithTitle:label
-                                 action:@selector(itemSelected:)
-                          keyEquivalent:@""]);
+  base::scoped_nsobject<NSMenuItem> item([[ResponsiveNSMenuItem alloc]
+      initWithTitle:label
+             action:@selector(itemSelected:)
+      keyEquivalent:@""]);
 
   // If the menu item has an icon, set it.
   gfx::Image icon;
   if (model->GetIconAt(index, &icon) && !icon.IsEmpty())
     [item setImage:icon.ToNSImage()];
 
   ui::MenuModel::ItemType type = model->GetTypeAt(index);
   if (type == ui::MenuModel::TYPE_SUBMENU) {
     // Recursively build a submenu from the sub-model at this index.
     [item setTarget:nil];
@@ skipping 20 matching lines @@
       if (platformAccelerator) {
         [item setKeyEquivalent:platformAccelerator->characters()];
         [item setKeyEquivalentModifierMask:
             platformAccelerator->modifier_mask()];
       }
     }
   }
   [menu insertItem:item atIndex:index];
 }
 
-// Called before the menu is to be displayed to update the state (enabled,
-// radio, etc) of each item in the menu. Also will update the title if
-// the item is marked as "dynamic".
 - (BOOL)validateUserInterfaceItem:(id<NSValidatedUserInterfaceItem>)item {
   SEL action = [item action];
   if (action != @selector(itemSelected:))
     return NO;
 
   NSInteger modelIndex = [item tag];
   ui::MenuModel* model =
       static_cast<ui::MenuModel*>(
           [[(id)item representedObject] pointerValue]);
   DCHECK(model);
@@ skipping 21 matching lines @@
       base::scoped_nsobject<NSAttributedString> title(
           [[NSAttributedString alloc] initWithString:[(id)item title]
                                           attributes:attributes]);
       [(id)item setAttributedTitle:title.get()];
     }
     return model->IsEnabledAt(modelIndex);
   }
   return NO;
 }
 
-// Called when the user chooses a particular menu item. |sender| is the menu
-// item chosen.
+- (void)itemWillBeSelected:(NSMenuItem*)sender {
+  if (postItemSelectedAsTask_ && [sender action] == @selector(itemSelected:) &&
+      [[sender target]
+          respondsToSelector:@selector(itemSelected:uiEventFlags:)]) {
+    const int uiEventFlags = ui::EventFlagsFromNative([NSApp currentEvent]);
+    postedItemSelectedTask_ =
+        base::MakeUnique<base::CancelableClosure>(base::BindBlock(^() {

[Robert Sesek, 2017/05/10 13:37:27]

nit: can omit the () and just do |^{|.

[tapted, 2017/05/11 00:24:06]

Done.

+          id target = [sender target];
+          if ([target respondsToSelector:@selector(itemSelected:uiEventFlags:)])
+            [target itemSelected:sender uiEventFlags:uiEventFlags];
+          else
+            NOTREACHED();
+        }));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, postedItemSelectedTask_->callback());
+  }
+}
+
 - (void)itemSelected:(id)sender {
+  if (postedItemSelectedTask_) {
+    if (!postedItemSelectedTask_->IsCancelled())
+      postedItemSelectedTask_->callback().Run();
+    postedItemSelectedTask_.reset();
+  } else {
+    [self itemSelected:sender
+          uiEventFlags:ui::EventFlagsFromNative([NSApp currentEvent])];
+  }
+}
+
+- (void)itemSelected:(id)sender uiEventFlags:(int)uiEventFlags {
   NSInteger modelIndex = [sender tag];
   ui::MenuModel* model =
       static_cast<ui::MenuModel*>(
           [[sender representedObject] pointerValue]);
   DCHECK(model);
-  if (model) {
-    int event_flags = ui::EventFlagsFromNative([NSApp currentEvent]);
-    model->ActivatedAt(modelIndex, event_flags);
-  }
+  if (model)
+    model->ActivatedAt(modelIndex, uiEventFlags);
+
+  // Cancel any posted task, but don't reset it, so that the correct path is
+  // taken in -itemSelected:.
+  if (postedItemSelectedTask_)
+    postedItemSelectedTask_->Cancel();
 }
 
 - (NSMenu*)menu {
   if (!menu_ && model_) {
     menu_.reset([[self menuFromModel:model_] retain]);
     [menu_ setDelegate:self];
     // If this is to be used with a NSPopUpButtonCell, add an item at the 0th
     // position that's empty. Doing it after the menu has been constructed won't
     // complicate creation logic, and since the tags are model indexes, they
     // are unaffected by the extra item.
@@ skipping 22 matching lines @@
   if (isMenuOpen_) {
     model_->MenuWillClose();
     isMenuOpen_ = NO;
   }
   [[NSNotificationCenter defaultCenter]
       postNotificationName:kMenuControllerMenuDidCloseNotification
                     object:self];
 }
 
 @end
+
+@interface NSMenuItem (Private)
+// Private method which is invoked very soon after the event that activates a
+// menu item is received. AppKit then spends 300ms or so flashing the menu item,
+// and fading out the menu, in private run loop modes.
+- (void)_sendItemSelectedNote;
+@end
+
+@implementation ResponsiveNSMenuItem
+- (void)_sendItemSelectedNote {
+  if ([[self target] respondsToSelector:@selector(itemWillBeSelected:)])
+    [[self target] itemWillBeSelected:self];
+  [super _sendItemSelectedNote];
+}
+@end