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(DisplayChangeNotifier, RemoveObserver_Smoke) {
  74   DisplayChangeNotifier change_notifier;
  75   MockDisplayObserver observer;
  76
  77   change_notifier.NotifyDisplaysChanged(
  78     std::vector<Display>(), std::vector<Display>(1, Display()));
  79   EXPECT_EQ(0, observer.display_added());
  80
  81   change_notifier.AddObserver(&observer);
  82   change_notifier.RemoveObserver(&observer);
  83
  84   change_notifier.NotifyDisplaysChanged(
  85     std::vector<Display>(), std::vector<Display>(1, Display()));
  86   EXPECT_EQ(0, observer.display_added());
  87 }
  88
  89 TEST(DisplayChangeNotifierTest, RemoveObserver_Unknown) {
  90   DisplayChangeNotifier change_notifier;
  91   MockDisplayObserver observer;
  92
  93   change_notifier.RemoveObserver(&observer);
  94   // Should not crash.
  95 }
  96
  97 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Removed) {
  98   DisplayChangeNotifier change_notifier;
  99
 100   // If the previous display array is empty, no removal.
 101   {
 102     MockDisplayObserver observer;
 103     change_notifier.AddObserver(&observer);
 104
 105     std::vector<Display> old_displays, new_displays;
 106     new_displays.push_back(Display());
 107
 108     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 109     EXPECT_EQ(0, observer.display_removed());
 110
 111     change_notifier.RemoveObserver(&observer);
 112   }
 113
 114   // If the previous and new display array are empty, no removal.
 115   {
 116     MockDisplayObserver observer;
 117     change_notifier.AddObserver(&observer);
 118
 119     std::vector<Display> old_displays, new_displays;
 120
 121     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 122     EXPECT_EQ(0, observer.display_removed());
 123
 124     change_notifier.RemoveObserver(&observer);
 125   }
 126
 127   // If the new display array is empty, there are as many removal as old
 128   // displays.
 129   {
 130     MockDisplayObserver observer;
 131     change_notifier.AddObserver(&observer);
 132
 133     std::vector<Display> old_displays, new_displays;
 134     old_displays.push_back(Display());
 135     old_displays.push_back(Display());
 136     old_displays.push_back(Display());
 137
 138     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 139     EXPECT_EQ(3, observer.display_removed());
 140
 141     change_notifier.RemoveObserver(&observer);
 142   }
 143
 144   // If displays don't use ids, as long as the new display array has one
 145   // element, there are no removals.
 146   {
 147     MockDisplayObserver observer;
 148     change_notifier.AddObserver(&observer);
 149
 150     std::vector<Display> old_displays, new_displays;
 151     old_displays.push_back(Display());
 152     old_displays.push_back(Display());
 153     old_displays.push_back(Display());
 154     new_displays.push_back(Display());
 155
 156     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 157     EXPECT_EQ(0, observer.display_removed());
 158
 159     change_notifier.RemoveObserver(&observer);
 160   }
 161
 162   // If displays use ids (and they are unique), ids not present in the new
 163   // display array will be marked as removed.
 164   {
 165     MockDisplayObserver observer;
 166     change_notifier.AddObserver(&observer);
 167
 168     std::vector<Display> old_displays, new_displays;
 169     old_displays.push_back(Display(1));
 170     old_displays.push_back(Display(2));
 171     old_displays.push_back(Display(3));
 172     new_displays.push_back(Display(2));
 173
 174     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 175     EXPECT_EQ(2, observer.display_removed());
 176
 177     change_notifier.RemoveObserver(&observer);
 178   }
 179 }
 180
 181 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Added) {
 182   DisplayChangeNotifier change_notifier;
 183
 184   // If the new display array is empty, no addition.
 185   {
 186     MockDisplayObserver observer;
 187     change_notifier.AddObserver(&observer);
 188
 189     std::vector<Display> old_displays, new_displays;
 190     old_displays.push_back(Display());
 191
 192     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 193     EXPECT_EQ(0, observer.display_added());
 194
 195     change_notifier.RemoveObserver(&observer);
 196   }
 197
 198   // If the old and new display arrays are empty, no addition.
 199   {
 200     MockDisplayObserver observer;
 201     change_notifier.AddObserver(&observer);
 202
 203     std::vector<Display> old_displays, new_displays;
 204
 205     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 206     EXPECT_EQ(0, observer.display_added());
 207
 208     change_notifier.RemoveObserver(&observer);
 209   }
 210
 211   // If the old display array is empty, there are as many addition as new
 212   // displays.
 213   {
 214     MockDisplayObserver observer;
 215     change_notifier.AddObserver(&observer);
 216
 217     std::vector<Display> old_displays, new_displays;
 218     new_displays.push_back(Display());
 219     new_displays.push_back(Display());
 220     new_displays.push_back(Display());
 221
 222     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 223     EXPECT_EQ(3, observer.display_added());
 224
 225     change_notifier.RemoveObserver(&observer);
 226   }
 227
 228   // If displays don't use ids, as long as the old display array has one
 229   // element, there are no additions.
 230   {
 231     MockDisplayObserver observer;
 232     change_notifier.AddObserver(&observer);
 233
 234     std::vector<Display> old_displays, new_displays;
 235     old_displays.push_back(Display());
 236     new_displays.push_back(Display());
 237     new_displays.push_back(Display());
 238     new_displays.push_back(Display());
 239
 240     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 241     EXPECT_EQ(0, observer.display_added());
 242
 243     change_notifier.RemoveObserver(&observer);
 244   }
 245
 246   // If displays use ids (and they are unique), ids not present in the old
 247   // display array will be marked as added.
 248   {
 249     MockDisplayObserver observer;
 250     change_notifier.AddObserver(&observer);
 251
 252     std::vector<Display> old_displays, new_displays;
 253     old_displays.push_back(Display(1));
 254     new_displays.push_back(Display(1));
 255     new_displays.push_back(Display(2));
 256     new_displays.push_back(Display(3));
 257
 258     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 259     EXPECT_EQ(2, observer.display_added());
 260
 261     change_notifier.RemoveObserver(&observer);
 262   }
 263 }
 264
 265 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_Smoke) {
 266   DisplayChangeNotifier change_notifier;
 267
 268   // If the old display array is empty, no change.
 269   {
 270     MockDisplayObserver observer;
 271     change_notifier.AddObserver(&observer);
 272
 273     std::vector<Display> old_displays, new_displays;
 274     new_displays.push_back(Display());
 275
 276     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 277     EXPECT_EQ(0, observer.display_changed());
 278
 279     change_notifier.RemoveObserver(&observer);
 280   }
 281
 282   // If the new 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     old_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 old and new display arrays are empty, no change.
 297   {
 298     MockDisplayObserver observer;
 299     change_notifier.AddObserver(&observer);
 300
 301     std::vector<Display> old_displays, new_displays;
 302
 303     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 304     EXPECT_EQ(0, observer.display_changed());
 305
 306     change_notifier.RemoveObserver(&observer);
 307   }
 308
 309   // If there is an intersection between old and new displays but there are no
 310   // metrics changes, there is no display change.
 311   {
 312     MockDisplayObserver observer;
 313     change_notifier.AddObserver(&observer);
 314
 315     std::vector<Display> old_displays, new_displays;
 316     old_displays.push_back(Display(1));
 317     new_displays.push_back(Display(1));
 318     new_displays.push_back(Display(2));
 319     new_displays.push_back(Display(3));
 320
 321     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 322     EXPECT_EQ(0, observer.display_changed());
 323
 324     change_notifier.RemoveObserver(&observer);
 325   }
 326 }
 327
 328 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_Bounds) {
 329   DisplayChangeNotifier change_notifier;
 330
 331   {
 332     MockDisplayObserver observer;
 333     change_notifier.AddObserver(&observer);
 334
 335     std::vector<Display> old_displays, new_displays;
 336     old_displays.push_back(Display(1, Rect(0, 0, 200, 200)));
 337     new_displays.push_back(Display(1, Rect(0, 0, 200, 200)));
 338
 339     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 340     EXPECT_EQ(0, observer.display_changed());
 341
 342     change_notifier.RemoveObserver(&observer);
 343   }
 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(10, 10, 300, 300)));
 352
 353     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 354     EXPECT_EQ(1, observer.display_changed());
 355     uint32_t metrics_change = DisplayObserver::DISPLAY_METRIC_BOUNDS |
 356                                   DisplayObserver::DISPLAY_METRIC_WORK_AREA;
 357     EXPECT_EQ(metrics_change, observer.latest_metrics_change());
 358
 359     change_notifier.RemoveObserver(&observer);
 360   }
 361
 362   {
 363     MockDisplayObserver observer;
 364     change_notifier.AddObserver(&observer);
 365
 366     std::vector<Display> old_displays, new_displays;
 367     old_displays.push_back(Display(1, Rect(0, 0, 200, 200)));
 368     new_displays.push_back(Display(1, Rect(0, 0, 200, 200)));
 369     new_displays[0].set_bounds(Rect(10, 10, 300, 300));
 370
 371     change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 372     EXPECT_EQ(1, observer.display_changed());
 373     EXPECT_EQ(DisplayObserver::DISPLAY_METRIC_BOUNDS,
 374               observer.latest_metrics_change());
 375
 376     change_notifier.RemoveObserver(&observer);
 377   }
 378 }
 379
 380 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_Rotation) {
 381   DisplayChangeNotifier change_notifier;
 382   MockDisplayObserver observer;
 383   change_notifier.AddObserver(&observer);
 384
 385   std::vector<Display> old_displays, new_displays;
 386   old_displays.push_back(Display(1));
 387   old_displays[0].SetRotationAsDegree(0);
 388   new_displays.push_back(Display(1));
 389   new_displays[0].SetRotationAsDegree(180);
 390
 391   change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 392   EXPECT_EQ(1, observer.display_changed());
 393   EXPECT_EQ(DisplayObserver::DISPLAY_METRIC_ROTATION,
 394             observer.latest_metrics_change());
 395 }
 396
 397 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_WorkArea) {
 398   DisplayChangeNotifier change_notifier;
 399   MockDisplayObserver observer;
 400   change_notifier.AddObserver(&observer);
 401
 402   std::vector<Display> old_displays, new_displays;
 403   old_displays.push_back(Display(1));
 404   old_displays[0].set_work_area(Rect(0, 0, 200, 200));
 405   new_displays.push_back(Display(1));
 406   new_displays[0].set_work_area(Rect(20, 20, 300, 300));
 407
 408   change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 409   EXPECT_EQ(1, observer.display_changed());
 410   EXPECT_EQ(DisplayObserver::DISPLAY_METRIC_WORK_AREA,
 411             observer.latest_metrics_change());
 412 }
 413
 414 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_DSF) {
 415   DisplayChangeNotifier change_notifier;
 416   MockDisplayObserver observer;
 417   change_notifier.AddObserver(&observer);
 418
 419   std::vector<Display> old_displays, new_displays;
 420   old_displays.push_back(Display(1));
 421   old_displays[0].set_device_scale_factor(1.f);
 422   new_displays.push_back(Display(1));
 423   new_displays[0].set_device_scale_factor(2.f);
 424
 425   change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 426   EXPECT_EQ(1, observer.display_changed());
 427   EXPECT_EQ(DisplayObserver::DISPLAY_METRIC_DEVICE_SCALE_FACTOR,
 428             observer.latest_metrics_change());
 429 }
 430
 431 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_Multi_Displays) {
 432   DisplayChangeNotifier change_notifier;
 433   MockDisplayObserver observer;
 434   change_notifier.AddObserver(&observer);
 435
 436   std::vector<Display> old_displays, new_displays;
 437   old_displays.push_back(Display(1));
 438   old_displays.push_back(Display(2));
 439   old_displays.push_back(Display(3));
 440   new_displays.push_back(Display(1));
 441   new_displays.push_back(Display(2));
 442   new_displays.push_back(Display(3));
 443
 444   old_displays[0].set_device_scale_factor(1.f);
 445   new_displays[0].set_device_scale_factor(2.f);
 446
 447   old_displays[1].set_bounds(Rect(0, 0, 200, 200));
 448   new_displays[1].set_bounds(Rect(0, 0, 400, 400));
 449
 450   old_displays[2].SetRotationAsDegree(0);
 451   new_displays[2].SetRotationAsDegree(90);
 452
 453   change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 454   EXPECT_EQ(3, observer.display_changed());
 455 }
 456
 457 TEST(DisplayChangeNotifierTest, NotifyDisplaysChanged_Changed_Multi_Metrics) {
 458   DisplayChangeNotifier change_notifier;
 459   MockDisplayObserver observer;
 460   change_notifier.AddObserver(&observer);
 461
 462   std::vector<Display> old_displays, new_displays;
 463   old_displays.push_back(Display(1, Rect(0, 0, 200, 200)));
 464   old_displays[0].set_device_scale_factor(1.f);
 465   old_displays[0].SetRotationAsDegree(0);
 466
 467   new_displays.push_back(Display(1, Rect(100, 100, 200, 200)));
 468   new_displays[0].set_device_scale_factor(2.f);
 469   new_displays[0].SetRotationAsDegree(90);
 470
 471   change_notifier.NotifyDisplaysChanged(old_displays, new_displays);
 472   EXPECT_EQ(1, observer.display_changed());
 473   uint32_t metrics = DisplayObserver::DISPLAY_METRIC_BOUNDS |
 474                          DisplayObserver::DISPLAY_METRIC_ROTATION |
 475                          DisplayObserver::DISPLAY_METRIC_WORK_AREA |
 476                          DisplayObserver::DISPLAY_METRIC_DEVICE_SCALE_FACTOR;
 477   EXPECT_EQ(metrics, observer.latest_metrics_change());
 478 }
 479
 480 } // namespace gfx