Fix processing of mouse events on MacViews.

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>
 #include <stddef.h>
 
 #import "base/mac/scoped_nsobject.h"
 #import "base/mac/scoped_objc_class_swizzler.h"
 #include "base/macros.h"
@@ skipping 154 matching lines @@
       break;
     case NSMouseMoved:
       // Assumes [NSWindow acceptsMouseMovedEvents] would return YES, and that
       // NSTrackingAreas have been appropriately installed on |responder|.
       [responder mouseMoved:event];
       break;
     case NSScrollWheel:
       [responder scrollWheel:event];
       break;
     case NSMouseEntered:
+      [responder mouseEntered:event];

[tapted, 2016/10/26 00:57:00]

EventGenerator is for cross-platform testing of views::Views. If you need to
send mouseEntered/Exited, you should use cocoa_test_event_utils 

[snake, 2016/10/26 12:44:56]

Yes, this needs for testing MouseEnter/Exit evenet in views::Views, not just in
RootView.

For example, views::Widget are processing MouseExitEvent.
https://cs.chromium.org/chromium/src/ui/views/widget/widget.cc?rcl=0&l=1238

+      break;
     case NSMouseExited:
-      // With the assumptions in NSMouseMoved, it doesn't make sense for the
-      // generator to handle entered/exited separately. It's the responsibility
-      // of views::internal::RootView to convert the moved events into entered
-      // and exited events for the individual views.
-      NOTREACHED();
+      [responder mouseExited:event];
       break;
     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();
   }
 }
 
 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);
-  return [NSEvent mouseEventWithType:type
-                            location:point
-                       modifierFlags:modifiers
-                           timestamp:0
-                        windowNumber:[window windowNumber]
-                             context:nil
-                         eventNumber:0
-                          clickCount:click_count
-                            pressure:1.0];
+  if (type == NSMouseEntered || type == NSMouseExited) {
+    return [NSEvent enterExitEventWithType:type
+                                  location:point
+                             modifierFlags:modifiers
+                                 timestamp:0
+                              windowNumber:[window windowNumber]
+                                   context:nil
+                               eventNumber:0
+                            trackingNumber:0
+                                  userData:nil];
+  } else {
+    return [NSEvent mouseEventWithType:type
+                              location:point
+                         modifierFlags:modifiers
+                             timestamp:0
+                          windowNumber:[window windowNumber]
+                               context:nil
+                           eventNumber:0
+                            clickCount:click_count
+                              pressure:1.0];
+  }
+}
+
+NSEvent* CreateMouseWheelEventInWindow(NSWindow* window,
+                                       ui::MouseEvent* mouse_event) {
+  DCHECK(mouse_event->type() == ui::ET_MOUSEWHEEL);
+  ui::MouseWheelEvent* mouse_wheel_event =
+      static_cast<ui::MouseWheelEvent*>(mouse_event);
+  return cocoa_test_event_utils::TestScrollEvent(
+      ConvertRootPointToTarget(window, mouse_wheel_event->location()), window,
+      mouse_wheel_event->x_offset(), mouse_wheel_event->y_offset(), false,
+      NSEventPhaseNone, NSEventPhaseNone);
 }
 
 // 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::EventHandler,
                                   public ui::EventProcessor,
                                   public ui::EventTargeter,
@@ skipping 114 matching lines @@
   ui::test::EventGenerator::default_delegate = nullptr;
 }
 
 std::unique_ptr<ui::EventTargetIterator>
 EventGeneratorDelegateMac::GetChildIterator() const {
   // Return nullptr to dispatch all events to the result of GetRootTarget().
   return nullptr;
 }
 
 void EventGeneratorDelegateMac::OnMouseEvent(ui::MouseEvent* event) {
-  NSEvent* ns_event = CreateMouseEventInWindow(window_,
-                                               event->type(),
-                                               event->location(),
-                                               event->changed_button_flags());
+  NSEvent* ns_event =
+      event->type() == ui::ET_MOUSEWHEEL
+          ? CreateMouseWheelEventInWindow(window_, 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::OnKeyEvent(ui::KeyEvent* event) {
   NSUInteger modifiers = EventFlagsToModifiers(event->flags());
   NSEvent* ns_event = cocoa_test_event_utils::SynthesizeKeyEvent(
       window_, event->type() == ui::ET_KEY_PRESSED, event->key_code(),
@@ skipping 125 matching lines @@
 - (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