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/bind.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
+#include "base/memory/weak_ptr.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"
 
+// Internal methods.
+@interface MenuController ()
+
+// 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
+
+namespace {
+
+// Object that calls -[MenuController itemSelected:uiEventFlags:] while a menu
+// is fading out.
+class PostedItemSelectedTask

[Robert Sesek, 2017/05/09 15:49:45]

I think you can replace this class with a base::CancelableCallback. It may be a
little easier to follow, since the base::Bind logic could live in
-itemWillBeSelected: (assuming that scoped_nsobject plays well with Bind).

[tapted, 2017/05/10 03:49:06]

Done (along with base::BindBlock to make the ObjC method call)

+    : public base::SupportsWeakPtr<PostedItemSelectedTask> {
+ public:
+  // On construction, captures the flags from [NSApp currentEvent] and posts a
+  // task to Run() on the current thread's TaskRunner.
+  explicit PostedItemSelectedTask(NSMenuItem* item);
+
+  // Invokes -itemSelected:uiEventFlags: on [item_ target], then clears |item_|
+  // so that later calls to Run() will do nothing.
+  void Run();
+
+ private:
+  base::scoped_nsobject<NSMenuItem> item_;
+  const int ui_event_flags_;
+
+  DISALLOW_COPY_AND_ASSIGN(PostedItemSelectedTask);
+};
+
+}  // namespace
+
 NSString* const kMenuControllerMenuWillOpenNotification =
     @"MenuControllerMenuWillOpen";
 NSString* const kMenuControllerMenuDidCloseNotification =
     @"MenuControllerMenuDidClose";
 
 @interface MenuController (Private)
 - (void)addSeparatorToMenu:(NSMenu*)menu
                    atIndex:(int)index;
 @end
 
-@implementation MenuController
+@interface ResponsiveNSMenuItem : NSMenuItem
+@end
+
+@implementation MenuController {
+  BOOL useWithPopUpButtonCell_;  // If YES, 0th item is blank
+  BOOL isMenuOpen_;
+  BOOL postItemSelectedAsTask_;
+  std::unique_ptr<PostedItemSelectedTask> 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 63 matching lines @@
 // 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 64 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:)]) {
+    postedItemSelectedTask_ = base::MakeUnique<PostedItemSelectedTask>(sender);
+  }
+}
+
 - (void)itemSelected:(id)sender {
+  if (postedItemSelectedTask_) {
+    postedItemSelectedTask_->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);
 }
 
 - (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
+
+namespace {
+
+PostedItemSelectedTask::PostedItemSelectedTask(NSMenuItem* item)
+    : item_(item, base::scoped_policy::RETAIN),
+      ui_event_flags_(ui::EventFlagsFromNative([NSApp currentEvent])) {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&PostedItemSelectedTask::Run, AsWeakPtr()));
+}
+
+void PostedItemSelectedTask::Run() {
+  if (!item_)
+    return;
+
+  id target = [item_ target];
+  if ([target respondsToSelector:@selector(itemSelected:uiEventFlags:)])
+    [target itemSelected:item_.get() uiEventFlags:ui_event_flags_];
+  else
+    NOTREACHED();
+
+  item_.reset();
+}
+
+}  // namespace