display_change_notifier_unittest.cc 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475
  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. #include "ui/display/display_change_notifier.h"
  5. #include <stdint.h>
  6. #include "testing/gtest/include/gtest/gtest.h"
  7. #include "ui/display/display.h"
  8. #include "ui/display/display_observer.h"
  9. namespace display {
  10. class MockDisplayObserver : public DisplayObserver {
  11. public:
  12. MockDisplayObserver()
  13. : display_added_(0),
  14. display_removed_(0),
  15. display_changed_(0),
  16. latest_metrics_change_(DisplayObserver::DISPLAY_METRIC_NONE) {}
  17. MockDisplayObserver(const MockDisplayObserver&) = delete;
  18. MockDisplayObserver& operator=(const MockDisplayObserver&) = delete;
  19. ~MockDisplayObserver() override {}
  20. void OnDisplayAdded(const Display& display) override { display_added_++; }
  21. void OnDisplayRemoved(const Display& display) override { display_removed_++; }
  22. void OnDisplayMetricsChanged(const Display& display,
  23. uint32_t metrics) override {
  24. display_changed_++;
  25. latest_metrics_change_ = metrics;
  26. }
  27. int display_added() const { return display_added_; }
  28. int display_removed() const { return display_removed_; }
  29. int display_changed() const { return display_changed_; }
  30. uint32_t latest_metrics_change() const { return latest_metrics_change_; }
  31. protected:
  32. int display_added_;
  33. int display_removed_;
  34. int display_changed_;
  35. uint32_t latest_metrics_change_;
  36. };
  37. TEST(DisplayChangeNotifierTest, AddObserver_Smoke) {
  38. DisplayChangeNotifier change_notifier;
  39. MockDisplayObserver observer;
  40. change_notifier.NotifyDisplaysChanged(std::vector<Display>(),
  41. std::vector<Display>(1, Display()));
  42. EXPECT_EQ(0, observer.display_added());
  43. change_notifier.AddObserver(&observer);
  44. change_notifier.NotifyDisplaysChanged(std::vector<Display>(),
  45. std::vector<Display>(1, Display()));
  46. EXPECT_EQ(1, observer.display_added());
  47. }
  48. TEST(DisplayChangeNotifier, RemoveObserver_Smoke) {
  49. DisplayChangeNotifier change_notifier;
  50. MockDisplayObserver observer;
  51. change_notifier.NotifyDisplaysChanged(std::vector<Display>(),
  52. std::vector<Display>(1, Display()));
  53. EXPECT_EQ(0, observer.display_added());
  54. change_notifier.AddObserver(&observer);
  55. change_notifier.RemoveObserver(&observer);
  56. change_notifier.NotifyDisplaysChanged(std::vector<Display>(),
  57. std::vector<Display>(1, Display()));
  58. EXPECT_EQ(0, observer.display_added());
  59. }
  60. TEST(DisplayChangeNotifierTest, RemoveObserver_Unknown) {
  61. DisplayChangeNotifier change_notifier;
  62. MockDisplayObserver observer;
  63. change_notifier.RemoveObserver(&observer);
  64. // Should not crash.
  65. }
  66. TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Removed) {
  67. DisplayChangeNotifier change_notifier;
  68. // If the previous display array is empty, no removal.
  69. {
  70. MockDisplayObserver observer;
  71. change_notifier.AddObserver(&observer);
  72. std::vector<Display> old_displays, new_displays;
  73. new_displays.push_back(Display());
  74. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  75. EXPECT_EQ(0, observer.display_removed());
  76. change_notifier.RemoveObserver(&observer);
  77. }
  78. // If the previous and new display array are empty, no removal.
  79. {
  80. MockDisplayObserver observer;
  81. change_notifier.AddObserver(&observer);
  82. std::vector<Display> old_displays, new_displays;
  83. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  84. EXPECT_EQ(0, observer.display_removed());
  85. change_notifier.RemoveObserver(&observer);
  86. }
  87. // If the new display array is empty, there are as many removal as old
  88. // displays.
  89. {
  90. MockDisplayObserver observer;
  91. change_notifier.AddObserver(&observer);
  92. std::vector<Display> old_displays, new_displays;
  93. old_displays.push_back(Display());
  94. old_displays.push_back(Display());
  95. old_displays.push_back(Display());
  96. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  97. EXPECT_EQ(3, observer.display_removed());
  98. change_notifier.RemoveObserver(&observer);
  99. }
  100. // If displays don't use ids, as long as the new display array has one
  101. // element, there are no removals.
  102. {
  103. MockDisplayObserver observer;
  104. change_notifier.AddObserver(&observer);
  105. std::vector<Display> old_displays, new_displays;
  106. old_displays.push_back(Display());
  107. old_displays.push_back(Display());
  108. old_displays.push_back(Display());
  109. new_displays.push_back(Display());
  110. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  111. EXPECT_EQ(0, observer.display_removed());
  112. change_notifier.RemoveObserver(&observer);
  113. }
  114. // If displays use ids (and they are unique), ids not present in the new
  115. // display array will be marked as removed.
  116. {
  117. MockDisplayObserver observer;
  118. change_notifier.AddObserver(&observer);
  119. std::vector<Display> old_displays, new_displays;
  120. old_displays.push_back(Display(1));
  121. old_displays.push_back(Display(2));
  122. old_displays.push_back(Display(3));
  123. new_displays.push_back(Display(2));
  124. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  125. EXPECT_EQ(2, observer.display_removed());
  126. change_notifier.RemoveObserver(&observer);
  127. }
  128. }
  129. TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Added) {
  130. DisplayChangeNotifier change_notifier;
  131. // If the new display array is empty, no addition.
  132. {
  133. MockDisplayObserver observer;
  134. change_notifier.AddObserver(&observer);
  135. std::vector<Display> old_displays, new_displays;
  136. old_displays.push_back(Display());
  137. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  138. EXPECT_EQ(0, observer.display_added());
  139. change_notifier.RemoveObserver(&observer);
  140. }
  141. // If the old and new display arrays are empty, no addition.
  142. {
  143. MockDisplayObserver observer;
  144. change_notifier.AddObserver(&observer);
  145. std::vector<Display> old_displays, new_displays;
  146. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  147. EXPECT_EQ(0, observer.display_added());
  148. change_notifier.RemoveObserver(&observer);
  149. }
  150. // If the old display array is empty, there are as many addition as new
  151. // displays.
  152. {
  153. MockDisplayObserver observer;
  154. change_notifier.AddObserver(&observer);
  155. std::vector<Display> old_displays, new_displays;
  156. new_displays.push_back(Display());
  157. new_displays.push_back(Display());
  158. new_displays.push_back(Display());
  159. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  160. EXPECT_EQ(3, observer.display_added());
  161. change_notifier.RemoveObserver(&observer);
  162. }
  163. // If displays don't use ids, as long as the old display array has one
  164. // element, there are no additions.
  165. {
  166. MockDisplayObserver observer;
  167. change_notifier.AddObserver(&observer);
  168. std::vector<Display> old_displays, new_displays;
  169. old_displays.push_back(Display());
  170. new_displays.push_back(Display());
  171. new_displays.push_back(Display());
  172. new_displays.push_back(Display());
  173. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  174. EXPECT_EQ(0, observer.display_added());
  175. change_notifier.RemoveObserver(&observer);
  176. }
  177. // If displays use ids (and they are unique), ids not present in the old
  178. // display array will be marked as added.
  179. {
  180. MockDisplayObserver observer;
  181. change_notifier.AddObserver(&observer);
  182. std::vector<Display> old_displays, new_displays;
  183. old_displays.push_back(Display(1));
  184. new_displays.push_back(Display(1));
  185. new_displays.push_back(Display(2));
  186. new_displays.push_back(Display(3));
  187. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  188. EXPECT_EQ(2, observer.display_added());
  189. change_notifier.RemoveObserver(&observer);
  190. }
  191. }
  192. TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_Smoke) {
  193. DisplayChangeNotifier change_notifier;
  194. // If the old display array is empty, no change.
  195. {
  196. MockDisplayObserver observer;
  197. change_notifier.AddObserver(&observer);
  198. std::vector<Display> old_displays, new_displays;
  199. new_displays.push_back(Display());
  200. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  201. EXPECT_EQ(0, observer.display_changed());
  202. change_notifier.RemoveObserver(&observer);
  203. }
  204. // If the new display array is empty, no change.
  205. {
  206. MockDisplayObserver observer;
  207. change_notifier.AddObserver(&observer);
  208. std::vector<Display> old_displays, new_displays;
  209. old_displays.push_back(Display());
  210. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  211. EXPECT_EQ(0, observer.display_changed());
  212. change_notifier.RemoveObserver(&observer);
  213. }
  214. // If the old and new display arrays are empty, no change.
  215. {
  216. MockDisplayObserver observer;
  217. change_notifier.AddObserver(&observer);
  218. std::vector<Display> old_displays, new_displays;
  219. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  220. EXPECT_EQ(0, observer.display_changed());
  221. change_notifier.RemoveObserver(&observer);
  222. }
  223. // If there is an intersection between old and new displays but there are no
  224. // metrics changes, there is no display change.
  225. {
  226. MockDisplayObserver observer;
  227. change_notifier.AddObserver(&observer);
  228. std::vector<Display> old_displays, new_displays;
  229. old_displays.push_back(Display(1));
  230. new_displays.push_back(Display(1));
  231. new_displays.push_back(Display(2));
  232. new_displays.push_back(Display(3));
  233. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  234. EXPECT_EQ(0, observer.display_changed());
  235. change_notifier.RemoveObserver(&observer);
  236. }
  237. }
  238. TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_Bounds) {
  239. DisplayChangeNotifier change_notifier;
  240. {
  241. MockDisplayObserver observer;
  242. change_notifier.AddObserver(&observer);
  243. std::vector<Display> old_displays, new_displays;
  244. old_displays.push_back(Display(1, gfx::Rect(0, 0, 200, 200)));
  245. new_displays.push_back(Display(1, gfx::Rect(0, 0, 200, 200)));
  246. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  247. EXPECT_EQ(0, observer.display_changed());
  248. change_notifier.RemoveObserver(&observer);
  249. }
  250. {
  251. MockDisplayObserver observer;
  252. change_notifier.AddObserver(&observer);
  253. std::vector<Display> old_displays, new_displays;
  254. old_displays.push_back(Display(1, gfx::Rect(0, 0, 200, 200)));
  255. new_displays.push_back(Display(1, gfx::Rect(10, 10, 300, 300)));
  256. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  257. EXPECT_EQ(1, observer.display_changed());
  258. uint32_t metrics_change = DisplayObserver::DISPLAY_METRIC_BOUNDS |
  259. DisplayObserver::DISPLAY_METRIC_WORK_AREA;
  260. EXPECT_EQ(metrics_change, observer.latest_metrics_change());
  261. change_notifier.RemoveObserver(&observer);
  262. }
  263. {
  264. MockDisplayObserver observer;
  265. change_notifier.AddObserver(&observer);
  266. std::vector<Display> old_displays, new_displays;
  267. old_displays.push_back(Display(1, gfx::Rect(0, 0, 200, 200)));
  268. new_displays.push_back(Display(1, gfx::Rect(0, 0, 200, 200)));
  269. new_displays[0].set_bounds(gfx::Rect(10, 10, 300, 300));
  270. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  271. EXPECT_EQ(1, observer.display_changed());
  272. EXPECT_EQ(static_cast<uint32_t>(DisplayObserver::DISPLAY_METRIC_BOUNDS),
  273. observer.latest_metrics_change());
  274. change_notifier.RemoveObserver(&observer);
  275. }
  276. }
  277. TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_Rotation) {
  278. DisplayChangeNotifier change_notifier;
  279. MockDisplayObserver observer;
  280. change_notifier.AddObserver(&observer);
  281. std::vector<Display> old_displays, new_displays;
  282. old_displays.push_back(Display(1));
  283. old_displays[0].SetRotationAsDegree(0);
  284. new_displays.push_back(Display(1));
  285. new_displays[0].SetRotationAsDegree(180);
  286. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  287. EXPECT_EQ(1, observer.display_changed());
  288. EXPECT_EQ(static_cast<uint32_t>(DisplayObserver::DISPLAY_METRIC_ROTATION),
  289. observer.latest_metrics_change());
  290. }
  291. TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_WorkArea) {
  292. DisplayChangeNotifier change_notifier;
  293. MockDisplayObserver observer;
  294. change_notifier.AddObserver(&observer);
  295. std::vector<Display> old_displays, new_displays;
  296. old_displays.push_back(Display(1));
  297. old_displays[0].set_work_area(gfx::Rect(0, 0, 200, 200));
  298. new_displays.push_back(Display(1));
  299. new_displays[0].set_work_area(gfx::Rect(20, 20, 300, 300));
  300. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  301. EXPECT_EQ(1, observer.display_changed());
  302. EXPECT_EQ(static_cast<uint32_t>(DisplayObserver::DISPLAY_METRIC_WORK_AREA),
  303. observer.latest_metrics_change());
  304. }
  305. TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_DSF) {
  306. DisplayChangeNotifier change_notifier;
  307. MockDisplayObserver observer;
  308. change_notifier.AddObserver(&observer);
  309. std::vector<Display> old_displays, new_displays;
  310. old_displays.push_back(Display(1));
  311. old_displays[0].set_device_scale_factor(1.f);
  312. new_displays.push_back(Display(1));
  313. new_displays[0].set_device_scale_factor(2.f);
  314. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  315. EXPECT_EQ(1, observer.display_changed());
  316. EXPECT_EQ(static_cast<uint32_t>(
  317. DisplayObserver::DISPLAY_METRIC_DEVICE_SCALE_FACTOR),
  318. observer.latest_metrics_change());
  319. }
  320. TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_Multi_Displays) {
  321. DisplayChangeNotifier change_notifier;
  322. MockDisplayObserver observer;
  323. change_notifier.AddObserver(&observer);
  324. std::vector<Display> old_displays, new_displays;
  325. old_displays.push_back(Display(1));
  326. old_displays.push_back(Display(2));
  327. old_displays.push_back(Display(3));
  328. new_displays.push_back(Display(1));
  329. new_displays.push_back(Display(2));
  330. new_displays.push_back(Display(3));
  331. old_displays[0].set_device_scale_factor(1.f);
  332. new_displays[0].set_device_scale_factor(2.f);
  333. old_displays[1].set_bounds(gfx::Rect(0, 0, 200, 200));
  334. new_displays[1].set_bounds(gfx::Rect(0, 0, 400, 400));
  335. old_displays[2].SetRotationAsDegree(0);
  336. new_displays[2].SetRotationAsDegree(90);
  337. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  338. EXPECT_EQ(3, observer.display_changed());
  339. }
  340. TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_Multi_Metrics) {
  341. DisplayChangeNotifier change_notifier;
  342. MockDisplayObserver observer;
  343. change_notifier.AddObserver(&observer);
  344. std::vector<Display> old_displays, new_displays;
  345. old_displays.push_back(Display(1, gfx::Rect(0, 0, 200, 200)));
  346. old_displays[0].set_device_scale_factor(1.f);
  347. old_displays[0].SetRotationAsDegree(0);
  348. new_displays.push_back(Display(1, gfx::Rect(100, 100, 200, 200)));
  349. new_displays[0].set_device_scale_factor(2.f);
  350. new_displays[0].SetRotationAsDegree(90);
  351. change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
  352. EXPECT_EQ(1, observer.display_changed());
  353. uint32_t metrics = DisplayObserver::DISPLAY_METRIC_BOUNDS |
  354. DisplayObserver::DISPLAY_METRIC_ROTATION |
  355. DisplayObserver::DISPLAY_METRIC_WORK_AREA |
  356. DisplayObserver::DISPLAY_METRIC_DEVICE_SCALE_FACTOR;
  357. EXPECT_EQ(metrics, observer.latest_metrics_change());
  358. }
  359. } // namespace display