Move session length timer into tray bubble.

ash/system/chromeos/session/tray_session_length_limit.cc

 // Copyright 2014 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/chromeos/session/tray_session_length_limit.h"
 
 #include <algorithm>
 
-#include "ash/shelf/shelf_types.h"
 #include "ash/shell.h"
+#include "ash/system/chromeos/label_tray_view.h"
 #include "ash/system/system_notifier.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/system_tray_delegate.h"
 #include "ash/system/tray/system_tray_notifier.h"
-#include "ash/system/tray/tray_constants.h"
-#include "ash/system/tray/tray_utils.h"
-#include "base/location.h"
 #include "base/logging.h"
-#include "base/strings/string16.h"
-#include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "grit/ash_resources.h"
 #include "grit/ash_strings.h"
-#include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/time_format.h"
 #include "ui/base/resource/resource_bundle.h"
-#include "ui/gfx/font_list.h"
 #include "ui/message_center/message_center.h"
 #include "ui/message_center/notification.h"
-#include "ui/views/border.h"
-#include "ui/views/controls/label.h"
-#include "ui/views/layout/box_layout.h"
-#include "ui/views/layout/grid_layout.h"
 #include "ui/views/view.h"
 
-using message_center::Notification;
-
 namespace ash {
 namespace {
 
 // 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.
+const int kExpiringSoonThresholdInMinutes = 5;
 
-// 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;
-
-views::Label* CreateAndSetupLabel() {
-  views::Label* label = new views::Label;
-  label->SetHorizontalAlignment(gfx::ALIGN_LEFT);
-  SetupLabelForTray(label);
-  label->SetFontList(label->font_list().DeriveWithStyle(
-      label->font_list().GetFontStyle() & ~gfx::Font::BOLD));
-  return label;
-}
-
-base::string16 IntToTwoDigitString(int value) {
-  DCHECK_GE(value, 0);
-  DCHECK_LE(value, 99);
-  if (value < 10)
-    return base::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::Detailed(ui::TimeFormat::FORMAT_DURATION,
-                               ui::TimeFormat::LENGTH_LONG,
-                               10,
-                               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 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(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,
-      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();
-  message_center::MessageCenter::Get()->AddNotification(notification.Pass());
-}
+// Use 500ms interval for updates to notification and tray bubble to reduce the
+// likelihood of a user-visible skip in high load situations (as might happen
+// with 1000ms).
+const int kTimerIntervalInMilliseconds = 500;
 
 }  // namespace
 
-namespace tray {
-
-class RemainingSessionTimeTrayView : public views::View {
- public:
-  RemainingSessionTimeTrayView(const TraySessionLengthLimit* owner,
-                               ShelfAlignment shelf_alignment);
-  virtual ~RemainingSessionTimeTrayView();
-
-  void UpdateClockLayout(ShelfAlignment shelf_alignment);
-  void Update();
-
- private:
-  void SetBorderFromAlignment(ShelfAlignment shelf_alignment);
-
-  const TraySessionLengthLimit* owner_;
-
-  views::Label* horizontal_layout_label_;
-  views::Label* vertical_layout_label_hours_left_;
-  views::Label* vertical_layout_label_hours_right_;
-  views::Label* vertical_layout_label_minutes_left_;
-  views::Label* vertical_layout_label_minutes_right_;
-  views::Label* vertical_layout_label_seconds_left_;
-  views::Label* vertical_layout_label_seconds_right_;
-
-  DISALLOW_COPY_AND_ASSIGN(RemainingSessionTimeTrayView);
-};
-
-RemainingSessionTimeTrayView::RemainingSessionTimeTrayView(
-    const TraySessionLengthLimit* owner,
-    ShelfAlignment shelf_alignment)
-    : owner_(owner),
-      horizontal_layout_label_(NULL),
-      vertical_layout_label_hours_left_(NULL),
-      vertical_layout_label_hours_right_(NULL),
-      vertical_layout_label_minutes_left_(NULL),
-      vertical_layout_label_minutes_right_(NULL),
-      vertical_layout_label_seconds_left_(NULL),
-      vertical_layout_label_seconds_right_(NULL) {
-  UpdateClockLayout(shelf_alignment);
-}
-
-RemainingSessionTimeTrayView::~RemainingSessionTimeTrayView() {
-}
-
-void RemainingSessionTimeTrayView::UpdateClockLayout(
-    ShelfAlignment shelf_alignment) {
-  SetBorderFromAlignment(shelf_alignment);
-  const bool horizontal_layout = (shelf_alignment == SHELF_ALIGNMENT_BOTTOM ||
-      shelf_alignment == SHELF_ALIGNMENT_TOP);
-  if (horizontal_layout && !horizontal_layout_label_) {
-    // Remove labels used for vertical layout.
-    RemoveAllChildViews(true);
-    vertical_layout_label_hours_left_ = NULL;
-    vertical_layout_label_hours_right_ = NULL;
-    vertical_layout_label_minutes_left_ = NULL;
-    vertical_layout_label_minutes_right_ = NULL;
-    vertical_layout_label_seconds_left_ = NULL;
-    vertical_layout_label_seconds_right_ = NULL;
-
-    // Create label used for horizontal layout.
-    horizontal_layout_label_ = CreateAndSetupLabel();
-
-    // Construct layout.
-    SetLayoutManager(
-        new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0, 0));
-    AddChildView(horizontal_layout_label_);
-
-  } else if (!horizontal_layout && horizontal_layout_label_) {
-    // Remove label used for horizontal layout.
-    RemoveAllChildViews(true);
-    horizontal_layout_label_ = NULL;
-
-    // Create labels used for vertical layout.
-    vertical_layout_label_hours_left_ = CreateAndSetupLabel();
-    vertical_layout_label_hours_right_ = CreateAndSetupLabel();
-    vertical_layout_label_minutes_left_ = CreateAndSetupLabel();
-    vertical_layout_label_minutes_right_ = CreateAndSetupLabel();
-    vertical_layout_label_seconds_left_ = CreateAndSetupLabel();
-    vertical_layout_label_seconds_right_ = CreateAndSetupLabel();
-
-    // Construct layout.
-    views::GridLayout* layout = new views::GridLayout(this);
-    SetLayoutManager(layout);
-    views::ColumnSet* columns = layout->AddColumnSet(0);
-    columns->AddPaddingColumn(0, 6);
-    columns->AddColumn(views::GridLayout::CENTER, views::GridLayout::CENTER,
-                       0, views::GridLayout::USE_PREF, 0, 0);
-    columns->AddColumn(views::GridLayout::CENTER, views::GridLayout::CENTER,
-                       0, views::GridLayout::USE_PREF, 0, 0);
-    layout->AddPaddingRow(0, kTrayLabelItemVerticalPaddingVerticalAlignment);
-    layout->StartRow(0, 0);
-    layout->AddView(vertical_layout_label_hours_left_);
-    layout->AddView(vertical_layout_label_hours_right_);
-    layout->StartRow(0, 0);
-    layout->AddView(vertical_layout_label_minutes_left_);
-    layout->AddView(vertical_layout_label_minutes_right_);
-    layout->StartRow(0, 0);
-    layout->AddView(vertical_layout_label_seconds_left_);
-    layout->AddView(vertical_layout_label_seconds_right_);
-    layout->AddPaddingRow(0, kTrayLabelItemVerticalPaddingVerticalAlignment);
-  }
-  Update();
-}
-
-void RemainingSessionTimeTrayView::Update() {
-  const TraySessionLengthLimit::LimitState limit_state =
-      owner_->GetLimitState();
-
-  if (limit_state == TraySessionLengthLimit::LIMIT_NONE) {
-    SetVisible(false);
-    return;
-  }
-
-  int seconds = owner_->GetRemainingSessionTime().InSeconds();
-  // If the remaining session time is 100 hours or more, show 99:59:59 instead.
-  seconds = std::min(seconds, 100 * 60 * 60 - 1);  // 100 hours - 1 second.
-  int minutes = seconds / 60;
-  seconds %= 60;
-  const int hours = minutes / 60;
-  minutes %= 60;
-
-  const base::string16 hours_str = IntToTwoDigitString(hours);
-  const base::string16 minutes_str = IntToTwoDigitString(minutes);
-  const base::string16 seconds_str = IntToTwoDigitString(seconds);
-  const SkColor color =
-      limit_state == TraySessionLengthLimit::LIMIT_EXPIRING_SOON ?
-          kRemainingTimeExpiringSoonColor : kRemainingTimeColor;
-
-  if (horizontal_layout_label_) {
-    horizontal_layout_label_->SetText(l10n_util::GetStringFUTF16(
-        IDS_ASH_STATUS_TRAY_REMAINING_SESSION_TIME,
-        hours_str, minutes_str, seconds_str));
-    horizontal_layout_label_->SetEnabledColor(color);
-  } else if (vertical_layout_label_hours_left_) {
-    vertical_layout_label_hours_left_->SetText(hours_str.substr(0, 1));
-    vertical_layout_label_hours_right_->SetText(hours_str.substr(1, 1));
-    vertical_layout_label_minutes_left_->SetText(minutes_str.substr(0, 1));
-    vertical_layout_label_minutes_right_->SetText(minutes_str.substr(1, 1));
-    vertical_layout_label_seconds_left_->SetText(seconds_str.substr(0, 1));
-    vertical_layout_label_seconds_right_->SetText(seconds_str.substr(1, 1));
-    vertical_layout_label_hours_left_->SetEnabledColor(color);
-    vertical_layout_label_hours_right_->SetEnabledColor(color);
-    vertical_layout_label_minutes_left_->SetEnabledColor(color);
-    vertical_layout_label_minutes_right_->SetEnabledColor(color);
-    vertical_layout_label_seconds_left_->SetEnabledColor(color);
-    vertical_layout_label_seconds_right_->SetEnabledColor(color);
-  }
-
-  Layout();
-  SetVisible(true);
-}
-
-void RemainingSessionTimeTrayView::SetBorderFromAlignment(
-    ShelfAlignment shelf_alignment) {
-  if (shelf_alignment == SHELF_ALIGNMENT_BOTTOM ||
-      shelf_alignment == SHELF_ALIGNMENT_TOP) {
-    SetBorder(views::Border::CreateEmptyBorder(
-        0,
-        kTrayLabelItemHorizontalPaddingBottomAlignment,
-        0,
-        kTrayLabelItemHorizontalPaddingBottomAlignment));
-  } else {
-    SetBorder(views::Border::NullBorder());
-  }
-}
-
-}  // 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) {
+      limit_state_(LIMIT_NONE),
+      last_limit_state_(LIMIT_NONE),
+      tray_bubble_view_(NULL) {
   Shell::GetInstance()->system_tray_notifier()->
       AddSessionLengthLimitObserver(this);
   Update();
 }
 
 TraySessionLengthLimit::~TraySessionLengthLimit() {
   Shell::GetInstance()->system_tray_notifier()->
       RemoveSessionLengthLimitObserver(this);
 }
 
-views::View* TraySessionLengthLimit::CreateTrayView(user::LoginStatus status) {
-  CHECK(tray_view_ == NULL);
-  tray_view_ = new tray::RemainingSessionTimeTrayView(
-      this, system_tray()->shelf_alignment());
-  return tray_view_;
+// Add view to tray bubble.
+views::View* TraySessionLengthLimit::CreateDefaultView(
+    user::LoginStatus status) {
+  CHECK(tray_bubble_view_ == NULL);

[bartfab (slow), 2014/05/05 13:45:04]

Nit: CHECK(!tray_bubble_view_);

[Thiemo Nagel, 2014/05/05 14:48:41]

Done.

+  UpdateState();
+  if (limit_state_ == LIMIT_NONE)
+    return NULL;
+  tray_bubble_view_ = new LabelTrayView(
+      this, IDR_AURA_UBER_TRAY_BUBBLE_SESSION_LENGTH_LIMIT);
+  tray_bubble_view_->SetMessage(tray_bubble_message_);
+  last_tray_bubble_message_ = tray_bubble_message_;
+  return tray_bubble_view_;
 }
 
-void TraySessionLengthLimit::DestroyTrayView() {
-  tray_view_ = NULL;
-}
-
-void TraySessionLengthLimit::UpdateAfterShelfAlignmentChange(
-    ShelfAlignment alignment) {
-  if (tray_view_)
-    tray_view_->UpdateClockLayout(alignment);
+// View has been removed from tray bubble.
+void TraySessionLengthLimit::DestroyDefaultView() {
+  tray_bubble_view_ = NULL;
 }
 
 void TraySessionLengthLimit::OnSessionStartTimeChanged() {
   Update();
 }
 
 void TraySessionLengthLimit::OnSessionLengthLimitChanged() {
   Update();
 }
 
+void TraySessionLengthLimit::OnViewClicked(views::View* sender) {
+}
+
 TraySessionLengthLimit::LimitState
     TraySessionLengthLimit::GetLimitState() const {
   return limit_state_;
 }
 
 base::TimeDelta TraySessionLengthLimit::GetRemainingSessionTime() const {
   return remaining_session_time_;
 }
 
 void TraySessionLengthLimit::Update() {
+  UpdateState();
+  UpdateUI();
+}
+
+void TraySessionLengthLimit::UpdateState() {
   SystemTrayDelegate* delegate = Shell::GetInstance()->system_tray_delegate();
-  const LimitState previous_limit_state = limit_state_;
-  if (!delegate->GetSessionStartTime(&session_start_time_) ||
-      !delegate->GetSessionLengthLimit(&limit_)) {
-    remaining_session_time_ = base::TimeDelta();
-    limit_state_ = LIMIT_NONE;
-    timer_.reset();
-  } else {
+  if (delegate->GetSessionStartTime(&session_start_time_) &&
+      delegate->GetSessionLengthLimit(&limit_)) {
+    const base::TimeDelta expiring_soon_threshold(
+        base::TimeDelta::FromMinutes(kExpiringSoonThresholdInMinutes));
     remaining_session_time_ = std::max(
         limit_ - (base::TimeTicks::Now() - session_start_time_),
         base::TimeDelta());
-    limit_state_ = remaining_session_time_.InSeconds() <=
-        kExpiringSoonThresholdInSeconds ? LIMIT_EXPIRING_SOON : LIMIT_SET;
-    if (!timer_)
-      timer_.reset(new base::RepeatingTimer<TraySessionLengthLimit>);
-    if (!timer_->IsRunning()) {
-      // Start a timer that will update the remaining session time every second.
-      timer_->Start(FROM_HERE,
-                    base::TimeDelta::FromSeconds(1),
-                    this,
-                    &TraySessionLengthLimit::Update);
-    }
+    limit_state_ = remaining_session_time_ <= expiring_soon_threshold ?
+        LIMIT_EXPIRING_SOON : LIMIT_SET;
+  } else {
+    remaining_session_time_ = base::TimeDelta();
+    limit_state_ = LIMIT_NONE;
   }
 
   switch (limit_state_) {

[bartfab (slow), 2014/05/05 13:45:04]

Nit: There is no need for this switch statement anymore. There are only two
cases now, which correspond to the if statement above. You can fold all this
code into the if statement.

[Thiemo Nagel, 2014/05/05 14:48:41]

At least for the moment, I'd like to keep the switch to make it easy to have
different wordings for LIMIT_SET vs. LIMIT_EXPIRING_SOON.  But I moved the timer
to a different place to make the switch more succinct.

[bartfab (slow), 2014/05/05 17:49:58]

Do you have any indication that that will be required? It seems strange to keep
extra code and complexity around just in case a string change may be required at
some point.

[Thiemo Nagel, 2014/05/06 14:28:00]

OK, it's removed.

     case LIMIT_NONE:
-      message_center::MessageCenter::Get()->RemoveNotification(
-          kNotificationId, false /* by_user */);
+      tray_bubble_message_.clear();
+      notification_message_.clear();

[bartfab (slow), 2014/05/05 13:45:04]

Clear the last_ messages as well.

[Thiemo Nagel, 2014/05/05 14:48:41]

Good catch!  Done.

+      timer_.reset();
       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);
+      tray_bubble_message_ = l10n_util::GetStringFUTF16(

[bartfab (slow), 2014/05/05 13:45:04]

Rather than passing information between methods via member variables, which is
akin to globals, why not have this method call two methods such as
UpdateNotification() and UpdateBubbleView(), passing the updated strings to
these?

[Thiemo Nagel, 2014/05/05 14:48:41]

I'd like to keep UpdateState() separate because CreateDefaultView() calls it
before deciding whether a tray bubble view needs to be created.  I wouldn't like
that call to update the UI because that creates the impression of recursion
(even if that would not be the case), making the code harder to read.

[bartfab (slow), 2014/05/05 17:49:58]

What you would gain are considerable memory savings: Right now, this class keeps
up to 6 strings in memory:

(1) notification_message_;
(2) last_notification_message_;
(3) tray_bubble_message_;
(4) last_tray_bubble_message_;
(5) the notification message held in memory by the notification
(6) the bubble message held in memory by the bubble view

There are two redundant pairs in here: (1) == (5) and (3) == (6). If you called
the UI update methods from UpdateState(), you could avoid this redundant memory
use.

[Thiemo Nagel, 2014/05/06 14:28:00]

All redundant strings have been removed.

+          IDS_ASH_STATUS_TRAY_BUBBLE_SESSION_LENGTH_LIMIT,
+          ui::TimeFormat::Detailed(ui::TimeFormat::FORMAT_DURATION,
+                                   ui::TimeFormat::LENGTH_LONG,
+                                   10,
+                                   remaining_session_time_));
+      notification_message_ = l10n_util::GetStringFUTF16(
+          IDS_ASH_STATUS_TRAY_NOTIFICATION_SESSION_LENGTH_LIMIT,
+          ui::TimeFormat::Detailed(ui::TimeFormat::FORMAT_DURATION,
+                                   ui::TimeFormat::LENGTH_LONG,
+                                   10,
+                                   remaining_session_time_));
+      if (!timer_)
+        timer_.reset(new base::RepeatingTimer<TraySessionLengthLimit>);
+      if (!timer_->IsRunning()) {
+        timer_->Start(FROM_HERE,
+                      base::TimeDelta::FromMilliseconds(
+                          kTimerIntervalInMilliseconds),
+                      this,
+                      &TraySessionLengthLimit::Update);
+      }
       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();
+void TraySessionLengthLimit::UpdateUI() {
+  UpdateNotification();
+  UpdateTrayBubbleView();
+}
+
+void TraySessionLengthLimit::UpdateNotification() {
+  message_center::MessageCenter* message_center =
+      message_center::MessageCenter::Get();
+
+  // If state hasn't changed and the notification message hasn't changed,
+  // there's nothing to do.
+  if (limit_state_ == last_limit_state_ &&
+      notification_message_ == last_notification_message_) {
+    return;
+  }
+
+  // If state hasn't changed and the notification has already been acknowledged,
+  // we won't re-create it.
+  if (limit_state_ == last_limit_state_ &&
+      !message_center->HasNotification(kNotificationId)) {
+    return;
+  }
+
+  // After state change, any possibly existing notification is removed to make
+  // sure it is re-shown even if it had been acknowledged by the user before
+  // (and in the rare case of state change towards LIMIT_NONE to make the
+  // notification disappear).
+  if (limit_state_ != last_limit_state_ &&
+      message_center->HasNotification(kNotificationId)) {
+    message_center::MessageCenter::Get()->RemoveNotification(
+        kNotificationId, false /* by_user */);
+  }
+
+  // For LIMIT_NONE, there's nothing more to do.
+  if (limit_state_ == LIMIT_NONE) {
+    last_limit_state_ = limit_state_;
+    return;
+  }
+
+  ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
+  message_center::RichNotificationData data;
+  data.should_make_spoken_feedback_for_popup_updates =
+      (limit_state_ != last_limit_state_);
+  scoped_ptr<message_center::Notification> notification(
+      new message_center::Notification(
+          message_center::NOTIFICATION_TYPE_SIMPLE,
+          kNotificationId,
+          base::string16() /* title */,
+          notification_message_ /* message */,
+          bundle.GetImageNamed(
+              IDR_AURA_UBER_TRAY_NOTIFICATION_SESSION_LENGTH_LIMIT),
+          base::string16() /* display_source */,
+          message_center::NotifierId(
+              message_center::NotifierId::SYSTEM_COMPONENT,
+              system_notifier::kNotifierSessionLengthTimeout),
+          data,
+          NULL /* delegate */));
+  notification->SetSystemPriority();
+  if (message_center->HasNotification(kNotificationId))
+    message_center->UpdateNotification(kNotificationId, notification.Pass());
+  else
+    message_center->AddNotification(notification.Pass());
+  last_limit_state_ = limit_state_;
+  last_notification_message_ = notification_message_;
+}
+
+void TraySessionLengthLimit::UpdateTrayBubbleView() {
+  if (!tray_bubble_view_)
+    return;
+  if (tray_bubble_message_ == last_tray_bubble_message_)
+    return;
+  tray_bubble_view_->SetMessage(tray_bubble_message_);

[bartfab (slow), 2014/05/05 13:45:04]

Why is |last_tray_bubble_message_| necessary? Can you not simply always set the
message and call Layout()? Or does this cause flicker?

[Thiemo Nagel, 2014/05/05 14:48:41]

I haven't tested it, but I figure that Layout() is rather expensive and thus
only call it when necessary.

[bartfab (slow), 2014/05/05 17:49:58]

Looking at the code, Layout() here should be very cheap: LabelTrayView uses a
FillLayout, whose Layout() method is trivial. The Layout() call gets propagated
to the children but nothing much happens there if the bounds have not changed.

The advantage of removing the if statement here is that you could further reduce
memory footprint by not keeping the previous string around.

[Thiemo Nagel, 2014/05/06 14:28:00]

Ok, fine, after our offline discussion I'm removing all strings to favour data
size reduction over conserving CPU.

+  tray_bubble_view_->Layout();
+  last_tray_bubble_message_ = tray_bubble_message_;
 }
 
 }  // namespace ash