src/ash/system/chromeos/tray_display_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/system/chromeos/tray_display.h"
   6
   7 #include "ash/display/display_manager.h"
   8 #include "ash/root_window_controller.h"
   9 #include "ash/screen_util.h"
  10 #include "ash/shell.h"
  11 #include "ash/system/tray/system_tray.h"
  12 #include "ash/test/ash_test_base.h"
  13 #include "ash/test/test_system_tray_delegate.h"
  14 #include "base/strings/string16.h"
  15 #include "base/strings/string_util.h"
  16 #include "base/strings/utf_string_conversions.h"
  17 #include "grit/ash_strings.h"
  18 #include "ui/accessibility/ax_view_state.h"
  19 #include "ui/base/l10n/l10n_util.h"
  20 #include "ui/gfx/display.h"
  21 #include "ui/message_center/message_center.h"
  22 #include "ui/message_center/notification.h"
  23 #include "ui/message_center/notification_list.h"
  24 #include "ui/views/controls/label.h"
  25
  26 namespace ash {
  27
  28 base::string16 GetTooltipText(const base::string16& headline,
  29                               const base::string16& name1,
  30                               const std::string& data1,
  31                               const base::string16& name2,
  32                               const std::string& data2) {
  33   std::vector<base::string16> lines;
  34   lines.push_back(headline);
  35   if (data1.empty()) {
  36     lines.push_back(name1);
  37   } else {
  38     lines.push_back(l10n_util::GetStringFUTF16(
  39         IDS_ASH_STATUS_TRAY_DISPLAY_SINGLE_DISPLAY,
  40         name1, base::UTF8ToUTF16(data1)));
  41   }
  42   if (!name2.empty()) {
  43     lines.push_back(l10n_util::GetStringFUTF16(
  44         IDS_ASH_STATUS_TRAY_DISPLAY_SINGLE_DISPLAY,
  45         name2, base::UTF8ToUTF16(data2)));
  46   }
  47   return JoinString(lines, '\n');
  48 }
  49
  50 base::string16 GetMirroredTooltipText(const base::string16& headline,
  51                                       const base::string16& name,
  52                                       const std::string& data) {
  53   return GetTooltipText(headline, name, data, base::string16(), "");
  54 }
  55
  56 base::string16 GetFirstDisplayName() {
  57   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
  58   return base::UTF8ToUTF16(display_manager->GetDisplayNameForId(
  59       display_manager->first_display_id()));
  60 }
  61
  62 base::string16 GetSecondDisplayName() {
  63   return base::UTF8ToUTF16(
  64       Shell::GetInstance()->display_manager()->GetDisplayNameForId(
  65           ScreenUtil::GetSecondaryDisplay().id()));
  66 }
  67
  68 base::string16 GetMirroredDisplayName() {
  69   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
  70   return base::UTF8ToUTF16(display_manager->GetDisplayNameForId(
  71       display_manager->mirrored_display_id()));
  72 }
  73
  74 class TrayDisplayTest : public ash::test::AshTestBase {
  75  public:
  76   TrayDisplayTest();
  77   virtual ~TrayDisplayTest();
  78
  79   virtual void SetUp() override;
  80
  81  protected:
  82   SystemTray* tray() { return tray_; }
  83   TrayDisplay* tray_display() { return tray_display_; }
  84
  85   void CloseNotification();
  86   bool IsDisplayVisibleInTray() const;
  87   base::string16 GetTrayDisplayText() const;
  88   void CheckAccessibleName() const;
  89   base::string16 GetTrayDisplayTooltipText() const;
  90   base::string16 GetDisplayNotificationText() const;
  91   base::string16 GetDisplayNotificationAdditionalText() const;
  92
  93  private:
  94   const message_center::Notification* GetDisplayNotification() const;
  95
  96   // Weak reference, owned by Shell.
  97   SystemTray* tray_;
  98
  99   // Weak reference, owned by |tray_|.
 100   TrayDisplay* tray_display_;
 101
 102   DISALLOW_COPY_AND_ASSIGN(TrayDisplayTest);
 103 };
 104
 105 TrayDisplayTest::TrayDisplayTest() : tray_(NULL), tray_display_(NULL) {
 106 }
 107
 108 TrayDisplayTest::~TrayDisplayTest() {
 109 }
 110
 111 void TrayDisplayTest::SetUp() {
 112   ash::test::AshTestBase::SetUp();
 113   tray_ = Shell::GetPrimaryRootWindowController()->GetSystemTray();
 114   tray_display_ = new TrayDisplay(tray_);
 115   tray_->AddTrayItem(tray_display_);
 116 }
 117
 118 void TrayDisplayTest::CloseNotification() {
 119   message_center::MessageCenter::Get()->RemoveNotification(
 120       TrayDisplay::kNotificationId, false);
 121   RunAllPendingInMessageLoop();
 122 }
 123
 124 bool TrayDisplayTest::IsDisplayVisibleInTray() const {
 125   return tray_->HasSystemBubble() &&
 126       tray_display_->default_view() &&
 127       tray_display_->default_view()->visible();
 128 }
 129
 130 base::string16 TrayDisplayTest::GetTrayDisplayText() const {
 131   return tray_display_->GetDefaultViewMessage();
 132 }
 133
 134 void TrayDisplayTest::CheckAccessibleName() const {
 135   ui::AXViewState state;
 136   if (tray_display_->GetAccessibleStateForTesting(&state)) {
 137     base::string16 expected = tray_display_->GetDefaultViewMessage();
 138     EXPECT_EQ(expected, state.name);
 139   }
 140 }
 141
 142 base::string16 TrayDisplayTest::GetTrayDisplayTooltipText() const {
 143   if (!tray_display_->default_view())
 144     return base::string16();
 145
 146   base::string16 tooltip;
 147   if (!tray_display_->default_view()->GetTooltipText(gfx::Point(), &tooltip))
 148     return base::string16();
 149   return tooltip;
 150 }
 151
 152 base::string16 TrayDisplayTest::GetDisplayNotificationText() const {
 153   const message_center::Notification* notification = GetDisplayNotification();
 154   return notification ? notification->title() : base::string16();
 155 }
 156
 157 base::string16 TrayDisplayTest::GetDisplayNotificationAdditionalText() const {
 158   const message_center::Notification* notification = GetDisplayNotification();
 159   return notification ? notification->message() : base::string16();
 160 }
 161
 162 const message_center::Notification* TrayDisplayTest::GetDisplayNotification()
 163     const {
 164   const message_center::NotificationList::Notifications notifications =
 165       message_center::MessageCenter::Get()->GetVisibleNotifications();
 166   for (message_center::NotificationList::Notifications::const_iterator iter =
 167            notifications.begin(); iter != notifications.end(); ++iter) {
 168     if ((*iter)->id() == TrayDisplay::kNotificationId)
 169       return *iter;
 170   }
 171
 172   return NULL;
 173 }
 174
 175 TEST_F(TrayDisplayTest, NoInternalDisplay) {
 176   UpdateDisplay("400x400");
 177   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
 178   EXPECT_FALSE(IsDisplayVisibleInTray());
 179
 180   UpdateDisplay("400x400,200x200");
 181   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
 182   EXPECT_TRUE(IsDisplayVisibleInTray());
 183   base::string16 expected = l10n_util::GetStringUTF16(
 184       IDS_ASH_STATUS_TRAY_DISPLAY_EXTENDED_NO_INTERNAL);
 185   base::string16 first_name = GetFirstDisplayName();
 186   EXPECT_EQ(expected, GetTrayDisplayText());
 187   EXPECT_EQ(GetTooltipText(expected, GetFirstDisplayName(), "400x400",
 188                            GetSecondDisplayName(), "200x200"),
 189             GetTrayDisplayTooltipText());
 190   CheckAccessibleName();
 191
 192   // mirroring
 193   Shell::GetInstance()->display_manager()->SetSoftwareMirroring(true);
 194   UpdateDisplay("400x400,200x200");
 195   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
 196   EXPECT_TRUE(IsDisplayVisibleInTray());
 197   expected = l10n_util::GetStringUTF16(
 198       IDS_ASH_STATUS_TRAY_DISPLAY_MIRRORING_NO_INTERNAL);
 199   EXPECT_EQ(expected, GetTrayDisplayText());
 200   EXPECT_EQ(GetMirroredTooltipText(expected, GetFirstDisplayName(), "400x400"),
 201             GetTrayDisplayTooltipText());
 202   CheckAccessibleName();
 203 }
 204
 205 TEST_F(TrayDisplayTest, InternalDisplay) {
 206   UpdateDisplay("400x400");
 207   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 208   gfx::Display::SetInternalDisplayId(display_manager->first_display_id());
 209
 210   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
 211   EXPECT_FALSE(IsDisplayVisibleInTray());
 212
 213   // Extended
 214   UpdateDisplay("400x400,200x200");
 215   base::string16 expected = l10n_util::GetStringFUTF16(
 216       IDS_ASH_STATUS_TRAY_DISPLAY_EXTENDED, GetSecondDisplayName());
 217   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
 218   EXPECT_TRUE(IsDisplayVisibleInTray());
 219   EXPECT_EQ(expected, GetTrayDisplayText());
 220   EXPECT_EQ(GetTooltipText(expected, GetFirstDisplayName(), "400x400",
 221                            GetSecondDisplayName(), "200x200"),
 222             GetTrayDisplayTooltipText());
 223   CheckAccessibleName();
 224
 225   // Mirroring
 226   display_manager->SetSoftwareMirroring(true);
 227   UpdateDisplay("400x400,200x200");
 228   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
 229   EXPECT_TRUE(IsDisplayVisibleInTray());
 230
 231   expected = l10n_util::GetStringFUTF16(
 232       IDS_ASH_STATUS_TRAY_DISPLAY_MIRRORING, GetMirroredDisplayName());
 233   EXPECT_EQ(expected, GetTrayDisplayText());
 234   EXPECT_EQ(GetMirroredTooltipText(expected, GetFirstDisplayName(), "400x400"),
 235             GetTrayDisplayTooltipText());
 236   CheckAccessibleName();
 237 }
 238
 239 TEST_F(TrayDisplayTest, InternalDisplayResized) {
 240   UpdateDisplay("400x400@1.5");
 241   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 242   gfx::Display::SetInternalDisplayId(display_manager->first_display_id());
 243
 244   // Shows the tray_display even though there's a single-display.
 245   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
 246   EXPECT_TRUE(IsDisplayVisibleInTray());
 247   base::string16 internal_info = l10n_util::GetStringFUTF16(
 248       IDS_ASH_STATUS_TRAY_DISPLAY_SINGLE_DISPLAY,
 249       GetFirstDisplayName(), base::UTF8ToUTF16("600x600"));
 250   EXPECT_EQ(internal_info, GetTrayDisplayText());
 251   EXPECT_EQ(GetTooltipText(base::string16(), GetFirstDisplayName(), "600x600",
 252                            base::string16(), std::string()),
 253             GetTrayDisplayTooltipText());
 254   CheckAccessibleName();
 255
 256   // Extended
 257   UpdateDisplay("400x400@1.5,200x200");
 258   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
 259   EXPECT_TRUE(IsDisplayVisibleInTray());
 260   base::string16 expected = l10n_util::GetStringFUTF16(
 261       IDS_ASH_STATUS_TRAY_DISPLAY_EXTENDED, GetSecondDisplayName());
 262   EXPECT_EQ(expected, GetTrayDisplayText());
 263   EXPECT_EQ(GetTooltipText(expected, GetFirstDisplayName(), "600x600",
 264                            GetSecondDisplayName(), "200x200"),
 265             GetTrayDisplayTooltipText());
 266   CheckAccessibleName();
 267
 268   // Mirroring
 269   display_manager->SetSoftwareMirroring(true);
 270   UpdateDisplay("400x400@1.5,200x200");
 271   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
 272   EXPECT_TRUE(IsDisplayVisibleInTray());
 273   expected = l10n_util::GetStringFUTF16(
 274       IDS_ASH_STATUS_TRAY_DISPLAY_MIRRORING, GetMirroredDisplayName());
 275   EXPECT_EQ(expected, GetTrayDisplayText());
 276   EXPECT_EQ(GetMirroredTooltipText(expected, GetFirstDisplayName(), "600x600"),
 277             GetTrayDisplayTooltipText());
 278   CheckAccessibleName();
 279
 280   // Closed lid mode.
 281   display_manager->SetSoftwareMirroring(false);
 282   UpdateDisplay("400x400@1.5,200x200");
 283   gfx::Display::SetInternalDisplayId(ScreenUtil::GetSecondaryDisplay().id());
 284   UpdateDisplay("400x400@1.5");
 285   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
 286   EXPECT_TRUE(IsDisplayVisibleInTray());
 287   expected = l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_DISPLAY_DOCKED);
 288   EXPECT_EQ(expected, GetTrayDisplayText());
 289   EXPECT_EQ(
 290       GetTooltipText(
 291           expected, GetFirstDisplayName(), "600x600", base::string16(), ""),
 292       GetTrayDisplayTooltipText());
 293   CheckAccessibleName();
 294 }
 295
 296 TEST_F(TrayDisplayTest, ExternalDisplayResized) {
 297   UpdateDisplay("400x400");
 298   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 299   gfx::Display::SetInternalDisplayId(display_manager->first_display_id());
 300
 301   // Shows the tray_display even though there's a single-display.
 302   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
 303   EXPECT_FALSE(IsDisplayVisibleInTray());
 304
 305   // Extended
 306   UpdateDisplay("400x400,200x200@1.5");
 307   const gfx::Display& secondary_display = ScreenUtil::GetSecondaryDisplay();
 308
 309   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
 310   EXPECT_TRUE(IsDisplayVisibleInTray());
 311   base::string16 expected = l10n_util::GetStringFUTF16(
 312       IDS_ASH_STATUS_TRAY_DISPLAY_EXTENDED,
 313       l10n_util::GetStringFUTF16(
 314           IDS_ASH_STATUS_TRAY_DISPLAY_ANNOTATED_NAME,
 315           GetSecondDisplayName(),
 316           base::UTF8ToUTF16(secondary_display.size().ToString())));
 317   EXPECT_EQ(expected, GetTrayDisplayText());
 318   EXPECT_EQ(GetTooltipText(expected, GetFirstDisplayName(), "400x400",
 319                            GetSecondDisplayName(), "300x300"),
 320             GetTrayDisplayTooltipText());
 321   CheckAccessibleName();
 322
 323   // Mirroring
 324   display_manager->SetSoftwareMirroring(true);
 325   UpdateDisplay("400x400,200x200@1.5");
 326   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
 327   EXPECT_TRUE(IsDisplayVisibleInTray());
 328   expected = l10n_util::GetStringFUTF16(
 329       IDS_ASH_STATUS_TRAY_DISPLAY_MIRRORING, GetMirroredDisplayName());
 330   EXPECT_EQ(expected, GetTrayDisplayText());
 331   EXPECT_EQ(GetMirroredTooltipText(expected, GetFirstDisplayName(), "400x400"),
 332             GetTrayDisplayTooltipText());
 333   CheckAccessibleName();
 334 }
 335
 336 TEST_F(TrayDisplayTest, OverscanDisplay) {
 337   UpdateDisplay("400x400,300x300/o");
 338   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 339   gfx::Display::SetInternalDisplayId(display_manager->first_display_id());
 340
 341   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
 342   EXPECT_TRUE(IsDisplayVisibleInTray());
 343
 344   // /o creates the default overscan, and if overscan is set, the annotation
 345   // should be the size.
 346   base::string16 overscan = l10n_util::GetStringUTF16(
 347       IDS_ASH_STATUS_TRAY_DISPLAY_ANNOTATION_OVERSCAN);
 348   base::string16 headline = l10n_util::GetStringFUTF16(
 349       IDS_ASH_STATUS_TRAY_DISPLAY_EXTENDED,
 350       l10n_util::GetStringFUTF16(
 351           IDS_ASH_STATUS_TRAY_DISPLAY_ANNOTATED_NAME,
 352           GetSecondDisplayName(), base::UTF8ToUTF16("286x286")));
 353   std::string second_data = l10n_util::GetStringFUTF8(
 354       IDS_ASH_STATUS_TRAY_DISPLAY_ANNOTATION,
 355       base::UTF8ToUTF16("286x286"), overscan);
 356   EXPECT_EQ(GetTooltipText(headline, GetFirstDisplayName(), "400x400",
 357                            GetSecondDisplayName(), second_data),
 358             GetTrayDisplayTooltipText());
 359
 360   // reset the overscan.
 361   display_manager->SetOverscanInsets(
 362       ScreenUtil::GetSecondaryDisplay().id(), gfx::Insets());
 363   headline = l10n_util::GetStringFUTF16(
 364       IDS_ASH_STATUS_TRAY_DISPLAY_EXTENDED,
 365       l10n_util::GetStringFUTF16(
 366           IDS_ASH_STATUS_TRAY_DISPLAY_ANNOTATED_NAME,
 367           GetSecondDisplayName(), overscan));
 368   second_data = l10n_util::GetStringFUTF8(
 369       IDS_ASH_STATUS_TRAY_DISPLAY_ANNOTATION,
 370       base::UTF8ToUTF16("300x300"), overscan);
 371   EXPECT_EQ(GetTooltipText(headline, GetFirstDisplayName(), "400x400",
 372                            GetSecondDisplayName(), second_data),
 373             GetTrayDisplayTooltipText());
 374 }
 375
 376 TEST_F(TrayDisplayTest, UpdateDuringDisplayConfigurationChange) {
 377   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
 378   EXPECT_FALSE(IsDisplayVisibleInTray());
 379
 380   UpdateDisplay("400x400@1.5");
 381   EXPECT_TRUE(tray()->HasSystemBubble());
 382   EXPECT_TRUE(IsDisplayVisibleInTray());
 383   base::string16 internal_info = l10n_util::GetStringFUTF16(
 384       IDS_ASH_STATUS_TRAY_DISPLAY_SINGLE_DISPLAY,
 385       GetFirstDisplayName(), base::UTF8ToUTF16("600x600"));
 386   EXPECT_EQ(internal_info, GetTrayDisplayText());
 387   EXPECT_EQ(GetTooltipText(base::string16(), GetFirstDisplayName(), "600x600",
 388                            base::string16(), std::string()),
 389             GetTrayDisplayTooltipText());
 390   CheckAccessibleName();
 391
 392   UpdateDisplay("400x400,200x200");
 393   EXPECT_TRUE(tray()->HasSystemBubble());
 394   EXPECT_TRUE(IsDisplayVisibleInTray());
 395   base::string16 expected = l10n_util::GetStringUTF16(
 396       IDS_ASH_STATUS_TRAY_DISPLAY_EXTENDED_NO_INTERNAL);
 397   base::string16 first_name = GetFirstDisplayName();
 398   EXPECT_EQ(expected, GetTrayDisplayText());
 399   EXPECT_EQ(GetTooltipText(expected, GetFirstDisplayName(), "400x400",
 400                            GetSecondDisplayName(), "200x200"),
 401             GetTrayDisplayTooltipText());
 402   CheckAccessibleName();
 403
 404   UpdateDisplay("400x400@1.5");
 405   tray()->ShowDefaultView(BUBBLE_USE_EXISTING);
 406
 407   // Back to the default state, the display tray item should disappear.
 408   UpdateDisplay("400x400");
 409   EXPECT_TRUE(tray()->HasSystemBubble());
 410   EXPECT_FALSE(IsDisplayVisibleInTray());
 411 }
 412
 413 TEST_F(TrayDisplayTest, DisplayNotifications) {
 414   test::TestSystemTrayDelegate* tray_delegate =
 415       static_cast<test::TestSystemTrayDelegate*>(
 416           Shell::GetInstance()->system_tray_delegate());
 417   tray_delegate->set_should_show_display_notification(true);
 418
 419   UpdateDisplay("400x400");
 420   DisplayManager* display_manager = Shell::GetInstance()->display_manager();
 421   gfx::Display::SetInternalDisplayId(display_manager->first_display_id());
 422   EXPECT_TRUE(GetDisplayNotificationText().empty());
 423
 424   // rotation.
 425   UpdateDisplay("400x400/r");
 426   EXPECT_EQ(
 427       l10n_util::GetStringFUTF16(
 428           IDS_ASH_STATUS_TRAY_DISPLAY_ROTATED, GetFirstDisplayName(),
 429           l10n_util::GetStringUTF16(
 430               IDS_ASH_STATUS_TRAY_DISPLAY_ORIENTATION_90)),
 431       GetDisplayNotificationText());
 432   EXPECT_TRUE(GetDisplayNotificationAdditionalText().empty());
 433
 434   CloseNotification();
 435   UpdateDisplay("400x400");
 436   EXPECT_EQ(
 437       l10n_util::GetStringFUTF16(
 438           IDS_ASH_STATUS_TRAY_DISPLAY_ROTATED, GetFirstDisplayName(),
 439           l10n_util::GetStringUTF16(
 440               IDS_ASH_STATUS_TRAY_DISPLAY_STANDARD_ORIENTATION)),
 441       GetDisplayNotificationText());
 442   EXPECT_TRUE(GetDisplayNotificationAdditionalText().empty());
 443
 444   // UI-scale
 445   CloseNotification();
 446   UpdateDisplay("400x400@1.5");
 447   EXPECT_EQ(
 448       l10n_util::GetStringFUTF16(
 449           IDS_ASH_STATUS_TRAY_DISPLAY_RESOLUTION_CHANGED,
 450           GetFirstDisplayName(), base::UTF8ToUTF16("600x600")),
 451       GetDisplayNotificationText());
 452   EXPECT_TRUE(GetDisplayNotificationAdditionalText().empty());
 453
 454   // UI-scale to 1.0
 455   CloseNotification();
 456   UpdateDisplay("400x400");
 457   EXPECT_EQ(
 458       l10n_util::GetStringFUTF16(
 459           IDS_ASH_STATUS_TRAY_DISPLAY_RESOLUTION_CHANGED,
 460           GetFirstDisplayName(), base::UTF8ToUTF16("400x400")),
 461       GetDisplayNotificationText());
 462   EXPECT_TRUE(GetDisplayNotificationAdditionalText().empty());
 463
 464   // No-update
 465   CloseNotification();
 466   UpdateDisplay("400x400");
 467   EXPECT_TRUE(GetDisplayNotificationText().empty());
 468   EXPECT_TRUE(GetDisplayNotificationAdditionalText().empty());
 469
 470   // Extended.
 471   CloseNotification();
 472   UpdateDisplay("400x400,200x200");
 473   EXPECT_EQ(
 474       l10n_util::GetStringFUTF16(
 475           IDS_ASH_STATUS_TRAY_DISPLAY_EXTENDED, GetSecondDisplayName()),
 476       GetDisplayNotificationText());
 477   EXPECT_TRUE(GetDisplayNotificationAdditionalText().empty());
 478
 479   // Mirroring.
 480   CloseNotification();
 481   display_manager->SetSoftwareMirroring(true);
 482   UpdateDisplay("400x400,200x200");
 483   EXPECT_EQ(
 484       l10n_util::GetStringFUTF16(
 485           IDS_ASH_STATUS_TRAY_DISPLAY_MIRRORING, GetMirroredDisplayName()),
 486       GetDisplayNotificationText());
 487   EXPECT_TRUE(GetDisplayNotificationAdditionalText().empty());
 488
 489   // Back to extended.
 490   CloseNotification();
 491   display_manager->SetSoftwareMirroring(false);
 492   UpdateDisplay("400x400,200x200");
 493   EXPECT_EQ(
 494       l10n_util::GetStringFUTF16(
 495           IDS_ASH_STATUS_TRAY_DISPLAY_EXTENDED, GetSecondDisplayName()),
 496       GetDisplayNotificationText());
 497   EXPECT_TRUE(GetDisplayNotificationAdditionalText().empty());
 498
 499   // Resize the first display.
 500   UpdateDisplay("400x400@1.5,200x200");
 501   EXPECT_EQ(
 502       l10n_util::GetStringFUTF16(
 503           IDS_ASH_STATUS_TRAY_DISPLAY_RESOLUTION_CHANGED,
 504           GetFirstDisplayName(), base::UTF8ToUTF16("600x600")),
 505       GetDisplayNotificationText());
 506   EXPECT_TRUE(GetDisplayNotificationAdditionalText().empty());
 507
 508   // Rotate the second.
 509   UpdateDisplay("400x400@1.5,200x200/r");
 510   EXPECT_EQ(
 511       l10n_util::GetStringFUTF16(
 512           IDS_ASH_STATUS_TRAY_DISPLAY_ROTATED,
 513           GetSecondDisplayName(),
 514           l10n_util::GetStringUTF16(
 515               IDS_ASH_STATUS_TRAY_DISPLAY_ORIENTATION_90)),
 516       GetDisplayNotificationText());
 517   EXPECT_TRUE(GetDisplayNotificationAdditionalText().empty());
 518
 519   // Enters closed lid mode.
 520   UpdateDisplay("400x400@1.5,200x200");
 521   gfx::Display::SetInternalDisplayId(ScreenUtil::GetSecondaryDisplay().id());
 522   UpdateDisplay("400x400@1.5");
 523   EXPECT_EQ(l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_DISPLAY_DOCKED),
 524             GetDisplayNotificationText());
 525   EXPECT_EQ(
 526       l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_DISPLAY_DOCKED_DESCRIPTION),
 527       GetDisplayNotificationAdditionalText());
 528 }
 529
 530 TEST_F(TrayDisplayTest, DisplayConfigurationChangedTwice) {
 531   test::TestSystemTrayDelegate* tray_delegate =
 532       static_cast<test::TestSystemTrayDelegate*>(
 533           Shell::GetInstance()->system_tray_delegate());
 534   tray_delegate->set_should_show_display_notification(true);
 535
 536   UpdateDisplay("400x400,200x200");
 537   EXPECT_EQ(
 538       l10n_util::GetStringUTF16(
 539           IDS_ASH_STATUS_TRAY_DISPLAY_EXTENDED_NO_INTERNAL),
 540       GetDisplayNotificationText());
 541
 542   // OnDisplayConfigurationChanged() may be called more than once for a single
 543   // update display in case of primary is swapped or recovered from dock mode.
 544   // Should not remove the notification in such case.
 545   tray_display()->OnDisplayConfigurationChanged();
 546   EXPECT_EQ(
 547       l10n_util::GetStringUTF16(
 548           IDS_ASH_STATUS_TRAY_DISPLAY_EXTENDED_NO_INTERNAL),
 549       GetDisplayNotificationText());
 550
 551   // Back to the single display. It SHOULD remove the notification since the
 552   // information is stale.
 553   UpdateDisplay("400x400");
 554   EXPECT_TRUE(GetDisplayNotificationText().empty());
 555 }
 556
 557 TEST_F(TrayDisplayTest, UpdateAfterSuppressDisplayNotification) {
 558   UpdateDisplay("400x400,200x200");
 559
 560   test::TestSystemTrayDelegate* tray_delegate =
 561       static_cast<test::TestSystemTrayDelegate*>(
 562           Shell::GetInstance()->system_tray_delegate());
 563   tray_delegate->set_should_show_display_notification(true);
 564
 565   // rotate the second.
 566   UpdateDisplay("400x400,200x200/r");
 567   EXPECT_EQ(
 568       l10n_util::GetStringFUTF16(
 569           IDS_ASH_STATUS_TRAY_DISPLAY_ROTATED,
 570           GetSecondDisplayName(),
 571           l10n_util::GetStringUTF16(
 572               IDS_ASH_STATUS_TRAY_DISPLAY_ORIENTATION_90)),
 573       GetDisplayNotificationText());
 574 }
 575
 576 }  // namespace ash