| OLD | NEW |
| (Empty) |
| 1 // Copyright 2015 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/touch_input_scaler.h" | |
| 6 | |
| 7 #include <cmath> | |
| 8 | |
| 9 #include "remoting/protocol/protocol_mock_objects.h" | |
| 10 #include "remoting/protocol/test_event_matchers.h" | |
| 11 #include "testing/gmock/include/gmock/gmock.h" | |
| 12 #include "testing/gtest/include/gtest/gtest.h" | |
| 13 | |
| 14 using ::testing::_; | |
| 15 using ::testing::AllOf; | |
| 16 using ::testing::PrintToString; | |
| 17 | |
| 18 namespace remoting { | |
| 19 | |
| 20 using protocol::MockInputStub; | |
| 21 using protocol::TouchEvent; | |
| 22 using protocol::TouchEventPoint; | |
| 23 using protocol::test::EqualsTouchPointCoordinates; | |
| 24 using protocol::test::EqualsTouchPointRadii; | |
| 25 | |
| 26 namespace { | |
| 27 | |
| 28 const float kDefaultRadius = 30.0f; | |
| 29 const float kDefaultXCoord = 1.0f; | |
| 30 const float kDefaultYCoord = 1.0f; | |
| 31 | |
| 32 struct PointInfo { | |
| 33 PointInfo(float x, float y) | |
| 34 : PointInfo(x, y, kDefaultRadius, kDefaultRadius) {} | |
| 35 PointInfo(float x, float y, float radius_x, float radius_y) | |
| 36 : x(x), y(y), radius_x(radius_x), radius_y(radius_y) {} | |
| 37 | |
| 38 float x; | |
| 39 float y; | |
| 40 float radius_x; | |
| 41 float radius_y; | |
| 42 }; | |
| 43 | |
| 44 const PointInfo kDefaultPointInfo = {kDefaultXCoord, | |
| 45 kDefaultYCoord, | |
| 46 kDefaultRadius, | |
| 47 kDefaultRadius}; | |
| 48 | |
| 49 } // namespace | |
| 50 | |
| 51 class TouchInputScalerTest : public ::testing::Test { | |
| 52 protected: | |
| 53 TouchInputScalerTest() : touch_input_scaler_(&mock_stub_) {} | |
| 54 | |
| 55 void AddInputCoordinate(const PointInfo& point_info) { | |
| 56 point_infos_.push_back(point_info); | |
| 57 } | |
| 58 | |
| 59 void AddDefaultTestPoint() { point_infos_.push_back(kDefaultPointInfo); } | |
| 60 | |
| 61 void InjectTestTouchEvent() { | |
| 62 TouchEvent e; | |
| 63 e.set_event_type(TouchEvent::TOUCH_POINT_MOVE); | |
| 64 | |
| 65 uint32_t id = 1; | |
| 66 for (const PointInfo& point_info : point_infos_) { | |
| 67 TouchEventPoint* point = e.add_touch_points(); | |
| 68 point->set_id(id++); | |
| 69 point->set_x(point_info.x); | |
| 70 point->set_y(point_info.y); | |
| 71 point->set_radius_x(point_info.radius_x); | |
| 72 point->set_radius_y(point_info.radius_y); | |
| 73 } | |
| 74 | |
| 75 touch_input_scaler_.InjectTouchEvent(e); | |
| 76 } | |
| 77 | |
| 78 void SetInputDimensions(int width, int height) { | |
| 79 touch_input_scaler_.set_input_size(webrtc::DesktopSize(width, height)); | |
| 80 } | |
| 81 | |
| 82 void SetOutputDimensions(int width, int height) { | |
| 83 touch_input_scaler_.set_output_size(webrtc::DesktopSize(width, height)); | |
| 84 } | |
| 85 | |
| 86 MockInputStub mock_stub_; | |
| 87 TouchInputScaler touch_input_scaler_; | |
| 88 | |
| 89 private: | |
| 90 std::vector<PointInfo> point_infos_; | |
| 91 | |
| 92 DISALLOW_COPY_AND_ASSIGN(TouchInputScalerTest); | |
| 93 }; | |
| 94 | |
| 95 // TouchInputFilter require both input and output dimensions. | |
| 96 // These test verify that no events are forwarded to the next InputStub if | |
| 97 // either dimensions are not set or 0. | |
| 98 TEST_F(TouchInputScalerTest, NoDimensionsSet) { | |
| 99 AddDefaultTestPoint(); | |
| 100 EXPECT_CALL(mock_stub_, InjectTouchEvent(_)).Times(0); | |
| 101 InjectTestTouchEvent(); | |
| 102 } | |
| 103 | |
| 104 TEST_F(TouchInputScalerTest, BothDimensionsZero) { | |
| 105 SetInputDimensions(0, 0); | |
| 106 SetOutputDimensions(0, 0); | |
| 107 AddDefaultTestPoint(); | |
| 108 EXPECT_CALL(mock_stub_, InjectTouchEvent(_)).Times(0); | |
| 109 InjectTestTouchEvent(); | |
| 110 } | |
| 111 | |
| 112 TEST_F(TouchInputScalerTest, SetOnlyInputDimensions) { | |
| 113 SetInputDimensions(50, 60); | |
| 114 AddDefaultTestPoint(); | |
| 115 EXPECT_CALL(mock_stub_, InjectTouchEvent(_)).Times(0); | |
| 116 InjectTestTouchEvent(); | |
| 117 } | |
| 118 | |
| 119 TEST_F(TouchInputScalerTest, SetOnlyOutputDimensions) { | |
| 120 SetOutputDimensions(50, 60); | |
| 121 AddDefaultTestPoint(); | |
| 122 EXPECT_CALL(mock_stub_, InjectTouchEvent(_)).Times(0); | |
| 123 InjectTestTouchEvent(); | |
| 124 } | |
| 125 | |
| 126 // The x,y coordinate fall in the desktop size. | |
| 127 TEST_F(TouchInputScalerTest, NoClampingNoScaling) { | |
| 128 SetInputDimensions(50, 60); | |
| 129 SetOutputDimensions(50, 60); | |
| 130 | |
| 131 AddInputCoordinate({10.0f, 15.0f}); | |
| 132 TouchEvent expected_out; | |
| 133 TouchEventPoint* point = expected_out.add_touch_points(); | |
| 134 point->set_x(10.0f); | |
| 135 point->set_y(15.0f); | |
| 136 | |
| 137 EXPECT_CALL(mock_stub_, | |
| 138 InjectTouchEvent(EqualsTouchPointCoordinates(expected_out))); | |
| 139 InjectTestTouchEvent(); | |
| 140 } | |
| 141 | |
| 142 // Make sure clamping works. | |
| 143 TEST_F(TouchInputScalerTest, ClampingNoScaling) { | |
| 144 SetInputDimensions(50, 60); | |
| 145 SetOutputDimensions(50, 60); | |
| 146 | |
| 147 // Note that this could happen if touch started in the chromoting window but | |
| 148 // the finger moved off the windows. | |
| 149 AddInputCoordinate({-1.0f, 1.0f}); | |
| 150 TouchEvent expected_out; | |
| 151 TouchEventPoint* point = expected_out.add_touch_points(); | |
| 152 point->set_x(0.0f); | |
| 153 point->set_y(1.0f); | |
| 154 | |
| 155 EXPECT_CALL(mock_stub_, | |
| 156 InjectTouchEvent(EqualsTouchPointCoordinates(expected_out))); | |
| 157 InjectTestTouchEvent(); | |
| 158 } | |
| 159 | |
| 160 TEST_F(TouchInputScalerTest, ClampingMultiplePointsNoScaling) { | |
| 161 SetInputDimensions(50, 60); | |
| 162 SetOutputDimensions(50, 60); | |
| 163 | |
| 164 AddInputCoordinate({-1.0f, 1.0f}); // Fall off left. | |
| 165 TouchEvent expected_out; | |
| 166 TouchEventPoint* point = expected_out.add_touch_points(); | |
| 167 point->set_x(0.0f); | |
| 168 point->set_y(1.0f); | |
| 169 | |
| 170 AddInputCoordinate({100.0f, 1.0f}); // Fall off right. | |
| 171 point = expected_out.add_touch_points(); | |
| 172 point->set_x(49.0f); | |
| 173 point->set_y(1.0f); | |
| 174 | |
| 175 AddInputCoordinate({20.0f, 15.0f}); // Should not be clamped. | |
| 176 point = expected_out.add_touch_points(); | |
| 177 point->set_x(20.0f); | |
| 178 point->set_y(15.0f); | |
| 179 | |
| 180 AddInputCoordinate({3.0f, -1.0f}); // Fall off above. | |
| 181 point = expected_out.add_touch_points(); | |
| 182 point->set_x(3.0f); | |
| 183 point->set_y(0.0f); | |
| 184 | |
| 185 AddInputCoordinate({10.0f, 200.0f}); // Fall off below. | |
| 186 point = expected_out.add_touch_points(); | |
| 187 point->set_x(10.0f); | |
| 188 point->set_y(59.0f); | |
| 189 | |
| 190 EXPECT_CALL(mock_stub_, | |
| 191 InjectTouchEvent(EqualsTouchPointCoordinates(expected_out))); | |
| 192 InjectTestTouchEvent(); | |
| 193 } | |
| 194 | |
| 195 // Verify up-scaling works. All coordinates should fall inside the output | |
| 196 // dimensions after scaling. | |
| 197 TEST_F(TouchInputScalerTest, UpScalingNoClamping) { | |
| 198 SetInputDimensions(20, 20); | |
| 199 SetOutputDimensions(40, 40); | |
| 200 | |
| 201 AddInputCoordinate({1.0f, 1.0f}); | |
| 202 TouchEvent expected_out; | |
| 203 TouchEventPoint* point = expected_out.add_touch_points(); | |
| 204 point->set_x(2.0f); | |
| 205 point->set_y(2.0f); | |
| 206 | |
| 207 AddInputCoordinate({1.2f, 4.2f}); | |
| 208 point = expected_out.add_touch_points(); | |
| 209 point->set_x(2.4f); | |
| 210 point->set_y(8.4f); | |
| 211 | |
| 212 EXPECT_CALL(mock_stub_, | |
| 213 InjectTouchEvent(EqualsTouchPointCoordinates(expected_out))); | |
| 214 InjectTestTouchEvent(); | |
| 215 } | |
| 216 | |
| 217 // Verify up-scaling works with clamping. | |
| 218 TEST_F(TouchInputScalerTest, UpScalingWithClamping) { | |
| 219 SetInputDimensions(20, 20); | |
| 220 SetOutputDimensions(40, 40); | |
| 221 | |
| 222 AddInputCoordinate({25.0f, 25.0f}); | |
| 223 TouchEvent expected_out; | |
| 224 TouchEventPoint* point = expected_out.add_touch_points(); | |
| 225 point->set_x(39.0f); | |
| 226 point->set_y(39.0f); | |
| 227 | |
| 228 EXPECT_CALL(mock_stub_, | |
| 229 InjectTouchEvent(EqualsTouchPointCoordinates(expected_out))); | |
| 230 InjectTestTouchEvent(); | |
| 231 } | |
| 232 | |
| 233 // Verify down scaling works. All coordinates should fall inside the output | |
| 234 // dimensions after scaling. | |
| 235 TEST_F(TouchInputScalerTest, DownScalingNoClamping) { | |
| 236 SetInputDimensions(40, 40); | |
| 237 SetOutputDimensions(20, 20); | |
| 238 | |
| 239 AddInputCoordinate({2.0f, 2.0f}); | |
| 240 TouchEvent expected_out; | |
| 241 TouchEventPoint* point = expected_out.add_touch_points(); | |
| 242 point->set_x(1.0f); | |
| 243 point->set_y(1.0f); | |
| 244 | |
| 245 AddInputCoordinate({6.0f, 3.0f}); | |
| 246 point = expected_out.add_touch_points(); | |
| 247 point->set_x(3.0); | |
| 248 point->set_y(1.5f); | |
| 249 | |
| 250 EXPECT_CALL(mock_stub_, | |
| 251 InjectTouchEvent(EqualsTouchPointCoordinates(expected_out))); | |
| 252 InjectTestTouchEvent(); | |
| 253 } | |
| 254 | |
| 255 // Verify down scaling works with clamping. | |
| 256 TEST_F(TouchInputScalerTest, DownScalingWithClamping) { | |
| 257 SetInputDimensions(40, 40); | |
| 258 SetOutputDimensions(20, 20); | |
| 259 | |
| 260 AddInputCoordinate({-20.0f, 10.0f}); | |
| 261 TouchEvent expected_out; | |
| 262 TouchEventPoint* point = expected_out.add_touch_points(); | |
| 263 point->set_x(0.0f); | |
| 264 point->set_y(5.0f); | |
| 265 | |
| 266 AddInputCoordinate({10.0f, -20.0f}); | |
| 267 point = expected_out.add_touch_points(); | |
| 268 point->set_x(5.0f); | |
| 269 point->set_y(0.0f); | |
| 270 | |
| 271 AddInputCoordinate({6.0f, 80.0f}); | |
| 272 point = expected_out.add_touch_points(); | |
| 273 point->set_x(3.0f); | |
| 274 point->set_y(19.0f); | |
| 275 | |
| 276 AddInputCoordinate({80.0f, 6.0f}); | |
| 277 point = expected_out.add_touch_points(); | |
| 278 point->set_x(19.0f); | |
| 279 point->set_y(3.0f); | |
| 280 | |
| 281 EXPECT_CALL(mock_stub_, | |
| 282 InjectTouchEvent(EqualsTouchPointCoordinates(expected_out))); | |
| 283 InjectTestTouchEvent(); | |
| 284 } | |
| 285 | |
| 286 // Verify that the radii are up-scaled. | |
| 287 TEST_F(TouchInputScalerTest, UpScaleRadii) { | |
| 288 SetInputDimensions(20, 20); | |
| 289 SetOutputDimensions(40, 40); | |
| 290 | |
| 291 AddInputCoordinate({0.0f, 0.0f, 1.0f, 2.0f}); | |
| 292 TouchEvent expected_out; | |
| 293 TouchEventPoint* point = expected_out.add_touch_points(); | |
| 294 point->set_radius_x(2.0f); | |
| 295 point->set_radius_y(4.0f); | |
| 296 | |
| 297 EXPECT_CALL(mock_stub_, | |
| 298 InjectTouchEvent(EqualsTouchPointRadii(expected_out))); | |
| 299 InjectTestTouchEvent(); | |
| 300 } | |
| 301 | |
| 302 // Verify that the radii are down-scaled. | |
| 303 TEST_F(TouchInputScalerTest, DownScaleRadii) { | |
| 304 SetInputDimensions(20, 20); | |
| 305 SetOutputDimensions(10, 10); | |
| 306 | |
| 307 AddInputCoordinate({0.0f, 0.0f, 5.0f, 4.0f}); | |
| 308 TouchEvent expected_out; | |
| 309 TouchEventPoint* point = expected_out.add_touch_points(); | |
| 310 point->set_radius_x(2.5f); | |
| 311 point->set_radius_y(2.0f); | |
| 312 | |
| 313 EXPECT_CALL(mock_stub_, | |
| 314 InjectTouchEvent(EqualsTouchPointRadii(expected_out))); | |
| 315 InjectTestTouchEvent(); | |
| 316 } | |
| 317 | |
| 318 // Verify that up-scaling with clamping works for x,y coordinates and radii all | |
| 319 // work together. | |
| 320 TEST_F(TouchInputScalerTest, UpScaleCoordinatesAndRadii) { | |
| 321 SetInputDimensions(20, 20); | |
| 322 SetOutputDimensions(40, 40); | |
| 323 | |
| 324 AddInputCoordinate({5.0f, 12.0f, 3.0f, 2.0f}); | |
| 325 TouchEvent expected_out; | |
| 326 TouchEventPoint* point = expected_out.add_touch_points(); | |
| 327 point->set_x(10.0f); | |
| 328 point->set_y(24.0f); | |
| 329 point->set_radius_x(6.0f); | |
| 330 point->set_radius_y(4.0f); | |
| 331 | |
| 332 // Make sure clamping and scaling all work. | |
| 333 AddInputCoordinate({22.0f, -1.0f, 8.0f, 3.0f}); | |
| 334 point = expected_out.add_touch_points(); | |
| 335 point->set_x(39.0f); | |
| 336 point->set_y(0.0f); | |
| 337 point->set_radius_x(16.0f); | |
| 338 point->set_radius_y(6.0f); | |
| 339 | |
| 340 EXPECT_CALL(mock_stub_, | |
| 341 InjectTouchEvent(AllOf(EqualsTouchPointCoordinates(expected_out), | |
| 342 EqualsTouchPointRadii(expected_out)))); | |
| 343 InjectTestTouchEvent(); | |
| 344 } | |
| 345 | |
| 346 // Verify that down-scaling with clamping works for x,y coordinates and radii | |
| 347 // all work together. | |
| 348 TEST_F(TouchInputScalerTest, DownScaleCoordinatesAndRadii) { | |
| 349 SetInputDimensions(60, 60); | |
| 350 SetOutputDimensions(20, 20); | |
| 351 | |
| 352 AddInputCoordinate({50.0f, 24.0f, 10.0f, 9.0f}); | |
| 353 TouchEvent expected_out; | |
| 354 TouchEventPoint* point = expected_out.add_touch_points(); | |
| 355 point->set_x(16.666f); | |
| 356 point->set_y(8.0f); | |
| 357 point->set_radius_x(3.333f); | |
| 358 point->set_radius_y(3.0f); | |
| 359 | |
| 360 // Make sure clamping and scaling all work. | |
| 361 AddInputCoordinate({70.0f, 82.0f, 8.0f, 3.0f}); | |
| 362 point = expected_out.add_touch_points(); | |
| 363 point->set_x(19.0f); | |
| 364 point->set_y(19.0f); | |
| 365 point->set_radius_x(2.666f); | |
| 366 point->set_radius_y(1.0f); | |
| 367 | |
| 368 EXPECT_CALL(mock_stub_, | |
| 369 InjectTouchEvent(AllOf(EqualsTouchPointCoordinates(expected_out), | |
| 370 EqualsTouchPointRadii(expected_out)))); | |
| 371 InjectTestTouchEvent(); | |
| 372 } | |
| 373 | |
| 374 } // namespace remoting | |
| OLD | NEW |