MacViews: Implement Tab Dragging

ui/base/test/ui_controls_mac.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.
 
 #include "ui/base/test/ui_controls.h"
 
 #import <Cocoa/Cocoa.h>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
+#import "base/mac/foundation_util.h"
+#import "base/mac/scoped_nsobject.h"
+#import "base/mac/scoped_objc_class_swizzler.h"
 #include "base/message_loop/message_loop.h"
+#include "base/thread_task_runner_handle.h"
+#include "content/public/browser/browser_thread.h"
 #include "ui/base/cocoa/cocoa_base_utils.h"
 #include "ui/events/keycodes/keyboard_code_conversion_mac.h"
 #import "ui/events/test/cocoa_test_event_utils.h"
+#import "ui/gfx/mac/coordinate_conversion.h"
+#include "ui/gfx/screen.h"
 
 // Implementation details: We use [NSApplication sendEvent:] instead
 // of [NSApplication postEvent:atStart:] so that the event gets sent
 // immediately.  This lets us run the post-event task right
 // immediately as well.  Unfortunately I cannot subclass NSEvent (it's
 // probably a class cluster) to allow other easy answers.  For
 // example, if I could subclass NSEvent, I could run the Task in it's
 // dealloc routine (which necessarily happens after the event is
 // dispatched).  Unlike Linux, Mac does not have message loop
 // observer/notification.  Unlike windows, I cannot post non-events
@@ skipping 15 matching lines @@
 //    events causes BrowserKeyEventsTest.CommandKeyEvents to fail.
 //    See http://crbug.com/49270
 // 2. On OSX 10.6, [NSEvent addLocalMonitorForEventsMatchingMask:handler:] may
 //    be used, so that we don't need to poll the event queue time to time.
 
 using cocoa_test_event_utils::SynthesizeKeyEvent;
 using cocoa_test_event_utils::TimeIntervalSinceSystemStartup;
 
 namespace {
 
+// When enabled, all simulated mouse events will be posted to
+// the WindowServer, and the actual mouse will move on the screen.
+bool g_use_cgevents = false;
+
 // Stores the current mouse location on the screen. So that we can use it
 // when firing keyboard and mouse click events.
 NSPoint g_mouse_location = { 0, 0 };
 
+// Stores the current pressed mouse buttons. Indexed by
+// ui_controls::MouseButton.
+bool g_mouse_button_down[3] = { false, false, false };
+
 bool g_ui_controls_enabled = false;
 
 // Creates the proper sequence of autoreleased key events for a key down + up.
 void SynthesizeKeyEventsSequence(NSWindow* window,
                                  ui::KeyboardCode keycode,
                                  bool control,
                                  bool shift,
                                  bool alt,
                                  bool command,
                                  std::vector<NSEvent*>* events) {
@@ skipping 50 matching lines @@
     events->push_back(event);
   }
   if (control) {
     flags &= ~NSControlKeyMask;
     event = SynthesizeKeyEvent(window, false, ui::VKEY_CONTROL, flags);
     DCHECK(event);
     events->push_back(event);
   }
 }
 
+void RunTaskInTaskRunner(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+    const base::Closure& task) {
+  task_runner->PostTask(FROM_HERE, task);
+}
+
 // A helper function to watch for the event queue. The specific task will be
 // fired when there is no more event in the queue.
+// NOTE: It should be run on the UI thread, as otherwise it will always report
+// there are no pending events.
 void EventQueueWatcher(const base::Closure& task) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   NSEvent* event = [NSApp nextEventMatchingMask:NSAnyEventMask
                                       untilDate:nil
                                          inMode:NSDefaultRunLoopMode
                                         dequeue:NO];
   // If there is still event in the queue, then we need to check again.
   if (event) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&EventQueueWatcher, task));
   } else {
@@ skipping 28 matching lines @@
       return window;
   }
 
   // Note that -[NSApplication orderedWindows] won't include NSPanels. If a test
   // uses those, it will need to handle that itself.
   return nil;
 }
 
 }  // namespace
 
