ui/display/chromeos/x11/native_display_event_dispatcher_x11_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 <X11/extensions/Xrandr.h>
   6
   7 #undef Bool
   8 #undef None
   9
  10 #include "base/test/simple_test_tick_clock.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12 #include "ui/display/chromeos/x11/display_mode_x11.h"
  13 #include "ui/display/chromeos/x11/display_snapshot_x11.h"
  14 #include "ui/display/chromeos/x11/native_display_delegate_x11.h"
  15 #include "ui/display/chromeos/x11/native_display_event_dispatcher_x11.h"
  16
  17 namespace ui {
  18
  19 namespace {
  20
  21 DisplaySnapshotX11* CreateOutput(int64_t id,
  22                                  DisplayConnectionType type,
  23                                  RROutput output,
  24                                  RRCrtc crtc) {
  25   static const DisplayModeX11* kDefaultDisplayMode =
  26       new DisplayModeX11(gfx::Size(1, 1), false, 60.0f, 20);
  27
  28   DisplaySnapshotX11* snapshot = new DisplaySnapshotX11(
  29       id,
  30       gfx::Point(0, 0),
  31       gfx::Size(0, 0),
  32       type,
  33       false,
  34       false,
  35       std::string(),
  36       std::vector<const DisplayMode*>(1, kDefaultDisplayMode),
  37       kDefaultDisplayMode,
  38       NULL,
  39       output,
  40       crtc,
  41       0);
  42
  43   return snapshot;
  44 }
  45
  46 DisplaySnapshotX11* CreateExternalOutput(RROutput output, RRCrtc crtc) {
  47   return CreateOutput(static_cast<int64_t>(output),
  48                       DISPLAY_CONNECTION_TYPE_UNKNOWN,
  49                       output,
  50                       crtc);
  51 }
  52
  53 DisplaySnapshotX11* CreateInternalOutput(RROutput output, RRCrtc crtc) {
  54   return CreateOutput(0,
  55                       DISPLAY_CONNECTION_TYPE_INTERNAL,
  56                       output,
  57                       crtc);
  58 }
  59
  60 class TestHelperDelegate : public NativeDisplayDelegateX11::HelperDelegate {
  61  public:
  62   TestHelperDelegate();
  63   ~TestHelperDelegate() override;
  64
  65   int num_calls_update_xrandr_config() const {
  66     return num_calls_update_xrandr_config_;
  67   }
  68
  69   int num_calls_notify_observers() const { return num_calls_notify_observers_; }
  70
  71   void set_cached_outputs(const std::vector<DisplaySnapshot*>& outputs) {
  72     cached_outputs_ = outputs;
  73   }
  74
  75   // NativeDisplayDelegateX11::HelperDelegate overrides:
  76   void UpdateXRandRConfiguration(const base::NativeEvent& event) override;
  77   const std::vector<DisplaySnapshot*>& GetCachedDisplays() const override;
  78   void NotifyDisplayObservers() override;
  79
  80  private:
  81   int num_calls_update_xrandr_config_;
  82   int num_calls_notify_observers_;
  83
  84   std::vector<DisplaySnapshot*> cached_outputs_;
  85
  86   DISALLOW_COPY_AND_ASSIGN(TestHelperDelegate);
  87 };
  88
  89 TestHelperDelegate::TestHelperDelegate()
  90     : num_calls_update_xrandr_config_(0), num_calls_notify_observers_(0) {}
  91
  92 TestHelperDelegate::~TestHelperDelegate() {}
  93
  94 void TestHelperDelegate::UpdateXRandRConfiguration(
  95     const base::NativeEvent& event) {
  96   ++num_calls_update_xrandr_config_;
  97 }
  98
  99 const std::vector<DisplaySnapshot*>& TestHelperDelegate::GetCachedDisplays()
 100     const {
 101   return cached_outputs_;
 102 }
 103
 104 void TestHelperDelegate::NotifyDisplayObservers() {
 105   ++num_calls_notify_observers_;
 106 }
 107
 108 ////////////////////////////////////////////////////////////////////////////////
 109 // NativeDisplayEventDispatcherX11Test
 110
 111 class NativeDisplayEventDispatcherX11Test : public testing::Test {
 112  public:
 113   NativeDisplayEventDispatcherX11Test();
 114   ~NativeDisplayEventDispatcherX11Test() override;
 115
 116  protected:
 117   void DispatchScreenChangeEvent();
 118   void DispatchOutputChangeEvent(RROutput output,
 119                                  RRCrtc crtc,
 120                                  RRMode mode,
 121                                  bool connected);
 122
 123   int xrandr_event_base_;
 124   scoped_ptr<TestHelperDelegate> helper_delegate_;
 125   scoped_ptr<NativeDisplayEventDispatcherX11> dispatcher_;
 126   base::SimpleTestTickClock* test_tick_clock_;  // Owned by |dispatcher_|.
 127
 128  private:
 129   DISALLOW_COPY_AND_ASSIGN(NativeDisplayEventDispatcherX11Test);
 130 };
 131
 132 NativeDisplayEventDispatcherX11Test::NativeDisplayEventDispatcherX11Test()
 133     : xrandr_event_base_(10),
 134       helper_delegate_(new TestHelperDelegate()),
 135       dispatcher_(new NativeDisplayEventDispatcherX11(helper_delegate_.get(),
 136                                                       xrandr_event_base_)),
 137       test_tick_clock_(new base::SimpleTestTickClock) {
 138   test_tick_clock_->Advance(base::TimeDelta::FromMilliseconds(1));
 139   dispatcher_->SetTickClockForTest(
 140       scoped_ptr<base::TickClock>(test_tick_clock_));
 141 }
 142
 143 NativeDisplayEventDispatcherX11Test::~NativeDisplayEventDispatcherX11Test() {}
 144
 145 void NativeDisplayEventDispatcherX11Test::DispatchScreenChangeEvent() {
 146   XRRScreenChangeNotifyEvent event = {0};
 147   event.type = xrandr_event_base_ + RRScreenChangeNotify;
 148
 149   dispatcher_->DispatchEvent(reinterpret_cast<const PlatformEvent>(&event));
 150 }
 151
 152 void NativeDisplayEventDispatcherX11Test::DispatchOutputChangeEvent(
 153     RROutput output,
 154     RRCrtc crtc,
 155     RRMode mode,
 156     bool connected) {
 157   XRROutputChangeNotifyEvent event = {0};
 158   event.type = xrandr_event_base_ + RRNotify;
 159   event.subtype = RRNotify_OutputChange;
 160   event.output = output;
 161   event.crtc = crtc;
 162   event.mode = mode;
 163   event.connection = connected ? RR_Connected : RR_Disconnected;
 164
 165   dispatcher_->DispatchEvent(reinterpret_cast<const PlatformEvent>(&event));
 166 }
 167
 168 }  // namespace
 169
 170 TEST_F(NativeDisplayEventDispatcherX11Test, OnScreenChangedEvent) {
 171   DispatchScreenChangeEvent();
 172   EXPECT_EQ(1, helper_delegate_->num_calls_update_xrandr_config());
 173   EXPECT_EQ(0, helper_delegate_->num_calls_notify_observers());
 174 }
 175
 176 TEST_F(NativeDisplayEventDispatcherX11Test, CheckNotificationOnFirstEvent) {
 177   DispatchOutputChangeEvent(1, 10, 20, true);
 178   EXPECT_EQ(0, helper_delegate_->num_calls_update_xrandr_config());
 179   EXPECT_EQ(1, helper_delegate_->num_calls_notify_observers());
 180 }
 181
 182 TEST_F(NativeDisplayEventDispatcherX11Test, CheckNotificationAfterSecondEvent) {
 183   DispatchOutputChangeEvent(1, 10, 20, true);
 184
 185   // Simulate addition of the first output to the cached output list.
 186   ScopedVector<DisplaySnapshot> outputs;
 187   outputs.push_back(CreateExternalOutput(1, 10));
 188   helper_delegate_->set_cached_outputs(outputs.get());
 189
 190   DispatchOutputChangeEvent(2, 11, 20, true);
 191   EXPECT_EQ(2, helper_delegate_->num_calls_notify_observers());
 192 }
 193
 194 TEST_F(NativeDisplayEventDispatcherX11Test, CheckNotificationOnDisconnect) {
 195   ScopedVector<DisplaySnapshot> outputs;
 196   outputs.push_back(CreateExternalOutput(1, 10));
 197   helper_delegate_->set_cached_outputs(outputs.get());
 198
 199   DispatchOutputChangeEvent(1, 10, 20, false);
 200   EXPECT_EQ(1, helper_delegate_->num_calls_notify_observers());
 201 }
 202
 203 TEST_F(NativeDisplayEventDispatcherX11Test, CheckNotificationOnModeChange) {
 204   ScopedVector<DisplaySnapshot> outputs;
 205   outputs.push_back(CreateExternalOutput(1, 10));
 206   helper_delegate_->set_cached_outputs(outputs.get());
 207
 208   DispatchOutputChangeEvent(1, 10, 21, true);
 209   EXPECT_EQ(1, helper_delegate_->num_calls_notify_observers());
 210 }
 211
 212 TEST_F(NativeDisplayEventDispatcherX11Test, CheckNotificationOnSecondOutput) {
 213   ScopedVector<DisplaySnapshot> outputs;
 214   outputs.push_back(CreateExternalOutput(1, 10));
 215   helper_delegate_->set_cached_outputs(outputs.get());
 216
 217   DispatchOutputChangeEvent(2, 11, 20, true);
 218   EXPECT_EQ(1, helper_delegate_->num_calls_notify_observers());
 219 }
 220
 221 TEST_F(NativeDisplayEventDispatcherX11Test, CheckNotificationOnDifferentCrtc) {
 222   ScopedVector<DisplaySnapshot> outputs;
 223   outputs.push_back(CreateExternalOutput(1, 10));
 224   helper_delegate_->set_cached_outputs(outputs.get());
 225
 226   DispatchOutputChangeEvent(1, 11, 20, true);
 227   EXPECT_EQ(1, helper_delegate_->num_calls_notify_observers());
 228 }
 229
 230 TEST_F(NativeDisplayEventDispatcherX11Test,
 231        CheckNotificationOnSecondOutputDisconnect) {
 232   ScopedVector<DisplaySnapshot> outputs;
 233   outputs.push_back(CreateExternalOutput(1, 10));
 234   outputs.push_back(CreateExternalOutput(2, 11));
 235   helper_delegate_->set_cached_outputs(outputs.get());
 236
 237   DispatchOutputChangeEvent(2, 11, 20, false);
 238   EXPECT_EQ(1, helper_delegate_->num_calls_notify_observers());
 239 }
 240
 241 TEST_F(NativeDisplayEventDispatcherX11Test,
 242        AvoidDuplicateNotificationOnSecondOutputDisconnect) {
 243   ScopedVector<DisplaySnapshot> outputs;
 244   outputs.push_back(CreateExternalOutput(1, 10));
 245   outputs.push_back(CreateExternalOutput(2, 11));
 246   helper_delegate_->set_cached_outputs(outputs.get());
 247
 248   DispatchOutputChangeEvent(2, 11, 20, false);
 249   EXPECT_EQ(1, helper_delegate_->num_calls_notify_observers());
 250
 251   // Simulate removal of second output from cached output list.
 252   outputs.erase(outputs.begin() + 1);
 253   helper_delegate_->set_cached_outputs(outputs.get());
 254
 255   DispatchOutputChangeEvent(2, 11, 20, false);
 256   EXPECT_EQ(1, helper_delegate_->num_calls_notify_observers());
 257 }
 258
 259 TEST_F(NativeDisplayEventDispatcherX11Test,
 260        ForceUpdateAfterCacheExpiration) {
 261   // +1 to compenstate a possible rounding error.
 262   const int kHalfOfExpirationMs =
 263       NativeDisplayEventDispatcherX11::kUseCacheAfterStartupMs / 2 + 1;
 264
 265   ScopedVector<DisplaySnapshot> outputs;
 266   outputs.push_back(CreateExternalOutput(1, 10));
 267   outputs.push_back(CreateExternalOutput(2, 11));
 268   helper_delegate_->set_cached_outputs(outputs.get());
 269
 270   EXPECT_EQ(0, helper_delegate_->num_calls_notify_observers());
 271
 272   // Duplicated event will be ignored during the startup.
 273   DispatchOutputChangeEvent(2, 11, 20, true);
 274   EXPECT_EQ(0, helper_delegate_->num_calls_notify_observers());
 275
 276   test_tick_clock_->Advance(base::TimeDelta::FromMilliseconds(
 277       kHalfOfExpirationMs));
 278
 279   // Duplicated event will still be ignored.
 280   DispatchOutputChangeEvent(2, 11, 20, true);
 281   EXPECT_EQ(0, helper_delegate_->num_calls_notify_observers());
 282
 283   // The startup timeout has been elapsed. Duplicated event
 284   // should not be ignored.
 285   test_tick_clock_->Advance(
 286       base::TimeDelta::FromMilliseconds(kHalfOfExpirationMs));
 287   DispatchOutputChangeEvent(2, 11, 20, true);
 288   EXPECT_EQ(1, helper_delegate_->num_calls_notify_observers());
 289
 290   // Sending the same event immediately shoudldn't be ignored.
 291   DispatchOutputChangeEvent(2, 11, 20, true);
 292   EXPECT_EQ(2, helper_delegate_->num_calls_notify_observers());
 293
 294   // Advancing time further should not change the behavior.
 295   test_tick_clock_->Advance(base::TimeDelta::FromMilliseconds(
 296       kHalfOfExpirationMs));
 297   DispatchOutputChangeEvent(2, 11, 20, true);
 298   EXPECT_EQ(3, helper_delegate_->num_calls_notify_observers());
 299
 300   test_tick_clock_->Advance(
 301       base::TimeDelta::FromMilliseconds(kHalfOfExpirationMs));
 302   DispatchOutputChangeEvent(2, 11, 20, true);
 303   EXPECT_EQ(4, helper_delegate_->num_calls_notify_observers());
 304 }
 305
 306 TEST_F(NativeDisplayEventDispatcherX11Test,
 307        UpdateMissingExternalDisplayId) {
 308   ScopedVector<DisplaySnapshot> outputs;
 309   outputs.push_back(CreateInternalOutput(1, 10));
 310   helper_delegate_->set_cached_outputs(outputs.get());
 311
 312   ASSERT_EQ(0, helper_delegate_->num_calls_notify_observers());
 313
 314   // Internal display's ID can be zero and not updated.
 315   DispatchOutputChangeEvent(1, 10, 20, true);
 316   EXPECT_EQ(0, helper_delegate_->num_calls_notify_observers());
 317
 318   outputs.clear();
 319   outputs.push_back(CreateOutput(0, DISPLAY_CONNECTION_TYPE_UNKNOWN, 2, 11));
 320   helper_delegate_->set_cached_outputs(outputs.get());
 321
 322   // External display should be updated if the id is zero.
 323   DispatchOutputChangeEvent(2, 11, 20, true);
 324   EXPECT_EQ(1, helper_delegate_->num_calls_notify_observers());
 325 }
 326
 327 }  // namespace ui