1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
// 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 "config.h"
#include <gtest/gtest.h>
#include "platform/geometry/IntPoint.h"
#include "platform/geometry/IntSize.h"
#include "platform/mac/ScrollElasticityController.h"
#include "platform/PlatformWheelEvent.h"
namespace WebCore {
class MockScrollElasticityControllerClient : public ScrollElasticityControllerClient {
public:
MockScrollElasticityControllerClient() : m_pinned(true), m_stretchX(0.0f) {}
virtual bool allowsHorizontalStretching() OVERRIDE { return true; }
virtual bool allowsVerticalStretching() OVERRIDE { return true; }
// The amount that the view is stretched past the normal allowable bounds.
// The "overhang" amount.
virtual IntSize stretchAmount() OVERRIDE { return IntSize(m_stretchX, 0); }
virtual bool pinnedInDirection(const FloatSize&) OVERRIDE { return m_pinned; }
virtual bool canScrollHorizontally() OVERRIDE { return true; }
virtual bool canScrollVertically() OVERRIDE { return true; }
// Return the absolute scroll position, not relative to the scroll origin.
virtual WebCore::IntPoint absoluteScrollPosition() OVERRIDE { return IntPoint(m_stretchX, 0); }
virtual void immediateScrollBy(const FloatSize& size) OVERRIDE { m_stretchX += size.width(); }
virtual void immediateScrollByWithoutContentEdgeConstraints(const FloatSize& size) OVERRIDE { m_stretchX += size.width(); }
virtual void startSnapRubberbandTimer() OVERRIDE {}
virtual void stopSnapRubberbandTimer() OVERRIDE {}
virtual void adjustScrollPositionToBoundsIfNecessary() OVERRIDE {}
void reset() { m_stretchX = 0; }
bool m_pinned;
private:
float m_stretchX;
};
class MockPlatformWheelEvent : public PlatformWheelEvent {
public:
MockPlatformWheelEvent(PlatformWheelEventPhase phase, float deltaX, bool canRubberbandLeft)
{
m_phase = phase;
m_deltaX = deltaX;
m_canRubberbandLeft = canRubberbandLeft;
}
};
enum RubberbandPermission {
DisallowRubberband,
AllowRubberband
};
enum ScrollPermission {
DisallowScroll,
AllowScroll
};
const float deltaLeft = 1.0f;
const float deltaNone = 0.0f;
class ScrollElasticityControllerTest : public testing::Test {
public:
ScrollElasticityControllerTest() : m_controller(&m_client) {}
// Makes a wheel event with the given parameters, and forwards the event to the
// controller.
bool handleWheelEvent(RubberbandPermission canRubberband, ScrollPermission canScroll, PlatformWheelEventPhase phase, float delta)
{
m_client.m_pinned = !canScroll;
MockPlatformWheelEvent event(phase, delta, canRubberband);
return m_controller.handleWheelEvent(event);
}
void SetUp()
{
m_client.reset();
}
private:
MockScrollElasticityControllerClient m_client;
ScrollElasticityController m_controller;
};
// The client cannot scroll, but the event allows rubber banding.
TEST_F(ScrollElasticityControllerTest, canRubberband)
{
// The PlatformWheelEventPhaseMayBegin event should never be handled.
EXPECT_FALSE(handleWheelEvent(AllowRubberband, DisallowScroll, PlatformWheelEventPhaseMayBegin, deltaNone));
// All other events should be handled.
EXPECT_TRUE(handleWheelEvent(AllowRubberband, DisallowScroll, PlatformWheelEventPhaseBegan, deltaLeft));
EXPECT_TRUE(handleWheelEvent(AllowRubberband, DisallowScroll, PlatformWheelEventPhaseChanged, deltaLeft));
EXPECT_TRUE(handleWheelEvent(AllowRubberband, DisallowScroll, PlatformWheelEventPhaseEnded, deltaNone));
}
// The client cannot scroll, and the event disallows rubber banding.
TEST_F(ScrollElasticityControllerTest, cannotRubberband)
{
// The PlatformWheelEventPhaseMayBegin event should never be handled.
EXPECT_FALSE(handleWheelEvent(DisallowRubberband, DisallowScroll, PlatformWheelEventPhaseMayBegin, deltaNone));
// Rubber-banding is disabled, and the client is pinned.
// Ignore all events.
EXPECT_FALSE(handleWheelEvent(DisallowRubberband, DisallowScroll, PlatformWheelEventPhaseBegan, deltaLeft));
EXPECT_FALSE(handleWheelEvent(DisallowRubberband, DisallowScroll, PlatformWheelEventPhaseChanged, deltaLeft));
EXPECT_FALSE(handleWheelEvent(DisallowRubberband, DisallowScroll, PlatformWheelEventPhaseEnded, deltaNone));
}
// The client can scroll, and the event disallows rubber banding.
TEST_F(ScrollElasticityControllerTest, cannotRubberbandCanScroll)
{
// The PlatformWheelEventPhaseMayBegin event should never be handled.
EXPECT_FALSE(handleWheelEvent(DisallowRubberband, AllowScroll, PlatformWheelEventPhaseMayBegin, deltaNone));
// Rubber-banding is disabled, but the client is not pinned.
// Handle all events.
EXPECT_TRUE(handleWheelEvent(DisallowRubberband, AllowScroll, PlatformWheelEventPhaseBegan, deltaLeft));
EXPECT_TRUE(handleWheelEvent(DisallowRubberband, AllowScroll, PlatformWheelEventPhaseChanged, deltaLeft));
EXPECT_TRUE(handleWheelEvent(DisallowRubberband, AllowScroll, PlatformWheelEventPhaseEnded, deltaNone));
}
// The client cannot scroll. The initial events allow rubber banding, but the
// later events disallow it.
TEST_F(ScrollElasticityControllerTest, canRubberbandBecomesFalse)
{
// The PlatformWheelEventPhaseMayBegin event should never be handled.
EXPECT_FALSE(handleWheelEvent(AllowRubberband, DisallowScroll, PlatformWheelEventPhaseMayBegin, deltaNone));
EXPECT_TRUE(handleWheelEvent(AllowRubberband, DisallowScroll, PlatformWheelEventPhaseBegan, deltaLeft));
EXPECT_TRUE(handleWheelEvent(AllowRubberband, DisallowScroll, PlatformWheelEventPhaseChanged, deltaLeft));
// Rubber-banding is no longer allowed, but its already started.
// Events should still be handled.
EXPECT_TRUE(handleWheelEvent(DisallowRubberband, DisallowScroll, PlatformWheelEventPhaseChanged, deltaLeft));
EXPECT_TRUE(handleWheelEvent(DisallowRubberband, DisallowScroll, PlatformWheelEventPhaseEnded, deltaNone));
}
// The client cannot scroll. The initial events disallow rubber banding, but the
// later events allow it.
TEST_F(ScrollElasticityControllerTest, canRubberbandBecomesTrue)
{
// The PlatformWheelEventPhaseMayBegin event should never be handled.
EXPECT_FALSE(handleWheelEvent(DisallowRubberband, DisallowScroll, PlatformWheelEventPhaseMayBegin, deltaNone));
EXPECT_FALSE(handleWheelEvent(DisallowRubberband, DisallowScroll, PlatformWheelEventPhaseBegan, deltaLeft));
EXPECT_FALSE(handleWheelEvent(DisallowRubberband, DisallowScroll, PlatformWheelEventPhaseChanged, deltaLeft));
// Rubber-banding is now allowed
EXPECT_TRUE(handleWheelEvent(AllowRubberband, DisallowScroll, PlatformWheelEventPhaseChanged, deltaLeft));
EXPECT_TRUE(handleWheelEvent(AllowRubberband, DisallowScroll, PlatformWheelEventPhaseEnded, deltaNone));
}
// Events with no delta should not cause scrolling.
TEST_F(ScrollElasticityControllerTest, zeroDeltaEventsIgnored)
{
// The PlatformWheelEventPhaseMayBegin event should never be handled.
EXPECT_FALSE(handleWheelEvent(AllowRubberband, DisallowScroll, PlatformWheelEventPhaseMayBegin, deltaNone));
// TODO(erikchen): This logic is incorrect. The zero delta event should not have been handled. crbug.com/375512
EXPECT_TRUE(handleWheelEvent(AllowRubberband, DisallowScroll, PlatformWheelEventPhaseBegan, deltaNone));
EXPECT_FALSE(handleWheelEvent(AllowRubberband, DisallowScroll, PlatformWheelEventPhaseChanged, deltaNone));
EXPECT_TRUE(handleWheelEvent(AllowRubberband, DisallowScroll, PlatformWheelEventPhaseChanged, deltaLeft));
EXPECT_TRUE(handleWheelEvent(AllowRubberband, DisallowScroll, PlatformWheelEventPhaseEnded, deltaNone));
}
} // namespace WebCore
|
