Adds TraySessionLengthLimitTest to ash_unittests.

ash/system/session_length_limit/tray_session_length_limit.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/system/session_length_limit/tray_session_length_limit.h"
 
 #include <algorithm>
 
 #include "ash/shelf/shelf_types.h"
 #include "ash/shell.h"
@@ skipping 32 matching lines @@
 
 // If the remaining session time falls below this threshold, the user should be
 // informed that the session is about to expire.
 const int kExpiringSoonThresholdInSeconds = 5 * 60;  // 5 minutes.
 
 // Color in which the remaining session time is normally shown.
 const SkColor kRemainingTimeColor = SK_ColorWHITE;
 // Color in which the remaining session time is shown when it is expiring soon.
 const SkColor kRemainingTimeExpiringSoonColor = SK_ColorRED;
 
-const char kSessionLengthTimeoutNotificationId[] = "chrome://session/timeout";
-
 views::Label* CreateAndSetupLabel() {
   views::Label* label = new views::Label;
   label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
   SetupLabelForTray(label);
   gfx::Font font = label->font();
   label->SetFont(font.DeriveFont(0, font.GetStyle() & ~gfx::Font::BOLD));
   return label;
 }
 
 base::string16 IntToTwoDigitString(int value) {
   DCHECK_GE(value, 0);
   DCHECK_LE(value, 99);
   if (value < 10)
     return ASCIIToUTF16("0") + base::IntToString16(value);
   return base::IntToString16(value);
 }
 
 base::string16 FormatRemainingSessionTimeNotification(
     const base::TimeDelta& remaining_session_time) {
   return l10n_util::GetStringFUTF16(
       IDS_ASH_STATUS_TRAY_REMAINING_SESSION_TIME_NOTIFICATION,
       ui::TimeFormat::TimeDurationLong(remaining_session_time));
 }
 
 // Creates, or updates the notification for session length timeout with
 // |remaining_time|.  |state_changed| is true when its internal state has been
 // changed from another.
-void CreateOrUpdateNotification(const base::TimeDelta& remaining_time,
+void CreateOrUpdateNotification(const std::string& notification_id,
+                                const base::TimeDelta& remaining_time,
                                 bool state_changed) {
   message_center::MessageCenter* message_center =
       message_center::MessageCenter::Get();
 
   // Do not create a new notification if no state has changed. It may happen
   // when the notification is already closed by the user, see crbug.com/285941.
-  if (!state_changed &&
-      !message_center->HasNotification(kSessionLengthTimeoutNotificationId)) {
+  if (!state_changed && !message_center->HasNotification(notification_id))
     return;
-  }
 
   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
   message_center::RichNotificationData data;
   // Makes the spoken feedback only when the state has been changed.
   data.should_make_spoken_feedback_for_popup_updates = state_changed;
   scoped_ptr<Notification> notification(new Notification(
       message_center::NOTIFICATION_TYPE_SIMPLE,
-      kSessionLengthTimeoutNotificationId,
+      notification_id,
       FormatRemainingSessionTimeNotification(remaining_time),
       base::string16() /* message */,
       bundle.GetImageNamed(IDR_AURA_UBER_TRAY_SESSION_LENGTH_LIMIT_TIMER),
       base::string16() /* display_source */,
       message_center::NotifierId(
           message_center::NotifierId::SYSTEM_COMPONENT,
           system_notifier::kNotifierSessionLengthTimeout),
       data,
       NULL /* delegate */));
   notification->SetSystemPriority();
@@ skipping 160 matching lines @@
     set_border(views::Border::CreateEmptyBorder(
         0, kTrayLabelItemHorizontalPaddingBottomAlignment,
         0, kTrayLabelItemHorizontalPaddingBottomAlignment));
   } else {
     set_border(NULL);
   }
 }
 
 }  // namespace tray
 
+// static
+const char TraySessionLengthLimit::kNotificationId[] =
+    "chrome://session/timeout";
+
 TraySessionLengthLimit::TraySessionLengthLimit(SystemTray* system_tray)
     : SystemTrayItem(system_tray),
       tray_view_(NULL),
       limit_state_(LIMIT_NONE) {
   Shell::GetInstance()->system_tray_notifier()->
       AddSessionLengthLimitObserver(this);
   Update();
 }
 
 TraySessionLengthLimit::~TraySessionLengthLimit() {
@@ skipping 56 matching lines @@
       timer_->Start(FROM_HERE,
                     base::TimeDelta::FromSeconds(1),
                     this,
                     &TraySessionLengthLimit::Update);
     }
   }
 
   switch (limit_state_) {
     case LIMIT_NONE:
       message_center::MessageCenter::Get()->RemoveNotification(
-          kSessionLengthTimeoutNotificationId, false /* by_user */);
+          kNotificationId, false /* by_user */);
       break;
     case LIMIT_SET:
       CreateOrUpdateNotification(
+          kNotificationId,
           remaining_session_time_,
           previous_limit_state == LIMIT_NONE);
       break;
     case LIMIT_EXPIRING_SOON:
       CreateOrUpdateNotification(
+          kNotificationId,
           remaining_session_time_,
           previous_limit_state == LIMIT_NONE ||
           previous_limit_state == LIMIT_SET);
       break;
   }
 
   // Update the tray view last so that it can check whether the notification
   // view is currently visible or not.
   if (tray_view_)
     tray_view_->Update();
 }
 
+bool TraySessionLengthLimit::IsTrayViewVisibleForTest() {
+  return tray_view_ && tray_view_->visible();
+}
+
 }  // namespace internal
 }  // namespace ash