MacViews: Handle Tab properly

ui/views/test/event_generator_delegate_mac.mm

 // Copyright 2014 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 <Cocoa/Cocoa.h>
 
 #import "base/mac/scoped_nsobject.h"
 #import "base/mac/scoped_objc_class_swizzler.h"
 #include "base/memory/singleton.h"
 #include "ui/events/event_processor.h"
 #include "ui/events/event_target.h"
 #include "ui/events/event_target_iterator.h"
 #include "ui/events/event_targeter.h"
 #import "ui/events/test/cocoa_test_event_utils.h"
 #include "ui/events/test/event_generator.h"
 #include "ui/gfx/mac/coordinate_conversion.h"
 
 namespace {
 
 // Singleton to provide state for swizzled Objective C methods.
 ui::test::EventGenerator* g_active_generator = NULL;
 
+// Set (and always cleared) in EmulateSendEvent() to provide an answer for
+// [NSApp currentEvent].
+NSEvent* g_current_event = nil;
+
 }  // namespace
 
 @interface NSEventDonor : NSObject
 @end
 
-@implementation NSEventDonor
-
-// Donate +[NSEvent pressedMouseButtons] by retrieving the flags from the
-// active generator.
-+ (NSUInteger)pressedMouseButtons {
-  if (!g_active_generator)
-    return [NSEventDonor pressedMouseButtons];  // Call original implementation.
-
-  int flags = g_active_generator->flags();
-  NSUInteger bitmask = 0;
-  if (flags & ui::EF_LEFT_MOUSE_BUTTON)
-    bitmask |= 1;
-  if (flags & ui::EF_RIGHT_MOUSE_BUTTON)
-    bitmask |= 1 << 1;
-  if (flags & ui::EF_MIDDLE_MOUSE_BUTTON)
-    bitmask |= 1 << 2;
-  return bitmask;
-}
-
+@interface NSApplicationDonor : NSObject
 @end
 
 namespace {
 
 NSPoint ConvertRootPointToTarget(NSWindow* target,
                                  const gfx::Point& point_in_root) {
   // Normally this would do [NSWindow convertScreenToBase:]. However, Cocoa can
   // reposition the window on screen and make things flaky. Initially, just
   // assume that the contentRect of |target| is at the top-left corner of the
   // screen.
@@ skipping 69 matching lines @@
     default:
       NOTREACHED();
       return 0;
   }
 }
 
 // Emulate the dispatching that would be performed by -[NSWindow sendEvent:].
 // sendEvent is a black box which (among other things) will try to peek at the
 // event queue and can block indefinitely.
 void EmulateSendEvent(NSWindow* window, NSEvent* event) {
+  base::AutoReset<NSEvent*> reset(&g_current_event, event);
   NSResponder* responder = [window firstResponder];
   switch ([event type]) {
     case NSKeyDown:
       [responder keyDown:event];
       return;
     case NSKeyUp:
       [responder keyUp:event];
       return;
   }
 
@@ skipping 90 matching lines @@
 class EventGeneratorDelegateMac : public ui::EventTarget,
                                   public ui::EventSource,
                                   public ui::EventProcessor,
                                   public ui::EventTargeter,
                                   public ui::test::EventGeneratorDelegate {
  public:
   static EventGeneratorDelegateMac* GetInstance() {
     return Singleton<EventGeneratorDelegateMac>::get();
   }
 
+  IMP CurrentEventMethod() {
+    return swizzle_current_event_->GetOriginalImplementation();
+  }
+
   // Overridden from ui::EventTarget:
   bool CanAcceptEvent(const ui::Event& event) override { return true; }
   ui::EventTarget* GetParentTarget() override { return NULL; }
   scoped_ptr<ui::EventTargetIterator> GetChildIterator() const override;
   ui::EventTargeter* GetEventTargeter() override { return this; }
 
   // Overridden from ui::EventHandler (via ui::EventTarget):
   void OnMouseEvent(ui::MouseEvent* event) override;
   void OnKeyEvent(ui::KeyEvent* event) override;
 
@@ skipping 28 matching lines @@
 
  private:
   friend struct DefaultSingletonTraits<EventGeneratorDelegateMac>;
 
   EventGeneratorDelegateMac();
   ~EventGeneratorDelegateMac() override;
 
   ui::test::EventGenerator* owner_;
   NSWindow* window_;
   scoped_ptr<base::mac::ScopedObjCClassSwizzler> swizzle_pressed_;
+  scoped_ptr<base::mac::ScopedObjCClassSwizzler> swizzle_current_event_;
   base::scoped_nsobject<NSMenu> fake_menu_;
 
   DISALLOW_COPY_AND_ASSIGN(EventGeneratorDelegateMac);
 };
 
 EventGeneratorDelegateMac::EventGeneratorDelegateMac()
     : owner_(NULL),
       window_(NULL) {
   DCHECK(!ui::test::EventGenerator::default_delegate);
   ui::test::EventGenerator::default_delegate = this;
@@ skipping 57 matching lines @@
   if ([fake_menu_ performKeyEquivalent:ns_event])
     return;
 
   EmulateSendEvent(window_, ns_event);
 }
 
 void EventGeneratorDelegateMac::SetContext(ui::test::EventGenerator* owner,
                                            gfx::NativeWindow root_window,
                                            gfx::NativeWindow window) {
   swizzle_pressed_.reset();
+  swizzle_current_event_.reset();
   owner_ = owner;
   window_ = window;
 
   // Normally, edit menu items have a `nil` target. This results in -[NSMenu
   // performKeyEquivalent:] relying on -[NSApplication targetForAction:to:from:]
   // to find a target starting at the first responder of the key window. Since
   // non-interactive tests have no key window, that won't work. So set (or
   // clear) the target explicitly on all menu items.
   [[fake_menu_ itemArray] makeObjectsPerformSelector:@selector(setTarget:)
                                           withObject:[window firstResponder]];
 
   if (owner_) {
     swizzle_pressed_.reset(new base::mac::ScopedObjCClassSwizzler(
         [NSEvent class],
         [NSEventDonor class],
         @selector(pressedMouseButtons)));
+    swizzle_current_event_.reset(new base::mac::ScopedObjCClassSwizzler(
+        [NSApplication class],
+        [NSApplicationDonor class],
+        @selector(currentEvent)));
   }
 }
 
 gfx::Point EventGeneratorDelegateMac::CenterOfTarget(
     const ui::EventTarget* target) const {
   DCHECK_EQ(target, this);
   return CenterOfWindow(window_);
 }
 
 gfx::Point EventGeneratorDelegateMac::CenterOfWindow(
     gfx::NativeWindow window) const {
   DCHECK_EQ(window, window_);
   return gfx::ScreenRectFromNSRect([window frame]).CenterPoint();
 }
 
 }  // namespace
 
 namespace views {
 namespace test {
 
 void InitializeMacEventGeneratorDelegate() {
   EventGeneratorDelegateMac::GetInstance();
 }
 
 }  // namespace test
 }  // namespace views
+
+@implementation NSEventDonor
+
+// Donate +[NSEvent pressedMouseButtons] by retrieving the flags from the
+// active generator.
++ (NSUInteger)pressedMouseButtons {
+  if (!g_active_generator)
+    return [NSEventDonor pressedMouseButtons];  // Call original implementation.
+
+  int flags = g_active_generator->flags();
+  NSUInteger bitmask = 0;
+  if (flags & ui::EF_LEFT_MOUSE_BUTTON)
+    bitmask |= 1;
+  if (flags & ui::EF_RIGHT_MOUSE_BUTTON)
+    bitmask |= 1 << 1;
+  if (flags & ui::EF_MIDDLE_MOUSE_BUTTON)
+    bitmask |= 1 << 2;
+  return bitmask;
+}
+
+@end
+
+@implementation NSApplicationDonor
+
+- (NSEvent*)currentEvent {
+  if (g_current_event)
+    return g_current_event;
+
+  // Find the original implementation and invoke it.
+  IMP original = EventGeneratorDelegateMac::GetInstance()->CurrentEventMethod();
+  return original(self, _cmd);
+}
+
+@end