blob: a7d38a609be0926539f74fad31236dd45cca69cb [file] [log] [blame]
// 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.
#include <Cocoa/Cocoa.h>
#include "base/files/file_path.h"
#include "base/logging.h"
#include "base/mac/scoped_nsobject.h"
#import "base/mac/sdk_forward_declarations.h"
#include "base/message_loop/message_loop.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/tabs/tab_strip_model.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "chrome/test/base/ui_test_utils.h"
#include "content/public/browser/render_view_host.h"
#include "content/public/browser/render_widget_host_view.h"
#include "content/public/browser/web_contents.h"
#include "content/public/test/browser_test_utils.h"
#import "third_party/ocmock/OCMock/OCMock.h"
#import "third_party/ocmock/ocmock_extensions.h"
#include "url/gurl.h"
namespace {
// Refers to how the event is going to be sent to the NSView. There are 3
// relevant sets of APIs. The current code relies on all three sets of APIs.
// There is significant information duplication between the three sets of APIs,
// but the timing of the callbacks of the three APIs differ significantly.
enum Deployment {
// -[NSView touchesBeganWithEvent:]
DEPLOYMENT_TOUCHES_BEGAN,
// -[NSView touchesMovedWithEvent:]
DEPLOYMENT_TOUCHES_MOVED,
// -[NSView touchesEndedWithEvent:]
DEPLOYMENT_TOUCHES_ENDED,
// -[NSView scrollWheel:]
DEPLOYMENT_SCROLL_WHEEL,
// -[NSView beginGestureWithEvent:]
DEPLOYMENT_GESTURE_BEGIN,
// -[NSView endGestureWithEvent:]
DEPLOYMENT_GESTURE_END,
};
} // namespace
// A wrapper object for events queued for replay.
@interface QueuedEvent : NSObject {
BOOL _runMessageLoop;
Deployment _deployment;
NSEvent* _event;
}
// Whether the message loop should be run after this event has been replayed.
@property(nonatomic, assign) BOOL runMessageLoop;
// How this event should be replayed.
@property(nonatomic, assign) Deployment deployment;
// The event to be replayed.
@property(nonatomic, retain) NSEvent* event;
@end
@implementation QueuedEvent
@synthesize deployment = _deployment;
@synthesize event = _event;
@synthesize runMessageLoop = _runMessageLoop;
- (void)dealloc {
[_event release];
[super dealloc];
}
@end
class ChromeRenderWidgetHostViewMacHistorySwiperTest
: public InProcessBrowserTest {
public:
ChromeRenderWidgetHostViewMacHistorySwiperTest()
: event_queue_(), touch_(CGPointMake(0, 0)) {
const base::FilePath base_path(FILE_PATH_LITERAL("scroll"));
url1_ = ui_test_utils::GetTestUrl(
base_path, base::FilePath(FILE_PATH_LITERAL("text.html")));
url2_ = ui_test_utils::GetTestUrl(
base_path, base::FilePath(FILE_PATH_LITERAL("blank.html")));
url_iframe_ = ui_test_utils::GetTestUrl(
base_path, base::FilePath(FILE_PATH_LITERAL("iframe.html")));
}
virtual void SetUpOnMainThread() OVERRIDE {
event_queue_.reset([[NSMutableArray alloc] init]);
touch_ = CGPointMake(0.5, 0.5);
// Ensure that the navigation stack is not empty.
ui_test_utils::NavigateToURL(browser(), url1_);
ASSERT_EQ(url1_, GetWebContents()->GetURL());
ui_test_utils::NavigateToURL(browser(), url2_);
ASSERT_EQ(url2_, GetWebContents()->GetURL());
}
virtual void TearDownOnMainThread() OVERRIDE {
event_queue_.reset();
}
protected:
// Returns the active web contents.
content::WebContents* GetWebContents() {
return browser()->tab_strip_model()->GetActiveWebContents();
}
// Returns the value of |query| from Javascript as an int.
int GetScriptIntValue(const std::string& query) {
int value = 0;
EXPECT_TRUE(content::ExecuteScriptAndExtractInt(
GetWebContents(),
"domAutomationController.send(" + query + ")",
&value));
return value;
}
// Returns the vertical scroll offset of the current page.
int GetScrollTop() {
return GetScriptIntValue("document.body.scrollTop");
}
bool IsHistorySwipingSupported() {
// These tests require 10.7+ APIs.
return [NSEvent
respondsToSelector:@selector(isSwipeTrackingFromScrollEventsEnabled)];
}
// Create mock events --------------------------------------------------------
// Creates a mock scroll wheel event that is backed by a real CGEvent.
id MockScrollWheelEvent(NSPoint delta, NSEventType type) {
CGEventRef cg_event =
CGEventCreateScrollWheelEvent(NULL, kCGScrollEventUnitLine, 2, 0, 0);
CGEventSetIntegerValueField(cg_event, kCGScrollWheelEventIsContinuous, 1);
CGEventSetIntegerValueField(
cg_event, kCGScrollWheelEventPointDeltaAxis2, delta.x);
CGEventSetIntegerValueField(
cg_event, kCGScrollWheelEventPointDeltaAxis1, delta.y);
NSEvent* event = [NSEvent eventWithCGEvent:cg_event];
CFRelease(cg_event);
id mock_event = [OCMockObject partialMockForObject:event];
[[[mock_event stub] andReturnBool:NO] isDirectionInvertedFromDevice];
[(NSEvent*)[[mock_event stub] andReturnValue:OCMOCK_VALUE(type)] type];
return mock_event;
}
// Returns a scroll wheel event with the given parameters.
id ScrollWheelEventWithPhase(NSEventPhase phase,
NSEventPhase momentum_phase,
CGFloat scrolling_delta_x,
CGFloat scrolling_delta_y) {
id event = MockScrollWheelEvent(
NSMakePoint(scrolling_delta_x, scrolling_delta_y), NSScrollWheel);
[(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(phase)] phase];
[(NSEvent*)[[event stub]
andReturnValue:OCMOCK_VALUE(momentum_phase)] momentumPhase];
[(NSEvent*)[[event stub]
andReturnValue:OCMOCK_VALUE(scrolling_delta_x)] scrollingDeltaX];
[(NSEvent*)[[event stub]
andReturnValue:OCMOCK_VALUE(scrolling_delta_y)] scrollingDeltaY];
NSUInteger modifierFlags = 0;
[(NSEvent*)[[event stub]
andReturnValue:OCMOCK_VALUE(modifierFlags)] modifierFlags];
NSView* view =
GetWebContents()->GetRenderViewHost()->GetView()->GetNativeView();
NSWindow* window = [view window];
[(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(window)] window];
return event;
}
// Queue events for playback -------------------------------------------------
void QueueEvent(id event, Deployment deployment, BOOL run_message_loop) {
QueuedEvent* queued_event = [[[QueuedEvent alloc] init] autorelease];
queued_event.event = event;
queued_event.deployment = deployment;
queued_event.runMessageLoop = run_message_loop;
[event_queue_ addObject:queued_event];
}
// Queues a trackpad scroll event (e.g. [NSView scrollWheel:])
void QueueTrackpadScroll(int dx,
int dy,
NSEventPhase phase,
BOOL run_message_loop) {
id event = ScrollWheelEventWithPhase(phase, NSEventPhaseNone, dx, dy);
QueueEvent(event, DEPLOYMENT_SCROLL_WHEEL, run_message_loop);
}
// Queues a gesture begin event (e.g. [NSView gestureDidBegin:])
void QueueGestureBegin() {
id event = [OCMockObject mockForClass:[NSEvent class]];
NSEventType type = NSEventTypeBeginGesture;
[(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(type)] type];
QueueEvent(event, DEPLOYMENT_GESTURE_BEGIN, NO);
}
// Queues a gesture end event (e.g. [NSView gestureDidEnd:])
void QueueGestureEnd() {
id event = [OCMockObject mockForClass:[NSEvent class]];
NSEventType type = NSEventTypeEndGesture;
[(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(type)] type];
QueueEvent(event, DEPLOYMENT_GESTURE_END, NO);
}
// Queues a touch event with absolute coordinates |x| and |y|.
void QueueTouch(CGFloat x,
CGFloat y,
Deployment deployment,
NSEventType type,
short subtype,
BOOL run_message_loop) {
id event = [OCMockObject mockForClass:[NSEvent class]];
[(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(type)] type];
[(NSEvent*)[[event stub] andReturnValue:OCMOCK_VALUE(subtype)] subtype];
id mock_touch = [OCMockObject mockForClass:[NSTouch class]];
[[[mock_touch stub] andReturnNSPoint:NSMakePoint(x, y)] normalizedPosition];
NSArray* touches = @[ mock_touch ];
[[[event stub] andReturn:touches] touchesMatchingPhase:NSTouchPhaseAny
inView:[OCMArg any]];
[[[event stub] andReturnBool:NO] isDirectionInvertedFromDevice];
QueueEvent(event, deployment, run_message_loop);
}
// Convenience methods for event queuing -------------------------------------
// Trackpad scroll events are roughly related to touch events. Given a
// trackpad scroll delta, approximate the change to the touch event.
void UpdateTouchLocationFromTrackpadScroll(int dx, int dy) {
touch_.x -= dx * 0.001;
touch_.y -= dy * 0.001;
}
// Queue the typical events at the beginning of a new swipe gesture. The
// ordering and values were determined by recording real swipe events.
void QueueBeginningEvents(int dx, int dy) {
QueueTouch(
DEPLOYMENT_TOUCHES_BEGAN, NSEventTypeGesture, NSMouseEventSubtype, NO);
QueueTrackpadScroll(0, 0, NSEventPhaseMayBegin, YES);
QueueTouch(
DEPLOYMENT_TOUCHES_MOVED, NSEventTypeGesture, NSMouseEventSubtype, NO);
QueueTrackpadScroll(dx, dy, NSEventPhaseBegan, NO);
QueueGestureBegin();
QueueTouch(DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeBeginGesture,
NSTouchEventSubtype,
NO);
QueueTouch(
DEPLOYMENT_TOUCHES_MOVED, NSEventTypeGesture, NSTouchEventSubtype, YES);
UpdateTouchLocationFromTrackpadScroll(dx, dy);
QueueTouch(
DEPLOYMENT_TOUCHES_MOVED, NSEventTypeGesture, NSTouchEventSubtype, NO);
}
// Queue the typical events at the end of a new swipe gesture. The ordering
// and values were determined by recording real swipe events.
void QueueEndEvents() {
QueueTouch(DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeEndGesture,
NSMouseEventSubtype,
NO);
QueueTouch(DEPLOYMENT_TOUCHES_ENDED,
NSEventTypeEndGesture,
NSMouseEventSubtype,
NO);
QueueGestureEnd();
QueueTrackpadScroll(0, 0, NSEventPhaseEnded, YES);
}
// Queues a trackpad scroll movement and a touch movement event.
void QueueScrollAndTouchMoved(int dx, int dy) {
QueueTrackpadScroll(dx, dy, NSEventPhaseChanged, NO);
UpdateTouchLocationFromTrackpadScroll(dx, dy);
QueueTouch(
DEPLOYMENT_TOUCHES_MOVED, NSEventTypeGesture, NSTouchEventSubtype, YES);
}
// Queues a touch event with the stored touch coordinates.
void QueueTouch(Deployment deployment,
NSEventType type,
short subtype,
BOOL run_message_loop) {
QueueTouch(touch_.x, touch_.y, deployment, type, subtype, run_message_loop);
}
// Replays the events from the queue.
void RunQueuedEvents() {
while ([event_queue_ count] > 0) {
QueuedEvent* queued_event = [event_queue_ objectAtIndex:0];
NSEvent* event = queued_event.event;
NSView* view =
GetWebContents()->GetRenderViewHost()->GetView()->GetNativeView();
BOOL run_loop = queued_event.runMessageLoop;
switch (queued_event.deployment) {
case DEPLOYMENT_GESTURE_BEGIN:
[view beginGestureWithEvent:event];
break;
case DEPLOYMENT_GESTURE_END:
[view endGestureWithEvent:event];
break;
case DEPLOYMENT_SCROLL_WHEEL:
[view scrollWheel:event];
break;
case DEPLOYMENT_TOUCHES_BEGAN:
[view touchesBeganWithEvent:event];
break;
case DEPLOYMENT_TOUCHES_ENDED:
[view touchesEndedWithEvent:event];
break;
case DEPLOYMENT_TOUCHES_MOVED:
[view touchesMovedWithEvent:event];
break;
}
[event_queue_ removeObjectAtIndex:0];
if (!run_loop)
continue;
// Give time for the IPC to make it to the renderer process. If the IPC
// doesn't have time to make it to the renderer process, that's okay,
// since that simulates realistic conditions.
[[NSRunLoop currentRunLoop]
runUntilDate:[NSDate dateWithTimeIntervalSinceNow:0.001]];
// The renderer process returns an IPC, which needs to be handled.
base::MessageLoop::current()->RunUntilIdle();
}
}
void ExpectUrlAndOffset(const GURL& url, int offset) {
content::WaitForLoadStop(GetWebContents());
EXPECT_EQ(url, GetWebContents()->GetURL());
const int scroll_offset = GetScrollTop();
EXPECT_EQ(offset, scroll_offset);
}
GURL url1_;
GURL url2_;
GURL url_iframe_;
base::scoped_nsobject<NSMutableArray> event_queue_;
// The current location of the user's fingers on the track pad.
CGPoint touch_;
private:
DISALLOW_COPY_AND_ASSIGN(ChromeRenderWidgetHostViewMacHistorySwiperTest);
};
// The ordering, timing, and parameters of the events was determined by
// recording a real swipe.
IN_PROC_BROWSER_TEST_F(ChromeRenderWidgetHostViewMacHistorySwiperTest,
TestBackwardsHistoryNavigationRealData) {
if (!IsHistorySwipingSupported())
return;
QueueTouch(0.510681,
0.444672,
DEPLOYMENT_TOUCHES_BEGAN,
NSEventTypeGesture,
NSMouseEventSubtype,
NO);
QueueTrackpadScroll(0, 0, NSEventPhaseMayBegin, YES);
QueueTouch(0.510681,
0.444672,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSMouseEventSubtype,
NO);
QueueTrackpadScroll(1, 0, NSEventPhaseBegan, NO);
QueueGestureBegin();
QueueTouch(0.510681,
0.444672,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeBeginGesture,
NSTouchEventSubtype,
NO);
QueueTouch(0.510681,
0.444672,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTouch(0.507019,
0.444092,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
NO);
QueueTrackpadScroll(3, 0, NSEventPhaseChanged, YES);
QueueTrackpadScroll(3, -1, NSEventPhaseChanged, NO);
QueueTouch(0.502861,
0.443512,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTrackpadScroll(6, -1, NSEventPhaseChanged, NO);
QueueTouch(0.497002,
0.44294,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTrackpadScroll(5, -1, NSEventPhaseChanged, NO);
QueueTouch(0.487236,
0.44149,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTrackpadScroll(8, -1, NSEventPhaseChanged, NO);
QueueTouch(0.480392,
0.440628,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
NO);
QueueTouch(0.475266,
0.440338,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTrackpadScroll(6, -1, NSEventPhaseChanged, NO);
QueueTrackpadScroll(10, -1, NSEventPhaseChanged, NO);
QueueTouch(0.467934,
0.439758,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTrackpadScroll(6, -1, NSEventPhaseChanged, NO);
QueueTouch(0.462807,
0.439186,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTrackpadScroll(12, -1, NSEventPhaseChanged, NO);
QueueTouch(0.454018,
0.438316,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTrackpadScroll(6, -1, NSEventPhaseChanged, NO);
QueueTouch(0.449623,
0.438026,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTrackpadScroll(9, 0, NSEventPhaseChanged, NO);
QueueTouch(0.443275,
0.437744,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTouch(0.437164,
0.437164,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTrackpadScroll(9, -1, NSEventPhaseChanged, NO);
QueueTouch(0.431305,
0.436874,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTrackpadScroll(8, -1, NSEventPhaseChanged, NO);
QueueTouch(0.425926,
0.436295,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTrackpadScroll(7, -1, NSEventPhaseChanged, NO);
QueueTouch(0.420311,
0.43573,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTrackpadScroll(7, -1, NSEventPhaseChanged, NO);
QueueTouch(0.415184,
0.43544,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTrackpadScroll(6, -1, NSEventPhaseChanged, NO);
QueueTouch(0.410057,
0.43457,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTouch(0.40493,
0.43399,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTrackpadScroll(7, -1, NSEventPhaseChanged, YES);
QueueTrackpadScroll(3, -1, NSEventPhaseChanged, NO);
QueueTouch(0.402489,
0.433701,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTrackpadScroll(5, 0, NSEventPhaseChanged, NO);
QueueTouch(0.398094,
0.433418,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTrackpadScroll(4, -1, NSEventPhaseChanged, NO);
QueueTouch(0.394669,
0.433128,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTouch(0.391006,
0.432549,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTrackpadScroll(4, -1, NSEventPhaseChanged, NO);
QueueTrackpadScroll(5, 0, NSEventPhaseChanged, YES);
QueueTouch(0.386848,
0.432259,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
QueueTouch(0.38343,
0.432259,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeGesture,
NSTouchEventSubtype,
YES);
// Skipped a bunch of events. The data on the gesture end events are fudged.
QueueTouch(0.38343,
0.432259,
DEPLOYMENT_TOUCHES_MOVED,
NSEventTypeEndGesture,
NSMouseEventSubtype,
NO);
QueueTouch(0.38343,
0.432259,
DEPLOYMENT_TOUCHES_ENDED,
NSEventTypeEndGesture,
NSMouseEventSubtype,
NO);
QueueGestureEnd();
QueueTrackpadScroll(0, 0, NSEventPhaseEnded, YES);
RunQueuedEvents();
ExpectUrlAndOffset(url1_, 0);
}
// Each movement event that has non-zero parameters has both horizontal and
// vertical motion. This should not trigger history navigation.
IN_PROC_BROWSER_TEST_F(ChromeRenderWidgetHostViewMacHistorySwiperTest,
TestAllDiagonalSwipes) {
if (!IsHistorySwipingSupported())
return;
QueueBeginningEvents(1, -1);
for (int i = 0; i < 150; ++i)
QueueScrollAndTouchMoved(1, -1);
QueueEndEvents();
RunQueuedEvents();
ExpectUrlAndOffset(url2_, 150);
}
// The movements are equal part diagonal, horizontal, and vertical. This should
// not trigger history navigation.
IN_PROC_BROWSER_TEST_F(ChromeRenderWidgetHostViewMacHistorySwiperTest,
TestStaggeredDiagonalSwipe) {
if (!IsHistorySwipingSupported())
return;
QueueBeginningEvents(1, 0);
for (int i = 0; i < 150; ++i) {
switch (i % 3) {
case 0:
QueueScrollAndTouchMoved(1, -1);
break;
case 1:
QueueScrollAndTouchMoved(0, -1);
break;
case 2:
QueueScrollAndTouchMoved(1, 0);
break;
default:
NOTREACHED();
}
}
QueueEndEvents();
RunQueuedEvents();
content::WaitForLoadStop(GetWebContents());
EXPECT_EQ(url2_, GetWebContents()->GetURL());
// Depending on the timing of the IPCs, some of the initial events might be
// recognized as part of the history swipe, and not forwarded to the renderer,
// resulting in a non-deterministic scroll offset. This is bad, as some
// vertical motion is lost. Once the history swiper logic is fixed, this
// should become a direct comparison between 'scroll_offset' and 100.
// crbug.com/375514
const int scroll_offset = GetScrollTop();
// TODO(erikchen): Depending on the timing of the IPCs between Chrome and the
// renderer, more than 15% of the vertical motion can be lost. This assertion
// should eventually become an equality comparison against 100.
// crbug.com/378158
EXPECT_GT(scroll_offset, 1);
}
// The movement events are mostly in the horizontal direction, which should
// trigger a history swipe. This should trigger history navigation.
IN_PROC_BROWSER_TEST_F(ChromeRenderWidgetHostViewMacHistorySwiperTest,
TestMostlyHorizontal) {
if (!IsHistorySwipingSupported())
return;
QueueBeginningEvents(1, -1);
for (int i = 0; i < 150; ++i) {
if (i % 10 == 0) {
QueueScrollAndTouchMoved(0, -1);
} else if (i % 5 == 0) {
QueueScrollAndTouchMoved(1, -1);
} else {
QueueScrollAndTouchMoved(1, 0);
}
}
QueueEndEvents();
RunQueuedEvents();
ExpectUrlAndOffset(url1_, 0);
}
// Each movement event is horizontal, except the first two. This should trigger
// history navigation. This test is DISABLED because it has never worked. Once
// the flaw in the history swiper logic has been corrected, this test should be
// enabled.
// crbug.com/375512
IN_PROC_BROWSER_TEST_F(ChromeRenderWidgetHostViewMacHistorySwiperTest,
DISABLED_TestAllHorizontalButFirst) {
if (!IsHistorySwipingSupported())
return;
QueueBeginningEvents(0, -1);
QueueScrollAndTouchMoved(0, -1);
for (int i = 0; i < 149; ++i)
QueueScrollAndTouchMoved(1, 0);
QueueEndEvents();
RunQueuedEvents();
ExpectUrlAndOffset(url1_, 0);
}
// Initial movements are vertical, and scroll the iframe. Subsequent movements
// are horizontal, and should not trigger history swiping.
IN_PROC_BROWSER_TEST_F(ChromeRenderWidgetHostViewMacHistorySwiperTest,
TestIframeHistorySwiping) {
if (!IsHistorySwipingSupported())
return;
ui_test_utils::NavigateToURL(browser(), url_iframe_);
ASSERT_EQ(url_iframe_, GetWebContents()->GetURL());
QueueBeginningEvents(0, -1);
for (int i = 0; i < 10; ++i)
QueueScrollAndTouchMoved(0, -1);
for (int i = 0; i < 149; ++i)
QueueScrollAndTouchMoved(1, 0);
QueueEndEvents();
RunQueuedEvents();
content::WaitForLoadStop(GetWebContents());
EXPECT_EQ(url_iframe_, GetWebContents()->GetURL());
}
// The gesture ends before the touchesEndedWithEvent: method gets called.
IN_PROC_BROWSER_TEST_F(ChromeRenderWidgetHostViewMacHistorySwiperTest,
TestGestureEndTiming) {
if (!IsHistorySwipingSupported())
return;
QueueBeginningEvents(1, 0);
for (int i = 0; i < 150; ++i)
QueueScrollAndTouchMoved(1, 0);
QueueTouch(
DEPLOYMENT_TOUCHES_MOVED, NSEventTypeEndGesture, NSMouseEventSubtype, NO);
QueueGestureEnd();
QueueTouch(
DEPLOYMENT_TOUCHES_ENDED, NSEventTypeEndGesture, NSMouseEventSubtype, NO);
QueueTrackpadScroll(0, 0, NSEventPhaseEnded, YES);
RunQueuedEvents();
ExpectUrlAndOffset(url1_, 0);
}