| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 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 "ui/display/chromeos/touchscreen_util.h" | |
| 6 | |
| 7 #include <memory> | |
| 8 #include <string> | |
| 9 #include <vector> | |
| 10 | |
| 11 #include "base/memory/ptr_util.h" | |
| 12 #include "testing/gtest/include/gtest/gtest.h" | |
| 13 #include "ui/display/manager/display_manager.h" | |
| 14 #include "ui/display/manager/managed_display_info.h" | |
| 15 #include "ui/display/screen_base.h" | |
| 16 #include "ui/display/test/display_manager_test_api.h" | |
| 17 #include "ui/events/devices/input_device.h" | |
| 18 | |
| 19 namespace display { | |
| 20 | |
| 21 using DisplayInfoList = std::vector<ManagedDisplayInfo>; | |
| 22 | |
| 23 class TouchscreenUtilTest : public testing::Test { | |
| 24 public: | |
| 25 TouchscreenUtilTest() {} | |
| 26 ~TouchscreenUtilTest() override {} | |
| 27 | |
| 28 DisplayManager* display_manager() { return display_manager_.get(); } | |
| 29 | |
| 30 // testing::Test: | |
| 31 void SetUp() override { | |
| 32 // Recreate for each test, DisplayManager has a lot of state. | |
| 33 display_manager_ = | |
| 34 base::MakeUnique<DisplayManager>(base::MakeUnique<ScreenBase>()); | |
| 35 | |
| 36 // Internal display will always match to internal touchscreen. If internal | |
| 37 // touchscreen can't be detected, it is then associated to a touch screen | |
| 38 // with matching size. | |
| 39 { | |
| 40 ManagedDisplayInfo display(1, "1", false); | |
| 41 scoped_refptr<ManagedDisplayMode> mode(new ManagedDisplayMode( | |
| 42 gfx::Size(1920, 1080), 60.0, false /* interlaced */, | |
| 43 true /* native */, 1.0 /* ui_scale */, | |
| 44 1.0 /* device_scale_factor */)); | |
| 45 ManagedDisplayInfo::ManagedDisplayModeList modes(1, mode); | |
| 46 display.SetManagedDisplayModes(modes); | |
| 47 displays_.push_back(display); | |
| 48 } | |
| 49 | |
| 50 { | |
| 51 ManagedDisplayInfo display(2, "2", false); | |
| 52 | |
| 53 scoped_refptr<ManagedDisplayMode> mode(new ManagedDisplayMode( | |
| 54 gfx::Size(800, 600), 60.0, false /* interlaced */, true /* native */, | |
| 55 1.0 /* ui_scale */, 1.0 /* device_scale_factor */)); | |
| 56 ManagedDisplayInfo::ManagedDisplayModeList modes(1, mode); | |
| 57 display.SetManagedDisplayModes(modes); | |
| 58 displays_.push_back(display); | |
| 59 } | |
| 60 | |
| 61 // Display without native mode. Must not be matched to any touch screen. | |
| 62 { | |
| 63 ManagedDisplayInfo display(3, "3", false); | |
| 64 displays_.push_back(display); | |
| 65 } | |
| 66 | |
| 67 { | |
| 68 ManagedDisplayInfo display(4, "4", false); | |
| 69 | |
| 70 scoped_refptr<ManagedDisplayMode> mode(new ManagedDisplayMode( | |
| 71 gfx::Size(1024, 768), 60.0, false /* interlaced */, | |
| 72 /* native */ true, 1.0 /* ui_scale */, | |
| 73 1.0 /* device_scale_factor */)); | |
| 74 ManagedDisplayInfo::ManagedDisplayModeList modes(1, mode); | |
| 75 display.SetManagedDisplayModes(modes); | |
| 76 displays_.push_back(display); | |
| 77 } | |
| 78 } | |
| 79 | |
| 80 void TearDown() override { displays_.clear(); } | |
| 81 | |
| 82 protected: | |
| 83 DisplayInfoList displays_; | |
| 84 std::unique_ptr<DisplayManager> display_manager_; | |
| 85 | |
| 86 private: | |
| 87 DISALLOW_COPY_AND_ASSIGN(TouchscreenUtilTest); | |
| 88 }; | |
| 89 | |
| 90 TEST_F(TouchscreenUtilTest, NoTouchscreens) { | |
| 91 std::vector<ui::TouchscreenDevice> devices; | |
| 92 | |
| 93 test::ScopedSetInternalDisplayId set_internal(display_manager(), | |
| 94 displays_[0].id()); | |
| 95 AssociateTouchscreens(&displays_, devices); | |
| 96 | |
| 97 for (size_t i = 0; i < displays_.size(); ++i) | |
| 98 EXPECT_EQ(0u, displays_[i].input_devices().size()); | |
| 99 } | |
| 100 | |
| 101 // Verify that if there are a lot of touchscreens, they will all get associated | |
| 102 // with a display. | |
| 103 TEST_F(TouchscreenUtilTest, ManyTouchscreens) { | |
| 104 std::vector<ui::TouchscreenDevice> devices; | |
| 105 for (int i = 0; i < 5; ++i) { | |
| 106 devices.push_back( | |
| 107 ui::TouchscreenDevice(i, ui::InputDeviceType::INPUT_DEVICE_EXTERNAL, "", | |
| 108 gfx::Size(256, 256), 0)); | |
| 109 } | |
| 110 | |
| 111 DisplayInfoList displays; | |
| 112 displays.push_back(displays_[3]); | |
| 113 | |
| 114 test::ScopedSetInternalDisplayId set_internal(display_manager(), | |
| 115 displays_[0].id()); | |
| 116 AssociateTouchscreens(&displays, devices); | |
| 117 | |
| 118 for (int i = 0; i < 5; ++i) | |
| 119 EXPECT_EQ(i, displays[0].input_devices()[i]); | |
| 120 } | |
| 121 | |
| 122 TEST_F(TouchscreenUtilTest, OneToOneMapping) { | |
| 123 std::vector<ui::TouchscreenDevice> devices; | |
| 124 devices.push_back( | |
| 125 ui::TouchscreenDevice(1, ui::InputDeviceType::INPUT_DEVICE_EXTERNAL, "1", | |
| 126 gfx::Size(800, 600), 0)); | |
| 127 devices.push_back( | |
| 128 ui::TouchscreenDevice(2, ui::InputDeviceType::INPUT_DEVICE_EXTERNAL, "2", | |
| 129 gfx::Size(1024, 768), 0)); | |
| 130 | |
| 131 test::ScopedSetInternalDisplayId set_internal(display_manager(), | |
| 132 displays_[0].id()); | |
| 133 AssociateTouchscreens(&displays_, devices); | |
| 134 | |
| 135 EXPECT_EQ(0u, displays_[0].input_devices().size()); | |
| 136 EXPECT_EQ(1u, displays_[1].input_devices().size()); | |
| 137 EXPECT_EQ(1, displays_[1].input_devices()[0]); | |
| 138 EXPECT_EQ(0u, displays_[2].input_devices().size()); | |
| 139 EXPECT_EQ(1u, displays_[3].input_devices().size()); | |
| 140 EXPECT_EQ(2, displays_[3].input_devices()[0]); | |
| 141 } | |
| 142 | |
| 143 TEST_F(TouchscreenUtilTest, MapToCorrectDisplaySize) { | |
| 144 std::vector<ui::TouchscreenDevice> devices; | |
| 145 devices.push_back( | |
| 146 ui::TouchscreenDevice(2, ui::InputDeviceType::INPUT_DEVICE_EXTERNAL, "2", | |
| 147 gfx::Size(1024, 768), 0)); | |
| 148 | |
| 149 test::ScopedSetInternalDisplayId set_internal(display_manager(), | |
| 150 displays_[0].id()); | |
| 151 AssociateTouchscreens(&displays_, devices); | |
| 152 | |
| 153 EXPECT_EQ(0u, displays_[0].input_devices().size()); | |
| 154 EXPECT_EQ(0u, displays_[1].input_devices().size()); | |
| 155 EXPECT_EQ(0u, displays_[2].input_devices().size()); | |
| 156 EXPECT_EQ(1u, displays_[3].input_devices().size()); | |
| 157 EXPECT_EQ(2, displays_[3].input_devices()[0]); | |
| 158 } | |
| 159 | |
| 160 TEST_F(TouchscreenUtilTest, MapWhenSizeDiffersByOne) { | |
| 161 std::vector<ui::TouchscreenDevice> devices; | |
| 162 devices.push_back( | |
| 163 ui::TouchscreenDevice(1, ui::InputDeviceType::INPUT_DEVICE_EXTERNAL, "1", | |
| 164 gfx::Size(801, 600), 0)); | |
| 165 devices.push_back( | |
| 166 ui::TouchscreenDevice(2, ui::InputDeviceType::INPUT_DEVICE_EXTERNAL, "2", | |
| 167 gfx::Size(1023, 768), 0)); | |
| 168 | |
| 169 test::ScopedSetInternalDisplayId set_internal(display_manager(), | |
| 170 displays_[0].id()); | |
| 171 AssociateTouchscreens(&displays_, devices); | |
| 172 | |
| 173 EXPECT_EQ(0u, displays_[0].input_devices().size()); | |
| 174 EXPECT_EQ(1u, displays_[1].input_devices().size()); | |
| 175 EXPECT_EQ(1, displays_[1].input_devices()[0]); | |
| 176 EXPECT_EQ(0u, displays_[2].input_devices().size()); | |
| 177 EXPECT_EQ(1u, displays_[3].input_devices().size()); | |
| 178 EXPECT_EQ(2, displays_[3].input_devices()[0]); | |
| 179 } | |
| 180 | |
| 181 TEST_F(TouchscreenUtilTest, MapWhenSizesDoNotMatch) { | |
| 182 std::vector<ui::TouchscreenDevice> devices; | |
| 183 devices.push_back( | |
| 184 ui::TouchscreenDevice(1, ui::InputDeviceType::INPUT_DEVICE_EXTERNAL, "1", | |
| 185 gfx::Size(1022, 768), 0)); | |
| 186 devices.push_back( | |
| 187 ui::TouchscreenDevice(2, ui::InputDeviceType::INPUT_DEVICE_EXTERNAL, "2", | |
| 188 gfx::Size(802, 600), 0)); | |
| 189 | |
| 190 DisplayInfoList displays; | |
| 191 displays.push_back(displays_[0]); | |
| 192 displays.push_back(displays_[1]); | |
| 193 | |
| 194 test::ScopedSetInternalDisplayId set_internal(display_manager(), | |
| 195 displays[0].id()); | |
| 196 AssociateTouchscreens(&displays, devices); | |
| 197 | |
| 198 EXPECT_EQ(0u, displays[0].input_devices().size()); | |
| 199 EXPECT_EQ(2u, displays[1].input_devices().size()); | |
| 200 EXPECT_EQ(1, displays[1].input_devices()[0]); | |
| 201 EXPECT_EQ(2, displays[1].input_devices()[1]); | |
| 202 } | |
| 203 | |
| 204 TEST_F(TouchscreenUtilTest, MapInternalTouchscreen) { | |
| 205 std::vector<ui::TouchscreenDevice> devices; | |
| 206 devices.push_back( | |
| 207 ui::TouchscreenDevice(1, ui::InputDeviceType::INPUT_DEVICE_EXTERNAL, "1", | |
| 208 gfx::Size(1920, 1080), 0)); | |
| 209 devices.push_back( | |
| 210 ui::TouchscreenDevice(2, ui::InputDeviceType::INPUT_DEVICE_INTERNAL, "2", | |
| 211 gfx::Size(9999, 888), 0)); | |
| 212 | |
| 213 DisplayInfoList displays; | |
| 214 displays.push_back(displays_[0]); | |
| 215 displays.push_back(displays_[1]); | |
| 216 | |
| 217 test::ScopedSetInternalDisplayId set_internal(display_manager(), | |
| 218 displays[0].id()); | |
| 219 AssociateTouchscreens(&displays, devices); | |
| 220 | |
| 221 // Internal touchscreen is always mapped to internal display. | |
| 222 EXPECT_EQ(1u, displays[0].input_devices().size()); | |
| 223 EXPECT_EQ(2, displays[0].input_devices()[0]); | |
| 224 EXPECT_EQ(1u, displays[1].input_devices().size()); | |
| 225 EXPECT_EQ(1, displays[1].input_devices()[0]); | |
| 226 } | |
| 227 | |
| 228 TEST_F(TouchscreenUtilTest, MultipleInternal) { | |
| 229 std::vector<ui::TouchscreenDevice> devices; | |
| 230 devices.push_back( | |
| 231 ui::TouchscreenDevice(1, ui::InputDeviceType::INPUT_DEVICE_INTERNAL, "1", | |
| 232 gfx::Size(1920, 1080), 0)); | |
| 233 devices.push_back( | |
| 234 ui::TouchscreenDevice(2, ui::InputDeviceType::INPUT_DEVICE_INTERNAL, "2", | |
| 235 gfx::Size(1920, 1080), 0)); | |
| 236 | |
| 237 test::ScopedSetInternalDisplayId set_internal(display_manager(), | |
| 238 displays_[0].id()); | |
| 239 AssociateTouchscreens(&displays_, devices); | |
| 240 | |
| 241 EXPECT_EQ(2u, displays_[0].input_devices().size()); | |
| 242 EXPECT_EQ(0u, displays_[1].input_devices().size()); | |
| 243 EXPECT_EQ(0u, displays_[2].input_devices().size()); | |
| 244 EXPECT_EQ(0u, displays_[3].input_devices().size()); | |
| 245 } | |
| 246 | |
| 247 TEST_F(TouchscreenUtilTest, MultipleInternalAndExternal) { | |
| 248 std::vector<ui::TouchscreenDevice> devices; | |
| 249 devices.push_back( | |
| 250 ui::TouchscreenDevice(1, ui::InputDeviceType::INPUT_DEVICE_INTERNAL, "1", | |
| 251 gfx::Size(1920, 1080), 0)); | |
| 252 devices.push_back( | |
| 253 ui::TouchscreenDevice(2, ui::InputDeviceType::INPUT_DEVICE_INTERNAL, "2", | |
| 254 gfx::Size(1920, 1080), 0)); | |
| 255 devices.push_back( | |
| 256 ui::TouchscreenDevice(3, ui::InputDeviceType::INPUT_DEVICE_EXTERNAL, "3", | |
| 257 gfx::Size(1024, 768), 0)); | |
| 258 | |
| 259 test::ScopedSetInternalDisplayId set_internal(display_manager(), | |
| 260 displays_[0].id()); | |
| 261 AssociateTouchscreens(&displays_, devices); | |
| 262 | |
| 263 EXPECT_EQ(2u, displays_[0].input_devices().size()); | |
| 264 EXPECT_EQ(1, displays_[0].input_devices()[0]); | |
| 265 EXPECT_EQ(2, displays_[0].input_devices()[1]); | |
| 266 EXPECT_EQ(0u, displays_[1].input_devices().size()); | |
| 267 EXPECT_EQ(0u, displays_[2].input_devices().size()); | |
| 268 EXPECT_EQ(1u, displays_[3].input_devices().size()); | |
| 269 EXPECT_EQ(3, displays_[3].input_devices()[0]); | |
| 270 } | |
| 271 | |
| 272 // crbug.com/515201 | |
| 273 TEST_F(TouchscreenUtilTest, TestWithNoInternalDisplay) { | |
| 274 std::vector<ui::TouchscreenDevice> devices; | |
| 275 devices.push_back( | |
| 276 ui::TouchscreenDevice(1, ui::InputDeviceType::INPUT_DEVICE_EXTERNAL, "1", | |
| 277 gfx::Size(1920, 1080), 0)); | |
| 278 devices.push_back( | |
| 279 ui::TouchscreenDevice(2, ui::InputDeviceType::INPUT_DEVICE_INTERNAL, "2", | |
| 280 gfx::Size(9999, 888), 0)); | |
| 281 | |
| 282 // Internal touchscreen should not be associated with any display | |
| 283 AssociateTouchscreens(&displays_, devices); | |
| 284 | |
| 285 EXPECT_EQ(1u, displays_[0].input_devices().size()); | |
| 286 EXPECT_EQ(1, displays_[0].input_devices()[0]); | |
| 287 EXPECT_EQ(0u, displays_[1].input_devices().size()); | |
| 288 EXPECT_EQ(0u, displays_[2].input_devices().size()); | |
| 289 EXPECT_EQ(0u, displays_[3].input_devices().size()); | |
| 290 } | |
| 291 | |
| 292 } // namespace display | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2540313002:
Split //ui/display and create //ui/display/manager. (Closed)
