MacViews: Reveal scrollbars when resting on the trackpad.

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 241 matching lines @@
   // Overridden from ui::EventTarget:
   bool CanAcceptEvent(const ui::Event& event) override { return true; }
   ui::EventTarget* GetParentTarget() override { return nullptr; }
   std::unique_ptr<ui::EventTargetIterator> GetChildIterator() const override;
   ui::EventTargeter* GetEventTargeter() override { return this; }
 
   // Overridden from ui::EventHandler:
   void OnMouseEvent(ui::MouseEvent* event) override;
   void OnKeyEvent(ui::KeyEvent* event) override;
   void OnTouchEvent(ui::TouchEvent* event) override;
+  void OnScrollEvent(ui::ScrollEvent* event) override;
 
   // Overridden from ui::EventSource:
   ui::EventProcessor* GetEventProcessor() override { return this; }
 
   // Overridden from ui::EventProcessor:
   ui::EventTarget* GetRootTarget() override { return this; }
 
   // Overridden from ui::EventDispatcherDelegate (via ui::EventProcessor):
   bool CanDispatchToTarget(EventTarget* target) override { return true; }
 
@@ skipping 39 matching lines @@
   EventGeneratorDelegateMac();
   ~EventGeneratorDelegateMac() override;
 
   ui::test::EventGenerator* owner_;
   base::scoped_nsobject<NSWindow> window_;
   std::unique_ptr<base::mac::ScopedObjCClassSwizzler> swizzle_pressed_;
   std::unique_ptr<base::mac::ScopedObjCClassSwizzler> swizzle_location_;
   std::unique_ptr<base::mac::ScopedObjCClassSwizzler> swizzle_current_event_;
   base::scoped_nsobject<NSMenu> fake_menu_;
 
+  // Mac always sends trackpad scroll events between begin/end phase event
+  // markers. If |in_trackpad_scroll| is false, a phase begin event is sent
+  // before any trackpad scroll update.
+  bool in_trackpad_scroll = false;
+
+  // Timestamp on the last scroll update, used to simulate scroll momentum.
+  base::TimeTicks last_scroll_timestamp_;
+
   DISALLOW_COPY_AND_ASSIGN(EventGeneratorDelegateMac);
 };
 
 EventGeneratorDelegateMac::EventGeneratorDelegateMac() : owner_(nullptr) {
   DCHECK(!ui::test::EventGenerator::default_delegate);
   ui::test::EventGenerator::default_delegate = this;
   SetTargetHandler(this);
   // Install a fake "edit" menu. This is normally provided by Chrome's
   // MainMenu.xib, but src/ui shouldn't depend on that.
   fake_menu_.reset([[NSMenu alloc] initWithTitle:@"Edit"]);
@@ skipping 54 matching lines @@
   if ([fake_menu_ performKeyEquivalent:ns_event])
     return;
 
   EmulateSendEvent(window_, ns_event);
 }
 
 void EventGeneratorDelegateMac::OnTouchEvent(ui::TouchEvent* event) {
   NOTREACHED() << "Touchscreen events not supported on Chrome Mac.";
 }
 
+void EventGeneratorDelegateMac::OnScrollEvent(ui::ScrollEvent* event) {
+  // Ignore FLING_CANCEL. Cocoa provides a continuous stream of events during a
+  // fling. For now, this method simulates a momentum stream using a single
+  // update with a momentum phase (plus begin/end phase events), triggered when
+  // the EventGenerator requests a FLING_START.
+  if (event->type() == ui::ET_SCROLL_FLING_CANCEL)
+    return;
+
+  NSPoint location = ConvertRootPointToTarget(window_, event->location());
+
+  // MAY_BEGIN/END comes from the EventGenerator for trackpad rests.
+  if (event->momentum_phase() == ui::EventMomentumPhase::MAY_BEGIN ||
+      event->momentum_phase() == ui::EventMomentumPhase::END) {
+    DCHECK_EQ(0, event->x_offset());
+    DCHECK_EQ(0, event->y_offset());
+    NSEventPhase phase =
+        event->momentum_phase() == ui::EventMomentumPhase::MAY_BEGIN
+            ? NSEventPhaseMayBegin
+            : NSEventPhaseCancelled;
+
+    NSEvent* rest = cocoa_test_event_utils::TestScrollEvent(
+        location, window_, 0, 0, true, phase, NSEventPhaseNone);
+    EmulateSendEvent(window_, rest);
+
+    // Allow the next ScrollSequence to skip the "begin".
+    in_trackpad_scroll = phase == NSEventPhaseMayBegin;
+    return;
+  }
+
+  NSEventPhase event_phase = NSEventPhaseBegan;
+  NSEventPhase momentum_phase = NSEventPhaseNone;
+
+  // Treat FLING_START as the beginning of a momentum phase.
+  if (event->type() == ui::ET_SCROLL_FLING_START) {
+    DCHECK(in_trackpad_scroll);
+    // First end the non-momentum phase.
+    NSEvent* end = cocoa_test_event_utils::TestScrollEvent(
+        location, window_, 0, 0, true, NSEventPhaseEnded, NSEventPhaseNone);
+    EmulateSendEvent(window_, end);
+    in_trackpad_scroll = false;
+
+    // Assume a zero time delta means no fling. Just end the event phase.
+    if (event->time_stamp() == last_scroll_timestamp_)
+      return;
+
+    // Otherwise, switch phases for the "fling".
+    std::swap(event_phase, momentum_phase);
+  }
+
+  // Send a begin for the current event phase, unless it's already in progress.
+  if (!in_trackpad_scroll) {
+    NSEvent* begin = cocoa_test_event_utils::TestScrollEvent(
+        location, window_, 0, 0, true, event_phase, momentum_phase);
+    EmulateSendEvent(window_, begin);
+    in_trackpad_scroll = true;
+  }
+
+  if (event->type() == ui::ET_SCROLL) {
+    NSEvent* update = cocoa_test_event_utils::TestScrollEvent(
+        location, window_, -event->x_offset(), -event->y_offset(), true,
+        NSEventPhaseChanged, NSEventPhaseNone);
+    EmulateSendEvent(window_, update);
+  } else {
+    DCHECK_EQ(event->type(), ui::ET_SCROLL_FLING_START);
+    // Mac generates a stream of events. For the purposes of testing, just
+    // generate one.
+    NSEvent* update = cocoa_test_event_utils::TestScrollEvent(
+        location, window_, -event->x_offset(), -event->y_offset(), true,
+        NSEventPhaseNone, NSEventPhaseChanged);
+    EmulateSendEvent(window_, update);
+
+    // Never leave the momentum part hanging.
+    NSEvent* end = cocoa_test_event_utils::TestScrollEvent(
+        location, window_, 0, 0, true, NSEventPhaseNone, NSEventPhaseEnded);
+    EmulateSendEvent(window_, end);
+    in_trackpad_scroll = false;
+  }
+
+  last_scroll_timestamp_ = event->time_stamp();
+}
+
 void EventGeneratorDelegateMac::SetContext(ui::test::EventGenerator* owner,
                                            gfx::NativeWindow root_window,
                                            gfx::NativeWindow window) {
   // Mac doesn't use a |root_window|. Assume that if a single-argument
   // constructor was used, it should be the actual |window|.
   if (!window)
     window = root_window;
 
   swizzle_pressed_.reset();
   swizzle_location_.reset();
@@ skipping 99 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