ui/gfx/display_change_notifier_unittest.cc

   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/gfx/display_change_notifier.h"
   6
   7 #include "testing/gtest/include/gtest/gtest.h"
   8 #include "ui/gfx/display.h"
   9 #include "ui/gfx/display_observer.h"
  10
  11 namespace gfx {
  12
  13 class MockDisplayObserver : public DisplayObserver {
  14  public:
  15   MockDisplayObserver()
  16     : display_added_(0),
  17       display_removed_(0),
  18       display_changed_(0),
  19       latest_metrics_change_(DisplayObserver::DISPLAY_METRIC_NONE)
  20   {}
  21
  22   ~MockDisplayObserver() override {}
  23
  24   void OnDisplayAdded(const Display& display) override { display_added_++; }
  25
  26   void OnDisplayRemoved(const Display& display) override { display_removed_++; }
  27
  28   void OnDisplayMetricsChanged(const Display& display,
  29                                uint32_t metrics) override {
  30     display_changed_++;
  31     latest_metrics_change_ = metrics;
  32   }
  33
  34   int display_added() const {
  35     return display_added_;
  36   }
  37
  38   int display_removed() const {
  39     return display_removed_;
  40   }
  41
  42   int display_changed() const {
  43     return display_changed_;
  44   }
  45
  46   uint32_t latest_metrics_change() const {
  47     return latest_metrics_change_;
  48   }
  49
  50  protected:
  51   int display_added_;
  52   int display_removed_;
  53   int display_changed_;
  54   uint32_t latest_metrics_change_;
  55
  56   DISALLOW_COPY_AND_ASSIGN(MockDisplayObserver);
  57 };
  58
  59 TEST(DisplayChangeNotifierTest, AddObserver_Smoke) {
  60   DisplayChangeNotifier change_notifier;
  61   MockDisplayObserver observer;
  62
  63   change_notifier.NotifyDisplaysChanged(
  64     std::vector<Display>(), std::vector<Display>(1, Display()));
  65   EXPECT_EQ(0, observer.display_added());
  66
  67   change_notifier.AddObserver(&observer);
  68   change_notifier.NotifyDisplaysChanged(
  69     std::vector<Display>(), std::vector<Display>(1, Display()));
  70   EXPECT_EQ(1, observer.display_added());
  71 }
  72
  73 TEST(DisplayChangeNotifierTest, AddObserver_Null) {
  74   DisplayChangeNotifier change_notifier;
  75
  76   change_notifier.AddObserver(NULL);
  77   // Should not crash.
  78 }
  79
  80 TEST(DisplayChangeNotifier, RemoveObserver_Smoke) {
  81   DisplayChangeNotifier change_notifier;
  82   MockDisplayObserver observer;
  83
  84   change_notifier.NotifyDisplaysChanged(
  85     std::vector<Display>(), std::vector<Display>(1, Display()));
  86   EXPECT_EQ(0, observer.display_added());
  87
  88   change_notifier.AddObserver(&observer);
  89   change_notifier.RemoveObserver(&observer);
  90
  91   change_notifier.NotifyDisplaysChanged(
  92     std::vector<Display>(), std::vector<Display>(1, Display()));
  93   EXPECT_EQ(0, observer.display_added());
  94 }
  95
  96 TEST(DisplayChangeNotifierTest, RemoveObserver_Null) {
  97   DisplayChangeNotifier change_notifier;
  98
  99   change_notifier.RemoveObserver(NULL);
 100   // Should not crash.
 101 }
 102
 103 TEST(DisplayChangeNotifierTest, RemoveObserver_Unknown) {
 104   DisplayChangeNotifier change_notifier;
 105   MockDisplayObserver observer;
 106
 107   change_notifier.RemoveObserver(&observer);
 108   // Should not crash.
 109 }
 110
 111 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Removed) {
 112   DisplayChangeNotifier change_notifier;
 113
 114   // If the previous display array is empty, no removal.
 115   {
 116     MockDisplayObserver observer;
 117     change_notifier.AddObserver(&observer);
 118
 119     std::vector<Display> old_displays, new_displays;
 120     new_displays.push_back(Display());
 121
 122     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 123     EXPECT_EQ(0, observer.display_removed());
 124
 125     change_notifier.RemoveObserver(&observer);
 126   }
 127
 128   // If the previous and new display array are empty, no removal.
 129   {
 130     MockDisplayObserver observer;
 131     change_notifier.AddObserver(&observer);
 132
 133     std::vector<Display> old_displays, new_displays;
 134
 135     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 136     EXPECT_EQ(0, observer.display_removed());
 137
 138     change_notifier.RemoveObserver(&observer);
 139   }
 140
 141   // If the new display array is empty, there are as many removal as old
 142   // displays.
 143   {
 144     MockDisplayObserver observer;
 145     change_notifier.AddObserver(&observer);
 146
 147     std::vector<Display> old_displays, new_displays;
 148     old_displays.push_back(Display());
 149     old_displays.push_back(Display());
 150     old_displays.push_back(Display());
 151
 152     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 153     EXPECT_EQ(3, observer.display_removed());
 154
 155     change_notifier.RemoveObserver(&observer);
 156   }
 157
 158   // If displays don't use ids, as long as the new display array has one
 159   // element, there are no removals.
 160   {
 161     MockDisplayObserver observer;
 162     change_notifier.AddObserver(&observer);
 163
 164     std::vector<Display> old_displays, new_displays;
 165     old_displays.push_back(Display());
 166     old_displays.push_back(Display());
 167     old_displays.push_back(Display());
 168     new_displays.push_back(Display());
 169
 170     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 171     EXPECT_EQ(0, observer.display_removed());
 172
 173     change_notifier.RemoveObserver(&observer);
 174   }
 175
 176   // If displays use ids (and they are unique), ids not present in the new
 177   // display array will be marked as removed.
 178   {
 179     MockDisplayObserver observer;
 180     change_notifier.AddObserver(&observer);
 181
 182     std::vector<Display> old_displays, new_displays;
 183     old_displays.push_back(Display(1));
 184     old_displays.push_back(Display(2));
 185     old_displays.push_back(Display(3));
 186     new_displays.push_back(Display(2));
 187
 188     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 189     EXPECT_EQ(2, observer.display_removed());
 190
 191     change_notifier.RemoveObserver(&observer);
 192   }
 193 }
 194
 195 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Added) {
 196   DisplayChangeNotifier change_notifier;
 197
 198   // If the new display array is empty, no addition.
 199   {
 200     MockDisplayObserver observer;
 201     change_notifier.AddObserver(&observer);
 202
 203     std::vector<Display> old_displays, new_displays;
 204     old_displays.push_back(Display());
 205
 206     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 207     EXPECT_EQ(0, observer.display_added());
 208
 209     change_notifier.RemoveObserver(&observer);
 210   }
 211
 212   // If the old and new display arrays are empty, no addition.
 213   {
 214     MockDisplayObserver observer;
 215     change_notifier.AddObserver(&observer);
 216
 217     std::vector<Display> old_displays, new_displays;
 218
 219     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 220     EXPECT_EQ(0, observer.display_added());
 221
 222     change_notifier.RemoveObserver(&observer);
 223   }
 224
 225   // If the old display array is empty, there are as many addition as new
 226   // displays.
 227   {
 228     MockDisplayObserver observer;
 229     change_notifier.AddObserver(&observer);
 230
 231     std::vector<Display> old_displays, new_displays;
 232     new_displays.push_back(Display());
 233     new_displays.push_back(Display());
 234     new_displays.push_back(Display());
 235
 236     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 237     EXPECT_EQ(3, observer.display_added());
 238
 239     change_notifier.RemoveObserver(&observer);
 240   }
 241
 242   // If displays don't use ids, as long as the old display array has one
 243   // element, there are no additions.
 244   {
 245     MockDisplayObserver observer;
 246     change_notifier.AddObserver(&observer);
 247
 248     std::vector<Display> old_displays, new_displays;
 249     old_displays.push_back(Display());
 250     new_displays.push_back(Display());
 251     new_displays.push_back(Display());
 252     new_displays.push_back(Display());
 253
 254     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 255     EXPECT_EQ(0, observer.display_added());
 256
 257     change_notifier.RemoveObserver(&observer);
 258   }
 259
 260   // If displays use ids (and they are unique), ids not present in the old
 261   // display array will be marked as added.
 262   {
 263     MockDisplayObserver observer;
 264     change_notifier.AddObserver(&observer);
 265
 266     std::vector<Display> old_displays, new_displays;
 267     old_displays.push_back(Display(1));
 268     new_displays.push_back(Display(1));
 269     new_displays.push_back(Display(2));
 270     new_displays.push_back(Display(3));
 271
 272     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 273     EXPECT_EQ(2, observer.display_added());
 274
 275     change_notifier.RemoveObserver(&observer);
 276   }
 277 }
 278
 279 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_Smoke) {
 280   DisplayChangeNotifier change_notifier;
 281
 282   // If the old display array is empty, no change.
 283   {
 284     MockDisplayObserver observer;
 285     change_notifier.AddObserver(&observer);
 286
 287     std::vector<Display> old_displays, new_displays;
 288     new_displays.push_back(Display());
 289
 290     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 291     EXPECT_EQ(0, observer.display_changed());
 292
 293     change_notifier.RemoveObserver(&observer);
 294   }
 295
 296   // If the new display array is empty, no change.
 297   {
 298     MockDisplayObserver observer;
 299     change_notifier.AddObserver(&observer);
 300
 301     std::vector<Display> old_displays, new_displays;
 302     old_displays.push_back(Display());
 303
 304     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 305     EXPECT_EQ(0, observer.display_changed());
 306
 307     change_notifier.RemoveObserver(&observer);
 308   }
 309
 310   // If the old and new display arrays are empty, no change.
 311   {
 312     MockDisplayObserver observer;
 313     change_notifier.AddObserver(&observer);
 314
 315     std::vector<Display> old_displays, new_displays;
 316
 317     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 318     EXPECT_EQ(0, observer.display_changed());
 319
 320     change_notifier.RemoveObserver(&observer);
 321   }
 322
 323   // If there is an intersection between old and new displays but there are no
 324   // metrics changes, there is no display change.
 325   {
 326     MockDisplayObserver observer;
 327     change_notifier.AddObserver(&observer);
 328
 329     std::vector<Display> old_displays, new_displays;
 330     old_displays.push_back(Display(1));
 331     new_displays.push_back(Display(1));
 332     new_displays.push_back(Display(2));
 333     new_displays.push_back(Display(3));
 334
 335     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 336     EXPECT_EQ(0, observer.display_changed());
 337
 338     change_notifier.RemoveObserver(&observer);
 339   }
 340 }
 341
 342 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_Bounds) {
 343   DisplayChangeNotifier change_notifier;
 344
 345   {
 346     MockDisplayObserver observer;
 347     change_notifier.AddObserver(&observer);
 348
 349     std::vector<Display> old_displays, new_displays;
 350     old_displays.push_back(Display(1, Rect(0, 0, 200, 200)));
 351     new_displays.push_back(Display(1, Rect(0, 0, 200, 200)));
 352
 353     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 354     EXPECT_EQ(0, observer.display_changed());
 355
 356     change_notifier.RemoveObserver(&observer);
 357   }
 358
 359   {
 360     MockDisplayObserver observer;
 361     change_notifier.AddObserver(&observer);
 362
 363     std::vector<Display> old_displays, new_displays;
 364     old_displays.push_back(Display(1, Rect(0, 0, 200, 200)));
 365     new_displays.push_back(Display(1, Rect(10, 10, 300, 300)));
 366
 367     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 368     EXPECT_EQ(1, observer.display_changed());
 369     uint32_t metrics_change = DisplayObserver::DISPLAY_METRIC_BOUNDS |
 370                                   DisplayObserver::DISPLAY_METRIC_WORK_AREA;
 371     EXPECT_EQ(metrics_change, observer.latest_metrics_change());
 372
 373     change_notifier.RemoveObserver(&observer);
 374   }
 375
 376   {
 377     MockDisplayObserver observer;
 378     change_notifier.AddObserver(&observer);
 379
 380     std::vector<Display> old_displays, new_displays;
 381     old_displays.push_back(Display(1, Rect(0, 0, 200, 200)));
 382     new_displays.push_back(Display(1, Rect(0, 0, 200, 200)));
 383     new_displays[0].set_bounds(Rect(10, 10, 300, 300));
 384
 385     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 386     EXPECT_EQ(1, observer.display_changed());
 387     EXPECT_EQ(DisplayObserver::DISPLAY_METRIC_BOUNDS,
 388               observer.latest_metrics_change());
 389
 390     change_notifier.RemoveObserver(&observer);
 391   }
 392 }
 393
 394 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_Rotation) {
 395   DisplayChangeNotifier change_notifier;
 396   MockDisplayObserver observer;
 397   change_notifier.AddObserver(&observer);
 398
 399   std::vector<Display> old_displays, new_displays;
 400   old_displays.push_back(Display(1));
 401   old_displays[0].SetRotationAsDegree(0);
 402   new_displays.push_back(Display(1));
 403   new_displays[0].SetRotationAsDegree(180);
 404
 405   change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 406   EXPECT_EQ(1, observer.display_changed());
 407   EXPECT_EQ(DisplayObserver::DISPLAY_METRIC_ROTATION,
 408             observer.latest_metrics_change());
 409 }
 410
 411 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_WorkArea) {
 412   DisplayChangeNotifier change_notifier;
 413   MockDisplayObserver observer;
 414   change_notifier.AddObserver(&observer);
 415
 416   std::vector<Display> old_displays, new_displays;
 417   old_displays.push_back(Display(1));
 418   old_displays[0].set_work_area(Rect(0, 0, 200, 200));
 419   new_displays.push_back(Display(1));
 420   new_displays[0].set_work_area(Rect(20, 20, 300, 300));
 421
 422   change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 423   EXPECT_EQ(1, observer.display_changed());
 424   EXPECT_EQ(DisplayObserver::DISPLAY_METRIC_WORK_AREA,
 425             observer.latest_metrics_change());
 426 }
 427
 428 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_DSF) {
 429   DisplayChangeNotifier change_notifier;
 430   MockDisplayObserver observer;
 431   change_notifier.AddObserver(&observer);
 432
 433   std::vector<Display> old_displays, new_displays;
 434   old_displays.push_back(Display(1));
 435   old_displays[0].set_device_scale_factor(1.f);
 436   new_displays.push_back(Display(1));
 437   new_displays[0].set_device_scale_factor(2.f);
 438
 439   change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 440   EXPECT_EQ(1, observer.display_changed());
 441   EXPECT_EQ(DisplayObserver::DISPLAY_METRIC_DEVICE_SCALE_FACTOR,
 442             observer.latest_metrics_change());
 443 }
 444
 445 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_Multi_Displays) {
 446   DisplayChangeNotifier change_notifier;
 447   MockDisplayObserver observer;
 448   change_notifier.AddObserver(&observer);
 449
 450   std::vector<Display> old_displays, new_displays;
 451   old_displays.push_back(Display(1));
 452   old_displays.push_back(Display(2));
 453   old_displays.push_back(Display(3));
 454   new_displays.push_back(Display(1));
 455   new_displays.push_back(Display(2));
 456   new_displays.push_back(Display(3));
 457
 458   old_displays[0].set_device_scale_factor(1.f);
 459   new_displays[0].set_device_scale_factor(2.f);
 460
 461   old_displays[1].set_bounds(Rect(0, 0, 200, 200));
 462   new_displays[1].set_bounds(Rect(0, 0, 400, 400));
 463
 464   old_displays[2].SetRotationAsDegree(0);
 465   new_displays[2].SetRotationAsDegree(90);
 466
 467   change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 468   EXPECT_EQ(3, observer.display_changed());
 469 }
 470
 471 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_Multi_Metrics) {
 472   DisplayChangeNotifier change_notifier;
 473   MockDisplayObserver observer;
 474   change_notifier.AddObserver(&observer);
 475
 476   std::vector<Display> old_displays, new_displays;
 477   old_displays.push_back(Display(1, Rect(0, 0, 200, 200)));
 478   old_displays[0].set_device_scale_factor(1.f);
 479   old_displays[0].SetRotationAsDegree(0);
 480
 481   new_displays.push_back(Display(1, Rect(100, 100, 200, 200)));
 482   new_displays[0].set_device_scale_factor(2.f);
 483   new_displays[0].SetRotationAsDegree(90);
 484
 485   change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 486   EXPECT_EQ(1, observer.display_changed());
 487   uint32_t metrics = DisplayObserver::DISPLAY_METRIC_BOUNDS |
 488                          DisplayObserver::DISPLAY_METRIC_ROTATION |
 489                          DisplayObserver::DISPLAY_METRIC_WORK_AREA |
 490                          DisplayObserver::DISPLAY_METRIC_DEVICE_SCALE_FACTOR;
 491   EXPECT_EQ(metrics, observer.latest_metrics_change());
 492 }
 493
 494 } // namespace gfx