ash/display/resolution_notification_controller_unittest.cc

   1 // Copyright 2013 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 "ash/display/resolution_notification_controller.h"
   6
   7 #include "ash/display/display_manager.h"
   8 #include "ash/screen_util.h"
   9 #include "ash/shell.h"
  10 #include "ash/test/ash_test_base.h"
  11 #include "base/bind.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "grit/ash_strings.h"
  14 #include "ui/base/l10n/l10n_util.h"
  15 #include "ui/gfx/size.h"
  16 #include "ui/message_center/message_center.h"
  17 #include "ui/message_center/notification.h"
  18 #include "ui/message_center/notification_list.h"
  19
  20 namespace ash {
  21 namespace {
  22
  23 base::string16 ExpectedNotificationMessage(int64 display_id,
  24                                            const gfx::Size& new_resolution) {
  25   return l10n_util::GetStringFUTF16(
  26       IDS_ASH_STATUS_TRAY_DISPLAY_RESOLUTION_CHANGED,
  27       base::UTF8ToUTF16(
  28           Shell::GetInstance()->display_manager()->GetDisplayNameForId(
  29               display_id)),
  30       base::UTF8ToUTF16(new_resolution.ToString()));
  31 }
  32
  33 base::string16 ExpectedFallbackNotificationMessage(
  34     int64 display_id,
  35     const gfx::Size& specified_resolution,
  36     const gfx::Size& fallback_resolution) {
  37   return l10n_util::GetStringFUTF16(
  38       IDS_ASH_STATUS_TRAY_DISPLAY_RESOLUTION_CHANGED_TO_UNSUPPORTED,
  39       base::UTF8ToUTF16(
  40           Shell::GetInstance()->display_manager()->GetDisplayNameForId(
  41               display_id)),
  42       base::UTF8ToUTF16(specified_resolution.ToString()),
  43       base::UTF8ToUTF16(fallback_resolution.ToString()));
  44 }
  45
  46 }  // namespace
  47
  48 class ResolutionNotificationControllerTest : public ash::test::AshTestBase {
  49  public:
  50   ResolutionNotificationControllerTest()
  51       : accept_count_(0) {
  52   }
  53
  54   virtual ~ResolutionNotificationControllerTest() {}
  55
  56  protected:
  57   virtual void SetUp() OVERRIDE {
  58     ash::test::AshTestBase::SetUp();
  59     ResolutionNotificationController::SuppressTimerForTest();
  60   }
  61
  62   void SetDisplayResolutionAndNotifyWithResolution(
  63       const gfx::Display& display,
  64       const gfx::Size& new_resolution,
  65       const gfx::Size& actual_new_resolution) {
  66     DisplayManager* display_manager = Shell::GetInstance()->display_manager();
  67     const DisplayInfo& info = display_manager->GetDisplayInfo(display.id());
  68     controller()->SetDisplayResolutionAndNotify(
  69         display.id(),
  70         info.size_in_pixel(),
  71         new_resolution,
  72         base::Bind(&ResolutionNotificationControllerTest::OnAccepted,
  73                    base::Unretained(this)));
  74
  75     // OnConfigurationChanged event won't be emitted in the test environment,
  76     // so invoke UpdateDisplay() to emit that event explicitly.
  77     std::vector<DisplayInfo> info_list;
  78     for (size_t i = 0; i < display_manager->GetNumDisplays(); ++i) {
  79       int64 id = display_manager->GetDisplayAt(i).id();
  80       DisplayInfo info = display_manager->GetDisplayInfo(id);
  81       if (display.id() == id) {
  82         gfx::Rect bounds = info.bounds_in_native();
  83         bounds.set_size(actual_new_resolution);
  84         info.SetBounds(bounds);
  85       }
  86       info_list.push_back(info);
  87     }
  88     display_manager->OnNativeDisplaysChanged(info_list);
  89     RunAllPendingInMessageLoop();
  90   }
  91
  92   void SetDisplayResolutionAndNotify(const gfx::Display& display,
  93                                      const gfx::Size& new_resolution) {
  94     SetDisplayResolutionAndNotifyWithResolution(
  95         display, new_resolution, new_resolution);
  96   }
  97
  98   static base::string16 GetNotificationMessage() {
  99     const message_center::NotificationList::Notifications& notifications =
 100         message_center::MessageCenter::Get()->GetVisibleNotifications();
 101     for (message_center::NotificationList::Notifications::const_iterator iter =
 102              notifications.begin(); iter != notifications.end(); ++iter) {
 103       if ((*iter)->id() == ResolutionNotificationController::kNotificationId)
 104         return (*iter)->title();
 105     }
 106
 107     return base::string16();
 108   }
 109
 110   static void ClickOnNotification() {
 111     message_center::MessageCenter::Get()->ClickOnNotification(
 112         ResolutionNotificationController::kNotificationId);
 113   }
 114
 115   static void ClickOnNotificationButton(int index) {
 116     message_center::MessageCenter::Get()->ClickOnNotificationButton(
 117         ResolutionNotificationController::kNotificationId, index);
 118   }
 119
 120   static void CloseNotification() {
 121     message_center::MessageCenter::Get()->RemoveNotification(
 122         ResolutionNotificationController::kNotificationId, true /* by_user */);
 123   }
 124
 125   static bool IsNotificationVisible() {
 126     return message_center::MessageCenter::Get()->FindVisibleNotificationById(
 127         ResolutionNotificationController::kNotificationId);
 128   }
 129
 130   static void TickTimer() {
 131     controller()->OnTimerTick();
 132   }
 133
 134   static ResolutionNotificationController* controller() {
 135     return Shell::GetInstance()->resolution_notification_controller();
 136   }
 137
 138   int accept_count() const {
 139     return accept_count_;
 140   }
 141
 142  private:
 143   void OnAccepted() {
 144     EXPECT_FALSE(controller()->DoesNotificationTimeout());
 145     accept_count_++;
 146   }
 147
 148   int accept_count_;
 149
 150   DISALLOW_COPY_AND_ASSIGN(ResolutionNotificationControllerTest);
 151 };
 152
 153 // Basic behaviors and verifies it doesn't cause crashes.
 154 TEST_F(ResolutionNotificationControllerTest, Basic) {
 155   if (!SupportsMultipleDisplays())
 156     return;
 157
 158   UpdateDisplay("300x300#300x300%57|200x200%58,250x250#250x250%59|200x200%60");
 159   int64 id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
 160   ash::DisplayManager* display_manager =
 161       ash::Shell::GetInstance()->display_manager();
 162   ASSERT_EQ(0, accept_count());
 163   EXPECT_FALSE(IsNotificationVisible());
 164
 165   // Changes the resolution and apply the result.
 166   SetDisplayResolutionAndNotify(
 167       ScreenUtil::GetSecondaryDisplay(), gfx::Size(200, 200));
 168   EXPECT_TRUE(IsNotificationVisible());
 169   EXPECT_FALSE(controller()->DoesNotificationTimeout());
 170   EXPECT_EQ(ExpectedNotificationMessage(id2, gfx::Size(200, 200)),
 171             GetNotificationMessage());
 172   DisplayMode mode;
 173   EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
 174   EXPECT_EQ("200x200", mode.size.ToString());
 175   EXPECT_EQ(60.0, mode.refresh_rate);
 176
 177   // Click the revert button, which reverts to the best resolution.
 178   ClickOnNotificationButton(0);
 179   RunAllPendingInMessageLoop();
 180   EXPECT_FALSE(IsNotificationVisible());
 181   EXPECT_EQ(0, accept_count());
 182   EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
 183   EXPECT_EQ("250x250", mode.size.ToString());
 184   EXPECT_EQ(59.0, mode.refresh_rate);
 185 }
 186
 187 TEST_F(ResolutionNotificationControllerTest, ClickMeansAccept) {
 188   if (!SupportsMultipleDisplays())
 189     return;
 190
 191   UpdateDisplay("300x300#300x300%57|200x200%58,250x250#250x250%59|200x200%60");
 192   int64 id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
 193   ash::DisplayManager* display_manager =
 194       ash::Shell::GetInstance()->display_manager();
 195   ASSERT_EQ(0, accept_count());
 196   EXPECT_FALSE(IsNotificationVisible());
 197
 198   // Changes the resolution and apply the result.
 199   SetDisplayResolutionAndNotify(
 200       ScreenUtil::GetSecondaryDisplay(), gfx::Size(200, 200));
 201   EXPECT_TRUE(IsNotificationVisible());
 202   EXPECT_FALSE(controller()->DoesNotificationTimeout());
 203   DisplayMode mode;
 204   EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
 205   EXPECT_EQ("200x200", mode.size.ToString());
 206   EXPECT_EQ(60.0, mode.refresh_rate);
 207
 208   // Click the revert button, which reverts the resolution.
 209   ClickOnNotification();
 210   RunAllPendingInMessageLoop();
 211   EXPECT_FALSE(IsNotificationVisible());
 212   EXPECT_EQ(1, accept_count());
 213   EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
 214   EXPECT_EQ("200x200", mode.size.ToString());
 215   EXPECT_EQ(60.0, mode.refresh_rate);
 216 }
 217
 218 TEST_F(ResolutionNotificationControllerTest, AcceptButton) {
 219   if (!SupportsMultipleDisplays())
 220     return;
 221
 222   ash::DisplayManager* display_manager =
 223       ash::Shell::GetInstance()->display_manager();
 224
 225   UpdateDisplay("300x300#300x300%59|200x200%60");
 226   const gfx::Display& display = ash::Shell::GetScreen()->GetPrimaryDisplay();
 227   SetDisplayResolutionAndNotify(display, gfx::Size(200, 200));
 228   EXPECT_TRUE(IsNotificationVisible());
 229
 230   // If there's a single display only, it will have timeout and the first button
 231   // becomes accept.
 232   EXPECT_TRUE(controller()->DoesNotificationTimeout());
 233   ClickOnNotificationButton(0);
 234   EXPECT_FALSE(IsNotificationVisible());
 235   EXPECT_EQ(1, accept_count());
 236   DisplayMode mode;
 237   EXPECT_TRUE(
 238       display_manager->GetSelectedModeForDisplayId(display.id(), &mode));
 239   EXPECT_EQ("200x200", mode.size.ToString());
 240   EXPECT_EQ(60.0f, mode.refresh_rate);
 241
 242   // In that case the second button is revert.
 243   UpdateDisplay("300x300#300x300%59|200x200%60");
 244   SetDisplayResolutionAndNotify(display, gfx::Size(200, 200));
 245   EXPECT_TRUE(IsNotificationVisible());
 246
 247   EXPECT_TRUE(controller()->DoesNotificationTimeout());
 248   ClickOnNotificationButton(1);
 249   EXPECT_FALSE(IsNotificationVisible());
 250   EXPECT_EQ(1, accept_count());
 251   EXPECT_TRUE(
 252       display_manager->GetSelectedModeForDisplayId(display.id(), &mode));
 253   EXPECT_EQ("300x300", mode.size.ToString());
 254   EXPECT_EQ(59.0f, mode.refresh_rate);
 255 }
 256
 257 TEST_F(ResolutionNotificationControllerTest, Close) {
 258   if (!SupportsMultipleDisplays())
 259     return;
 260
 261   UpdateDisplay("100x100,150x150#150x150%59|200x200%60");
 262   int64 id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
 263   ash::DisplayManager* display_manager =
 264       ash::Shell::GetInstance()->display_manager();
 265   ASSERT_EQ(0, accept_count());
 266   EXPECT_FALSE(IsNotificationVisible());
 267
 268   // Changes the resolution and apply the result.
 269   SetDisplayResolutionAndNotify(
 270       ScreenUtil::GetSecondaryDisplay(), gfx::Size(200, 200));
 271   EXPECT_TRUE(IsNotificationVisible());
 272   EXPECT_FALSE(controller()->DoesNotificationTimeout());
 273   DisplayMode mode;
 274   EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
 275   EXPECT_EQ("200x200", mode.size.ToString());
 276   EXPECT_EQ(60.0f, mode.refresh_rate);
 277
 278   // Close the notification (imitates clicking [x] button). Also verifies if
 279   // this does not cause a crash.  See crbug.com/271784
 280   CloseNotification();
 281   RunAllPendingInMessageLoop();
 282   EXPECT_FALSE(IsNotificationVisible());
 283   EXPECT_EQ(1, accept_count());
 284 }
 285
 286 TEST_F(ResolutionNotificationControllerTest, Timeout) {
 287   if (!SupportsMultipleDisplays())
 288     return;
 289
 290   UpdateDisplay("300x300#300x300%59|200x200%60");
 291   const gfx::Display& display = ash::Shell::GetScreen()->GetPrimaryDisplay();
 292   SetDisplayResolutionAndNotify(display, gfx::Size(200, 200));
 293
 294   for (int i = 0; i < ResolutionNotificationController::kTimeoutInSec; ++i) {
 295     EXPECT_TRUE(IsNotificationVisible()) << "notification is closed after "
 296                                          << i << "-th timer tick";
 297     TickTimer();
 298     RunAllPendingInMessageLoop();
 299   }
 300   EXPECT_FALSE(IsNotificationVisible());
 301   EXPECT_EQ(0, accept_count());
 302   ash::DisplayManager* display_manager =
 303       ash::Shell::GetInstance()->display_manager();
 304   DisplayMode mode;
 305   EXPECT_TRUE(
 306       display_manager->GetSelectedModeForDisplayId(display.id(), &mode));
 307   EXPECT_EQ("300x300", mode.size.ToString());
 308   EXPECT_EQ(59.0f, mode.refresh_rate);
 309 }
 310
 311 TEST_F(ResolutionNotificationControllerTest, DisplayDisconnected) {
 312   if (!SupportsMultipleDisplays())
 313     return;
 314
 315   UpdateDisplay("300x300#300x300%56|200x200%57,"
 316                 "200x200#250x250%58|200x200%59|100x100%60");
 317   int64 id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
 318   ash::DisplayManager* display_manager =
 319       ash::Shell::GetInstance()->display_manager();
 320   SetDisplayResolutionAndNotify(
 321       ScreenUtil::GetSecondaryDisplay(), gfx::Size(100, 100));
 322   ASSERT_TRUE(IsNotificationVisible());
 323
 324   // Disconnects the secondary display and verifies it doesn't cause crashes.
 325   UpdateDisplay("300x300#300x300%56|200x200%57");
 326   RunAllPendingInMessageLoop();
 327   EXPECT_FALSE(IsNotificationVisible());
 328   EXPECT_EQ(0, accept_count());
 329   DisplayMode mode;
 330   EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
 331   gfx::Size resolution;
 332   EXPECT_EQ("200x200", mode.size.ToString());
 333   EXPECT_EQ(59.0f, mode.refresh_rate);
 334 }
 335
 336 TEST_F(ResolutionNotificationControllerTest, MultipleResolutionChange) {
 337   if (!SupportsMultipleDisplays())
 338     return;
 339
 340   UpdateDisplay("300x300#300x300%56|200x200%57,"
 341                 "250x250#250x250%58|200x200%59");
 342   int64 id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
 343   ash::DisplayManager* display_manager =
 344       ash::Shell::GetInstance()->display_manager();
 345
 346   SetDisplayResolutionAndNotify(
 347       ScreenUtil::GetSecondaryDisplay(), gfx::Size(200, 200));
 348   EXPECT_TRUE(IsNotificationVisible());
 349   EXPECT_FALSE(controller()->DoesNotificationTimeout());
 350   DisplayMode mode;
 351   EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
 352   EXPECT_EQ("200x200", mode.size.ToString());
 353   EXPECT_EQ(59.0f, mode.refresh_rate);
 354
 355   // Invokes SetDisplayResolutionAndNotify during the previous notification is
 356   // visible.
 357   SetDisplayResolutionAndNotify(
 358       ScreenUtil::GetSecondaryDisplay(), gfx::Size(250, 250));
 359   EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
 360   EXPECT_EQ("250x250", mode.size.ToString());
 361   EXPECT_EQ(58.0f, mode.refresh_rate);
 362
 363   // Then, click the revert button. Although |old_resolution| for the second
 364   // SetDisplayResolutionAndNotify is 200x200, it should revert to the original
 365   // size 250x250.
 366   ClickOnNotificationButton(0);
 367   RunAllPendingInMessageLoop();
 368   EXPECT_FALSE(IsNotificationVisible());
 369   EXPECT_EQ(0, accept_count());
 370   EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
 371   EXPECT_EQ("250x250", mode.size.ToString());
 372   EXPECT_EQ(58.0f, mode.refresh_rate);
 373 }
 374
 375 TEST_F(ResolutionNotificationControllerTest, Fallback) {
 376   if (!SupportsMultipleDisplays())
 377     return;
 378
 379   UpdateDisplay("300x300#300x300%56|200x200%57,"
 380                 "250x250#250x250%58|220x220%59|200x200%60");
 381   int64 id2 = ash::ScreenUtil::GetSecondaryDisplay().id();
 382   ash::DisplayManager* display_manager =
 383       ash::Shell::GetInstance()->display_manager();
 384   ASSERT_EQ(0, accept_count());
 385   EXPECT_FALSE(IsNotificationVisible());
 386
 387   // Changes the resolution and apply the result.
 388   SetDisplayResolutionAndNotifyWithResolution(
 389       ScreenUtil::GetSecondaryDisplay(),
 390       gfx::Size(220, 220),
 391       gfx::Size(200, 200));
 392   EXPECT_TRUE(IsNotificationVisible());
 393   EXPECT_FALSE(controller()->DoesNotificationTimeout());
 394   EXPECT_EQ(
 395       ExpectedFallbackNotificationMessage(
 396           id2, gfx::Size(220, 220), gfx::Size(200, 200)),
 397       GetNotificationMessage());
 398   DisplayMode mode;
 399   EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
 400   EXPECT_EQ("200x200", mode.size.ToString());
 401   EXPECT_EQ(60.0f, mode.refresh_rate);
 402
 403   // Click the revert button, which reverts to the best resolution.
 404   ClickOnNotificationButton(0);
 405   RunAllPendingInMessageLoop();
 406   EXPECT_FALSE(IsNotificationVisible());
 407   EXPECT_EQ(0, accept_count());
 408   EXPECT_TRUE(display_manager->GetSelectedModeForDisplayId(id2, &mode));
 409   EXPECT_EQ("250x250", mode.size.ToString());
 410   EXPECT_EQ(58.0f, mode.refresh_rate);
 411 }
 412
 413 }  // namespace ash