Tracing for NSMenu timelines

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/logging.h"
 #include "base/strings/sys_string_conversions.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;
 @end
 
+@interface ResponsiveNSMenuItem : NSMenuItem
+@end
+
 @implementation MenuController
 
 @synthesize model = model_;
 @synthesize useWithPopUpButtonCell = useWithPopUpButtonCell_;
 
 + (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);
@@ skipping 15 matching lines @@
 }
 
 - (void)dealloc {
   [menu_ setDelegate:nil];
 
   // Close the menu if it is still open. This could happen if a tab gets closed
   // while its context menu is still open.
   [self cancel];
 
   model_ = NULL;
+  [[NSNotificationCenter defaultCenter] removeObserver:self];
+
   [super dealloc];
 }
 
 - (void)cancel {
   if (isMenuOpen_) {
     [menu_ cancelTracking];
     model_->MenuWillClose();
     isMenuOpen_ = NO;
   }
 }
@@ skipping 32 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:(id)sender {
+  suppressNextItemSelected_ = [self processItemSelectedEarly:sender];
+}
+
+- (BOOL)processItemSelectedEarly:(id)sender {
+  return NO;
+}
+
 - (void)itemSelected:(id)sender {
+  DLOG(INFO) << "got action";
+  if (suppressNextItemSelected_)
+    return;
+
   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);
   }
 }
@@ skipping 14 matching lines @@
   }
   return menu_.get();
 }
 
 - (BOOL)isMenuOpen {
   return isMenuOpen_;
 }
 
 - (void)menuWillOpen:(NSMenu*)menu {
   isMenuOpen_ = YES;
+  suppressNextItemSelected_ = NO;
   model_->MenuWillShow();
   [[NSNotificationCenter defaultCenter]
       postNotificationName:kMenuControllerMenuWillOpenNotification
                     object:self];
+  [[NSNotificationCenter defaultCenter]
+      addObserver:self
+         selector:@selector(willSendAction:)
+             name:NSMenuWillSendActionNotification
+           object:nil];
 }
 
 - (void)menuDidClose:(NSMenu*)menu {
+  DLOG(INFO) << "did close";
   if (isMenuOpen_) {
     model_->MenuWillClose();
     isMenuOpen_ = NO;
   }
   [[NSNotificationCenter defaultCenter]
       postNotificationName:kMenuControllerMenuDidCloseNotification
                     object:self];
 }
 
+- (void)willSendAction:(NSNotification*)note {
+  DLOG(INFO) << "will send action";
+}
+
 @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, blocking the UI thread the entire time.
+- (void)_sendItemSelectedNote;
+@end
+
+@implementation ResponsiveNSMenuItem
+- (void)_sendItemSelectedNote {
+  DLOG(INFO) << "early";
+  if ([[self target] respondsToSelector:@selector(itemWillBeSelected:)])
+    [[self target] itemWillBeSelected:self];
+  [super _sendItemSelectedNote];
+}
+@end