Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(310)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: remoting/client/plugin/normalizing_input_filter_cros_unittest.cc

Issue 1228333004: Move code that doesn't depend on PPAPI out of remoting/client/plugin (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 5 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « remoting/client/plugin/normalizing_input_filter_cros.cc ('k') | remoting/client/plugin/normalizing_input_filter_mac.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "remoting/client/plugin/normalizing_input_filter_cros.h"
6
7 #include "remoting/proto/event.pb.h"
8 #include "remoting/protocol/protocol_mock_objects.h"
9 #include "remoting/protocol/test_event_matchers.h"
10 #include "remoting/protocol/usb_key_codes.h"
11 #include "testing/gmock/include/gmock/gmock.h"
12 #include "testing/gtest/include/gtest/gtest.h"
13
14 using ::testing::InSequence;
15 using remoting::protocol::InputStub;
16 using remoting::protocol::KeyEvent;
17 using remoting::protocol::MockInputStub;
18 using remoting::protocol::MouseEvent;
19 using remoting::protocol::test::EqualsKeyEventWithNumLock;
20 using remoting::protocol::test::EqualsMouseButtonEvent;
21 using remoting::protocol::test::EqualsMouseMoveEvent;
22
23 namespace remoting {
24
25 namespace {
26
27 const unsigned int kUsbFunctionKey = 0x07003a; // F1
28 const unsigned int kUsbExtendedKey = kUsbInsert;
29 const unsigned int kUsbOtherKey = kUsbTab;
30
31 KeyEvent MakeKeyEvent(uint32 keycode, bool pressed) {
32 KeyEvent event;
33 event.set_usb_keycode(keycode);
34 event.set_pressed(pressed);
35 event.set_lock_states(protocol::KeyEvent::LOCK_STATES_NUMLOCK);
36 return event;
37 }
38
39 void PressAndReleaseKey(InputStub* input_stub, uint32 keycode) {
40 input_stub->InjectKeyEvent(MakeKeyEvent(keycode, true));
41 input_stub->InjectKeyEvent(MakeKeyEvent(keycode, false));
42 }
43
44 static MouseEvent MakeMouseMoveEvent(int x, int y) {
45 MouseEvent event;
46 event.set_x(x);
47 event.set_y(y);
48 return event;
49 }
50
51 static MouseEvent MakeMouseButtonEvent(MouseEvent::MouseButton button,
52 bool button_down) {
53 MouseEvent event;
54 event.set_button(button);
55 event.set_button_down(button_down);
56 return event;
57 }
58
59 } // namespace
60
61 // Test OSKey press/release.
62 TEST(NormalizingInputFilterCrosTest, PressReleaseOsKey) {
63 MockInputStub stub;
64 scoped_ptr<protocol::InputFilter> processor(
65 new NormalizingInputFilterCros(&stub));
66
67 {
68 InSequence s;
69
70 EXPECT_CALL(stub,
71 InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbLeftOs, true)));
72 EXPECT_CALL(
73 stub, InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbLeftOs, false)));
74
75 EXPECT_CALL(
76 stub, InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbRightOs, true)));
77 EXPECT_CALL(
78 stub, InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbRightOs, false)));
79 }
80
81 // Inject press & release events for left & right OSKeys.
82 PressAndReleaseKey(processor.get(), kUsbLeftOs);
83 PressAndReleaseKey(processor.get(), kUsbRightOs);
84 }
85
86 // Test OSKey key repeat switches it to "modifying" mode.
87 TEST(NormalizingInputFilterCrosTest, OSKeyRepeats) {
88 MockInputStub stub;
89 scoped_ptr<protocol::InputFilter> processor(
90 new NormalizingInputFilterCros(&stub));
91
92 {
93 InSequence s;
94
95 EXPECT_CALL(stub,
96 InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbLeftOs, true)));
97 EXPECT_CALL(stub,
98 InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbLeftOs, true)));
99 EXPECT_CALL(stub,
100 InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbLeftOs, true)));
101 }
102
103 // Inject a press and repeats for the left OSKey, but don't release it, and
104 // verify that the repeats result in press events.
105 processor->InjectKeyEvent(MakeKeyEvent(kUsbLeftOs, true));
106 processor->InjectKeyEvent(MakeKeyEvent(kUsbLeftOs, true));
107 processor->InjectKeyEvent(MakeKeyEvent(kUsbLeftOs, true));
108 }
109
110 // Test OSKey press followed by function key press and release results in
111 // just the function key events.
112 TEST(NormalizingInputFilterCrosTest, FunctionKey) {
113 MockInputStub stub;
114 scoped_ptr<protocol::InputFilter> processor(
115 new NormalizingInputFilterCros(&stub));
116
117 {
118 InSequence s;
119
120 EXPECT_CALL(
121 stub, InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbFunctionKey, true)));
122 EXPECT_CALL(stub, InjectKeyEvent(
123 EqualsKeyEventWithNumLock(kUsbFunctionKey, false)));
124 }
125
126 // Hold the left OSKey while pressing & releasing the function key.
127 processor->InjectKeyEvent(MakeKeyEvent(kUsbLeftOs, true));
128 PressAndReleaseKey(processor.get(), kUsbFunctionKey);
129 processor->InjectKeyEvent(MakeKeyEvent(kUsbLeftOs, false));
130 }
131
132 // Test OSKey press followed by extended key press and release results in
133 // just the function key events.
134 TEST(NormalizingInputFilterCrosTest, ExtendedKey) {
135 MockInputStub stub;
136 scoped_ptr<protocol::InputFilter> processor(
137 new NormalizingInputFilterCros(&stub));
138
139 {
140 InSequence s;
141
142 EXPECT_CALL(
143 stub, InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbExtendedKey, true)));
144 EXPECT_CALL(stub, InjectKeyEvent(
145 EqualsKeyEventWithNumLock(kUsbExtendedKey, false)));
146 }
147
148 // Hold the left OSKey while pressing & releasing the function key.
149 processor->InjectKeyEvent(MakeKeyEvent(kUsbLeftOs, true));
150 PressAndReleaseKey(processor.get(), kUsbExtendedKey);
151 processor->InjectKeyEvent(MakeKeyEvent(kUsbLeftOs, false));
152 }
153
154 // Test OSKey press followed by non-function, non-extended key press and release
155 // results in normal-looking sequence.
156 TEST(NormalizingInputFilterCrosTest, OtherKey) {
157 MockInputStub stub;
158 scoped_ptr<protocol::InputFilter> processor(
159 new NormalizingInputFilterCros(&stub));
160
161 {
162 InSequence s;
163
164 EXPECT_CALL(stub,
165 InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbLeftOs, true)));
166 EXPECT_CALL(stub,
167 InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbOtherKey, true)));
168 EXPECT_CALL(stub,
169 InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbOtherKey, false)));
170 EXPECT_CALL(
171 stub, InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbLeftOs, false)));
172 }
173
174 // Hold the left OSKey while pressing & releasing the function key.
175 processor->InjectKeyEvent(MakeKeyEvent(kUsbLeftOs, true));
176 PressAndReleaseKey(processor.get(), kUsbOtherKey);
177 processor->InjectKeyEvent(MakeKeyEvent(kUsbLeftOs, false));
178 }
179
180 // Test OSKey press followed by extended key press, then normal key press
181 // results in OSKey switching to modifying mode for the normal key.
182 TEST(NormalizingInputFilterCrosTest, ExtendedThenOtherKey) {
183 MockInputStub stub;
184 scoped_ptr<protocol::InputFilter> processor(
185 new NormalizingInputFilterCros(&stub));
186
187 {
188 InSequence s;
189
190 EXPECT_CALL(
191 stub, InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbExtendedKey, true)));
192 EXPECT_CALL(stub, InjectKeyEvent(
193 EqualsKeyEventWithNumLock(kUsbExtendedKey, false)));
194 EXPECT_CALL(stub,
195 InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbLeftOs, true)));
196 EXPECT_CALL(stub,
197 InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbOtherKey, true)));
198 EXPECT_CALL(stub,
199 InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbOtherKey, false)));
200 EXPECT_CALL(
201 stub, InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbLeftOs, false)));
202 }
203
204 // Hold the left OSKey while pressing & releasing the function key.
205 processor->InjectKeyEvent(MakeKeyEvent(kUsbLeftOs, true));
206 PressAndReleaseKey(processor.get(), kUsbExtendedKey);
207 PressAndReleaseKey(processor.get(), kUsbOtherKey);
208 processor->InjectKeyEvent(MakeKeyEvent(kUsbLeftOs, false));
209 }
210
211 // Test OSKey press followed by mouse event puts the OSKey into modifying mode.
212 TEST(NormalizingInputFilterCrosTest, MouseEvent) {
213 MockInputStub stub;
214 scoped_ptr<protocol::InputFilter> processor(
215 new NormalizingInputFilterCros(&stub));
216
217 {
218 InSequence s;
219
220 EXPECT_CALL(stub,
221 InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbLeftOs, true)));
222 EXPECT_CALL(stub, InjectMouseEvent(EqualsMouseMoveEvent(0, 0)));
223 EXPECT_CALL(
224 stub, InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbLeftOs, false)));
225 }
226
227 // Hold the left OSKey while pressing & releasing the function key.
228 processor->InjectKeyEvent(MakeKeyEvent(kUsbLeftOs, true));
229 processor->InjectMouseEvent(MakeMouseMoveEvent(0, 0));
230 processor->InjectKeyEvent(MakeKeyEvent(kUsbLeftOs, false));
231 }
232
233 // Test left alt + right click is remapped to left alt + left click.
234 TEST(NormalizingInputFilterCrosTest, LeftAltClick) {
235 MockInputStub stub;
236 scoped_ptr<protocol::InputFilter> processor(
237 new NormalizingInputFilterCros(&stub));
238
239 {
240 InSequence s;
241
242 EXPECT_CALL(
243 stub, InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbLeftAlt, true)));
244 EXPECT_CALL(stub, InjectMouseEvent(EqualsMouseButtonEvent(
245 MouseEvent::BUTTON_LEFT, true)));
246 EXPECT_CALL(stub, InjectMouseEvent(EqualsMouseButtonEvent(
247 MouseEvent::BUTTON_LEFT, false)));
248 EXPECT_CALL(
249 stub, InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbLeftAlt, false)));
250 }
251
252 // Hold the left alt key while left-clicking. ChromeOS will rewrite this as
253 // Alt+RightClick
254 processor->InjectKeyEvent(MakeKeyEvent(kUsbLeftAlt, true));
255 processor->InjectMouseEvent(
256 MakeMouseButtonEvent(MouseEvent::BUTTON_RIGHT, true));
257 processor->InjectMouseEvent(
258 MakeMouseButtonEvent(MouseEvent::BUTTON_RIGHT, false));
259 processor->InjectKeyEvent(MakeKeyEvent(kUsbLeftAlt, false));
260 }
261
262 // Test that right alt + right click is unchanged.
263 TEST(NormalizingInputFilterCrosTest, RightAltClick) {
264 MockInputStub stub;
265 scoped_ptr<protocol::InputFilter> processor(
266 new NormalizingInputFilterCros(&stub));
267
268 {
269 InSequence s;
270
271 EXPECT_CALL(
272 stub, InjectKeyEvent(EqualsKeyEventWithNumLock(kUsbRightAlt, true)));
273 EXPECT_CALL(stub, InjectMouseEvent(EqualsMouseButtonEvent(
274 MouseEvent::BUTTON_RIGHT, true)));
275 EXPECT_CALL(stub, InjectMouseEvent(EqualsMouseButtonEvent(
276 MouseEvent::BUTTON_RIGHT, false)));
277 EXPECT_CALL(stub, InjectKeyEvent(
278 EqualsKeyEventWithNumLock(kUsbRightAlt, false)));
279 }
280
281 // Hold the right alt key while left-clicking. ChromeOS will rewrite this as
282 // Alt+RightClick
283 processor->InjectKeyEvent(MakeKeyEvent(kUsbRightAlt, true));
284 processor->InjectMouseEvent(
285 MakeMouseButtonEvent(MouseEvent::BUTTON_RIGHT, true));
286 processor->InjectMouseEvent(
287 MakeMouseButtonEvent(MouseEvent::BUTTON_RIGHT, false));
288 processor->InjectKeyEvent(MakeKeyEvent(kUsbRightAlt, false));
289 }
290
291 } // namespace remoting
OLDNEW
« no previous file with comments | « remoting/client/plugin/normalizing_input_filter_cros.cc ('k') | remoting/client/plugin/normalizing_input_filter_mac.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698