+// Since CGEvents take some time to reach -[NSApplication sendEvent:] we use
+// this class to wait for the events to start being processed before sending
+// finish notifications.
+class EventMonitor {
+ public:
+  void NotifyWhenEventIsProcessed(NSEvent* event, const base::Closure& task) {
+    if (g_use_cgevents) {
+      CHECK([[NSApplication sharedApplication] isActive])
+          << "If we generate CGEvents and the application is not active, we'll "
+             "deadlock waiting for NSMouseMoved events. Use "
+             "ui_test_utils::BringBrowserWindowToFront() to activate the "
+             "browser window prior to generating CGEvents.";
+    }
+
+    dispatch_sync(queue_, ^{
+      tasks_.emplace_back(Task(event, task));
+    });
+  }
+
+  void ProcessingEvent(NSEvent* event) {
+    dispatch_sync(queue_, ^{
+      auto it = std::find_if(
+          tasks_.begin(), tasks_.end(),
+          [&event](const Task& task) { return task.MatchesEvent(event); });
+      if (it != tasks_.end()) {
+        it->Run();
+        tasks_.erase(it);
+      }
+    });
+  }
+
+  static EventMonitor* Instance() {
+    static EventMonitor* monitor = nullptr;
+    if (!monitor) {
+      monitor = new EventMonitor();
+    }
+    return monitor;
+  }
+
+ private:
+  class Task {
+   public:
+    Task(NSEvent* event, const base::Closure& task)
+        : task_runner_(base::ThreadTaskRunnerHandle::Get()),
+          event_([event retain]),
+          finish_closure_(task) {}
+
+    bool MatchesEvent(NSEvent* event) const {
+      // When moving the window using BridgedNativeWidget::RunMoveLoop the
+      // locationInWindow can be a little inconsistent with what we expect.
+      // Seems that only comparing event type is fine.
+      return
+          [event_ type] == [event type] && [event_ subtype] == [event subtype];
+    }
+
+    void Run() {
+      // We get here before the event is actually processed. Run the
+      // EventQueueWatcher on the main thread in order to wait for all events to
+      // finish processing.
+      content::BrowserThread::PostTask(

[tapted, 2016/03/11 09:38:28]

Can you just post to task_runner_?

(sorry - I've still only had time to skim this file)

[themblsha, 2016/04/05 17:20:42]

task_runner_ is used here to notify the original requester, which could be on a
background thread (that's what the DragAndDrop functions do). We can't simply
wait using EventQueueWatcher from the start, because with CGEvents they're
posted asynchronously and we have to wait for them to start, and that's what the
EventMonitor class is for.

[tapted, 2016/04/06 09:38:51]

Ah, this was my plan for removing the browser_thread dependency -- it would be a
tough proposition to OWNERS to allow that DEPS change -- src/ui shouldn't depend
on src/content since it will make a dependency loop. I think we will need to
pass in a task runner for the UI thread at an appropriate place and store it on
a data member.

It might be enough simply to grab it from MessageLoop::current()->task_runner(),
but that might need an explicit Init() call rather than relying on lazy
initialization in instance()

+          content::BrowserThread::UI, FROM_HERE,
+          base::Bind(
+              &EventQueueWatcher,
+              base::Bind(&RunTaskInTaskRunner, task_runner_, finish_closure_)));
+    }
+
+   private:
+    // Events could be spawned on background threads. Be sure to invoke the
+    // |finish_closure_| on an appropriate thread.
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+    base::scoped_nsobject<NSEvent> event_;
+    base::Closure finish_closure_;
+  };
+
+  EventMonitor()
+      : queue_(dispatch_queue_create("ui_controls_mac.EventMonitor",
+                                     DISPATCH_QUEUE_SERIAL)),
+        send_event_swizzler_(
+            new base::mac::ScopedObjCClassSwizzler([NSApplication class],
+                                                   @selector(sendEvent:),
+                                                   @selector(cr_sendEvent:))) {
+  }
+
+  std::vector<Task> tasks_;
+
+  // synchronizes access to the |tasks_| in case we spawn the events on a
+  // different thread
+  dispatch_queue_t queue_ = 0;
+
+  scoped_ptr<base::mac::ScopedObjCClassSwizzler>
+      send_event_swizzler_;
+
+  DISALLOW_COPY_AND_ASSIGN(EventMonitor);
+};
+
+// Donates testing implementations of NSApplication methods. We can't simply
+// use -[NSEvent addLocalMonitorForEventsMatchingMask:handler:], as other event
+// monitors could have precedence, and they could filter the events before we
+// can see them. But since nobody swizzles -[NSApplication sendEvent:] we should
+// be safe.
+@interface NSApplication(TestingDonor)
+@end
+
+@implementation NSApplication(TestingDonor)
+- (void)cr_sendEvent:(NSEvent*)event {
+  // Invoke the finish handler before the event is processed, since we can get
+  // stuck in BridgedNativeWidget::RunMoveLoop and would never see the event
+  // otherwise.
+  EventMonitor::Instance()->ProcessingEvent(event);
+
+  [self cr_sendEvent:event];
+}
+@end
+
+// Donates testing implementations of NSEvent methods.
+@interface FakeNSEventTestingDonor : NSObject
+@end
+
+@implementation FakeNSEventTestingDonor
++ (NSPoint)mouseLocation {
+  return g_mouse_location;
+}
+
++ (NSUInteger)pressedMouseButtons {
+  NSUInteger result = 0;
+  const int buttons[3] = {
+      ui_controls::LEFT, ui_controls::RIGHT, ui_controls::MIDDLE};
+  for (unsigned int i = 0; i < arraysize(buttons); ++i) {
+    if (g_mouse_button_down[buttons[i]])
+      result |= (1 << i);
+  }
+  return result;
+}
+@end
+
+// Donates testing implementations of NSWindow methods.
+@interface FakeNSWindowTestingDonor : NSObject
+@end
+
+@implementation FakeNSWindowTestingDonor
+- (NSPoint)mouseLocationOutsideOfEventStream {
+  NSWindow* window = base::mac::ObjCCastStrict<NSWindow>(self);
+  return [window convertScreenToBase:g_mouse_location];
+}
+@end
+
+namespace {
+class NSEventSwizzler {
+ public:
+  static void Install() {
+    static NSEventSwizzler* swizzler = nullptr;
+    if (!swizzler) {
+      swizzler = new NSEventSwizzler();
+    }
+  }
+
+ protected:
+  NSEventSwizzler()
+      : mouse_location_swizzler_(new base::mac::ScopedObjCClassSwizzler(
+            [NSEvent class],
+            [FakeNSEventTestingDonor class],
+            @selector(mouseLocation))),
+        pressed_mouse_buttons_swizzler_(new base::mac::ScopedObjCClassSwizzler(
+            [NSEvent class],
+            [FakeNSEventTestingDonor class],
+            @selector(pressedMouseButtons))),
+        mouse_location_outside_of_event_stream_swizzler_(
+            new base::mac::ScopedObjCClassSwizzler(
+                [NSWindow class],
+                [FakeNSWindowTestingDonor class],
+                @selector(mouseLocationOutsideOfEventStream))) {}
+
+ private:
+  scoped_ptr<base::mac::ScopedObjCClassSwizzler> mouse_location_swizzler_;
+  scoped_ptr<base::mac::ScopedObjCClassSwizzler>
+      pressed_mouse_buttons_swizzler_;
+  scoped_ptr<base::mac::ScopedObjCClassSwizzler>
+      mouse_location_outside_of_event_stream_swizzler_;
+};
+}  // namespace
+
 namespace ui_controls {
 
 void EnableUIControls() {
   g_ui_controls_enabled = true;
 }
 
 bool SendKeyPress(gfx::NativeWindow window,
                   ui::KeyboardCode key,
                   bool control,
                   bool shift,
                   bool alt,
                   bool command) {
   CHECK(g_ui_controls_enabled);
   return SendKeyPressNotifyWhenDone(window, key,
                                     control, shift, alt, command,
                                     base::Closure());
 }
 
 // Win and Linux implement a SendKeyPress() this as a
 // SendKeyPressAndRelease(), so we should as well (despite the name).
 bool SendKeyPressNotifyWhenDone(gfx::NativeWindow window,
                                 ui::KeyboardCode key,
                                 bool control,
                                 bool shift,
                                 bool alt,
                                 bool command,
                                 const base::Closure& task) {
+  DCHECK(!g_use_cgevents) << "Not implemented";
   CHECK(g_ui_controls_enabled);
   DCHECK(base::MessageLoopForUI::IsCurrent());
 
   std::vector<NSEvent*> events;
   SynthesizeKeyEventsSequence(
       window, key, control, shift, alt, command, &events);
 
   // TODO(suzhe): Using [NSApplication postEvent:atStart:] here causes
   // BrowserKeyEventsTest.CommandKeyEvents to fail. See http://crbug.com/49270
   // But using [NSApplication sendEvent:] should be safe for keyboard events,
@@ skipping 15 matching lines @@
   CHECK(g_ui_controls_enabled);
   return SendMouseMoveNotifyWhenDone(x, y, base::Closure());
 }
 
 // Input position is in screen coordinates.  However, NSMouseMoved
 // events require them window-relative, so we adjust.  We *DO* flip
 // the coordinate space, so input events can be the same for all
 // platforms.  E.g. (0,0) is upper-left.
 bool SendMouseMoveNotifyWhenDone(long x, long y, const base::Closure& task) {
   CHECK(g_ui_controls_enabled);
-  CGFloat screenHeight =
-    [[[NSScreen screens] firstObject] frame].size.height;
-  g_mouse_location = NSMakePoint(x, screenHeight - y);  // flip!
+  g_mouse_location = gfx::ScreenPointToNSPoint(gfx::Point(x, y));  // flip!
+  NSEventSwizzler::Install();
 
   NSWindow* window = WindowAtCurrentMouseLocation();
 
   NSPoint pointInWindow = g_mouse_location;
   if (window)
     pointInWindow = ui::ConvertPointFromScreenToWindow(window, pointInWindow);
   NSTimeInterval timestamp = TimeIntervalSinceSystemStartup();
 
+  NSEventType event_type = NSMouseMoved;
+  if (g_mouse_button_down[LEFT]) {
+    event_type = NSLeftMouseDragged;
+  } else if (g_mouse_button_down[RIGHT]) {
+    event_type = NSRightMouseDragged;
+  } else if (g_mouse_button_down[MIDDLE]) {
+    event_type = NSOtherMouseDragged;
+  }
+
   NSEvent* event =
-      [NSEvent mouseEventWithType:NSMouseMoved
+      [NSEvent mouseEventWithType:event_type
                          location:pointInWindow
                     modifierFlags:0
                         timestamp:timestamp
                      windowNumber:[window windowNumber]
                           context:nil
                       eventNumber:0
-                       clickCount:0
-                         pressure:0.0];
-  [[NSApplication sharedApplication] postEvent:event atStart:NO];
+                       clickCount:(event_type == NSMouseMoved ? 0 : 1)
+                         pressure:(event_type == NSMouseMoved ? 0.0 : 1.0)];
 
   if (!task.is_null()) {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&EventQueueWatcher, task));
+    EventMonitor::Instance()->NotifyWhenEventIsProcessed(event, task);
+  }
+
+  gfx::Point gp = gfx::ScreenPointFromNSPoint(g_mouse_location);
+  CGWarpMouseCursorPosition(CGPointMake(gp.x(), gp.y()));
+
+  if (g_use_cgevents) {
+    CGEventPost(kCGSessionEventTap, [event CGEvent]);
+  } else {
+    [[NSApplication sharedApplication] postEvent:event atStart:NO];
   }
 
   return true;
 }
 
 bool SendMouseEvents(MouseButton type, int state) {
   CHECK(g_ui_controls_enabled);
   return SendMouseEventsNotifyWhenDone(type, state, base::Closure());
 }
 
 bool SendMouseEventsNotifyWhenDone(MouseButton type, int state,
                                    const base::Closure& task) {
   CHECK(g_ui_controls_enabled);
   // On windows it appears state can be (UP|DOWN).  It is unclear if
   // that'll happen here but prepare for it just in case.
   if (state == (UP|DOWN)) {
     return (SendMouseEventsNotifyWhenDone(type, DOWN, base::Closure()) &&
             SendMouseEventsNotifyWhenDone(type, UP, task));
   }
-  NSEventType etype = NSLeftMouseDown;
+  NSEventType event_type = NSLeftMouseDown;
   if (type == LEFT) {
     if (state == UP) {
-      etype = NSLeftMouseUp;
+      event_type = NSLeftMouseUp;
     } else {
-      etype = NSLeftMouseDown;
+      event_type = NSLeftMouseDown;
     }
   } else if (type == MIDDLE) {
     if (state == UP) {
-      etype = NSOtherMouseUp;
+      event_type = NSOtherMouseUp;
     } else {
-      etype = NSOtherMouseDown;
+      event_type = NSOtherMouseDown;
     }
   } else if (type == RIGHT) {
     if (state == UP) {
-      etype = NSRightMouseUp;
+      event_type = NSRightMouseUp;
     } else {
-      etype = NSRightMouseDown;
+      event_type = NSRightMouseDown;
     }
   } else {
+    NOTREACHED();
     return false;
   }
+  g_mouse_button_down[type] = state == DOWN;
+
   NSWindow* window = WindowAtCurrentMouseLocation();
   NSPoint pointInWindow = g_mouse_location;
   if (window)
     pointInWindow = ui::ConvertPointFromScreenToWindow(window, pointInWindow);
 
+  NSEventSwizzler::Install();
+
   NSEvent* event =
-      [NSEvent mouseEventWithType:etype
+      [NSEvent mouseEventWithType:event_type
                          location:pointInWindow
                     modifierFlags:0
                         timestamp:TimeIntervalSinceSystemStartup()
                      windowNumber:[window windowNumber]
                           context:nil
                       eventNumber:0
                        clickCount:1
                          pressure:(state == DOWN ? 1.0 : 0.0 )];
-  [[NSApplication sharedApplication] postEvent:event atStart:NO];
 
   if (!task.is_null()) {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE, base::Bind(&EventQueueWatcher, task));
+    EventMonitor::Instance()->NotifyWhenEventIsProcessed(event, task);
+  }
+
+  if (g_use_cgevents) {
+    CGEventPost(kCGSessionEventTap, [event CGEvent]);
+  } else {
+    [[NSApplication sharedApplication] postEvent:event atStart:NO];
   }
 
   return true;
 }
 
 bool SendMouseClick(MouseButton type) {
   CHECK(g_ui_controls_enabled);
   return SendMouseEventsNotifyWhenDone(type, UP|DOWN, base::Closure());
 }
 
 void RunClosureAfterAllPendingUIEvents(const base::Closure& closure) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&EventQueueWatcher, closure));
 }
 
 bool IsFullKeyboardAccessEnabled() {
   return [NSApp isFullKeyboardAccessEnabled];
 }
 
+void SetSendMouseEventsAsCGEvents(bool enable_cgevents) {
+  g_use_cgevents = enable_cgevents;
+}
+
+bool SendMouseEventsAsCGEvents() {
+  return g_use_cgevents;
+}
+
+void NotifyWhenEventIsProcessed(NSEvent* event, const base::Closure& task) {
+  EventMonitor::Instance()->NotifyWhenEventIsProcessed(event, task);
+}
+
 }  // namespace ui_controls