MacViews: Implement event monitoring for a specific window (Reland)

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_objc_class_swizzler.h"
 #include "base/memory/singleton.h"
 #include "ui/events/event_processor.h"
 #include "ui/events/event_target.h"
@@ skipping 10 matching lines @@
 }  // 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;
 }
@@ skipping 149 matching lines @@
     case NSEventTypeSwipe:
       // NSEventTypeSwipe events can't be generated using public interfaces on
       // NSEvent, so this will need to be handled at a higher level.
       NOTREACHED();
       break;
     default:
       NOTREACHED();
   }
 }
 
-void DispatchMouseEventInWindow(NSWindow* window,
-                                ui::EventType event_type,
-                                const gfx::Point& point_in_root,
-                                int flags) {
+NSEvent* CreateMouseEventInWindow(NSWindow* window,
+                                  ui::EventType event_type,
+                                  const gfx::Point& point_in_root,
+                                  int flags) {
   NSUInteger click_count = 0;
   if (event_type == ui::ET_MOUSE_PRESSED ||
       event_type == ui::ET_MOUSE_RELEASED) {
     if (flags & ui::EF_IS_TRIPLE_CLICK)
       click_count = 3;
     else if (flags & ui::EF_IS_DOUBLE_CLICK)
       click_count = 2;
     else
       click_count = 1;
   }
   NSPoint point = ConvertRootPointToTarget(window, point_in_root);
   NSUInteger modifiers = 0;
   NSEventType type = EventTypeToNative(event_type, flags, &modifiers);
-  NSEvent* event = [NSEvent mouseEventWithType:type
-                                      location:point
-                                 modifierFlags:modifiers
-                                     timestamp:0
-                                  windowNumber:[window windowNumber]
-                                       context:nil
-                                   eventNumber:0
-                                    clickCount:click_count
-                                      pressure:1.0];
-
-  // Typically events go through NSApplication. For tests, dispatch the event
-  // directly to make things more predicatble.
-  EmulateSendEvent(window, event);
+  return [NSEvent mouseEventWithType:type
+                            location:point
+                       modifierFlags:modifiers
+                           timestamp:0
+                        windowNumber:[window windowNumber]
+                             context:nil
+                         eventNumber:0
+                          clickCount:click_count
+                            pressure:1.0];
 }
 
 // Implementation of ui::test::EventGeneratorDelegate for Mac. Everything
 // defined inline is just a stub. Interesting overrides are defined below the
 // class.
 class EventGeneratorDelegateMac : public ui::EventTarget,
                                   public ui::EventSource,
                                   public ui::EventProcessor,
                                   public ui::EventTargeter,
                                   public ui::test::EventGeneratorDelegate {
@@ skipping 72 matching lines @@
 
 scoped_ptr<ui::EventTargetIterator>
 EventGeneratorDelegateMac::GetChildIterator() const {
   // Return NULL to dispatch all events to the result of GetRootTarget().
   return scoped_ptr<ui::EventTargetIterator>();
 }
 
 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_);
-  DispatchMouseEventInWindow(window_,
-                             event->type(),
-                             event->location(),
-                             event->changed_button_flags());
+  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);
 }
 
 void EventGeneratorDelegateMac::SetContext(ui::test::EventGenerator* owner,
                                            gfx::NativeWindow root_window,
                                            gfx::NativeWindow window) {
   swizzle_pressed_.reset();
   owner_ = owner;
   window_ = window;
   if (owner_) {
     swizzle_pressed_.reset(new base::mac::ScopedObjCClassSwizzler(
@@ skipping 19 matching lines @@
 
 namespace views {
 namespace test {
 
 void InitializeMacEventGeneratorDelegate() {
   EventGeneratorDelegateMac::GetInstance();
 }
 
 }  // namespace test
 }  // namespace views