MacViews: Implement Tooltips

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
 
 @interface NSApplicationDonor : NSObject
@@ skipping 194 matching lines @@
                                   public ui::test::EventGeneratorDelegate {
  public:
   static EventGeneratorDelegateMac* GetInstance() {
     return Singleton<EventGeneratorDelegateMac>::get();
   }
 
   IMP CurrentEventMethod() {
     return swizzle_current_event_->GetOriginalImplementation();
   }
 
+  NSWindow* window() { return window_.get(); }
+  ui::test::EventGenerator* owner() { return owner_; }
+
   // 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;
   void OnTouchEvent(ui::TouchEvent* event) override;
@@ skipping 29 matching lines @@
 
  private:
   friend struct DefaultSingletonTraits<EventGeneratorDelegateMac>;
 
   EventGeneratorDelegateMac();
   ~EventGeneratorDelegateMac() override;
 
   ui::test::EventGenerator* owner_;
   base::scoped_nsobject<NSWindow> window_;
   scoped_ptr<base::mac::ScopedObjCClassSwizzler> swizzle_pressed_;
+  scoped_ptr<base::mac::ScopedObjCClassSwizzler> swizzle_location_;
   scoped_ptr<base::mac::ScopedObjCClassSwizzler> swizzle_current_event_;
   base::scoped_nsobject<NSMenu> fake_menu_;
 
   DISALLOW_COPY_AND_ASSIGN(EventGeneratorDelegateMac);
 };
 
 EventGeneratorDelegateMac::EventGeneratorDelegateMac() : owner_(NULL) {
   DCHECK(!ui::test::EventGenerator::default_delegate);
   ui::test::EventGenerator::default_delegate = this;
   // Install a fake "edit" menu. This is normally provided by Chrome's
@@ skipping 24 matching lines @@
   ui::test::EventGenerator::default_delegate = NULL;
 }
 
 scoped_ptr<ui::EventTargetIterator>
 EventGeneratorDelegateMac::GetChildIterator() const {
   // Return NULL to dispatch all events to the result of GetRootTarget().
   return nullptr;
 }
 
 void EventGeneratorDelegateMac::OnMouseEvent(ui::MouseEvent* event) {
-  // For mouse drag events, ensure the swizzled methods return the right flags.
-  base::AutoReset<ui::test::EventGenerator*> reset(&g_active_generator, owner_);
   NSEvent* ns_event = CreateMouseEventInWindow(window_,
                                                event->type(),
                                                event->location(),
                                                event->changed_button_flags());
   if (owner_->targeting_application())
     [NSApp sendEvent:ns_event];
   else
     EmulateSendEvent(window_, ns_event);
 }
 
@@ skipping 14 matching lines @@
 }
 
 void EventGeneratorDelegateMac::OnTouchEvent(ui::TouchEvent* event) {
   NOTREACHED() << "Touchscreen events not supported on Chrome Mac.";
 }
 
 void EventGeneratorDelegateMac::SetContext(ui::test::EventGenerator* owner,
                                            gfx::NativeWindow root_window,
                                            gfx::NativeWindow window) {
   swizzle_pressed_.reset();
+  swizzle_location_.reset();
   swizzle_current_event_.reset();
   owner_ = owner;
 
   // Retain the NSWindow (note it can be nil). This matches Cocoa's tendency to
   // have autoreleased objects, or objects still in the event queue, that
   // reference the NSWindow.
   window_.reset([window retain]);
 
   // 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_location_.reset(new base::mac::ScopedObjCClassSwizzler(
+        [NSEvent class], [NSEventDonor class], @selector(mouseLocation)));
     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();
 }
 
+// Return the current owner of the EventGeneratorDelegate. May be null.
+ui::test::EventGenerator* GetActiveGenerator() {
+  return EventGeneratorDelegateMac::GetInstance()->owner();
+}
+
 }  // 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)
+  ui::test::EventGenerator* generator = GetActiveGenerator();
+  if (!generator)
     return [NSEventDonor pressedMouseButtons];  // Call original implementation.
 
-  int flags = g_active_generator->flags();
+  int flags = 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;
 }
 
+// Donate +[NSEvent mouseLocation] by retrieving the current position on screen.
++ (NSPoint)mouseLocation {
+  ui::test::EventGenerator* generator = GetActiveGenerator();
+  if (!generator)
+    return [NSEventDonor mouseLocation];  // Call original implementation.
+
+  // The location is the point in the root window which, for desktop widgets, is
+  // the widget itself.
+  gfx::Point point_in_root = generator->current_location();
+  NSWindow* window = EventGeneratorDelegateMac::GetInstance()->window();
+  NSPoint point_in_window = ConvertRootPointToTarget(window, point_in_root);
+  return [window convertBaseToScreen:point_in_window];
+}
+
 @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