Sets per-item timers rather than global timer.

ui/message_center/message_popup_bubble.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 "ui/message_center/message_popup_bubble.h"
 
 #include "base/bind.h"
+#include "base/stl_util.h"
 #include "ui/message_center/message_view.h"
 #include "ui/message_center/notification_view.h"
 #include "ui/notifications/notification_types.h"
 #include "ui/views/bubble/tray_bubble_view.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 namespace message_center {
 namespace {
 
 const int kAutocloseHighPriorityDelaySeconds = 25;
 const int kAutocloseDefaultDelaySeconds = 8;
 
-std::vector<const NotificationList::Notification*> GetNewNotifications(
-    const NotificationList::Notifications& old_list,
-    const NotificationList::Notifications& new_list) {
-  std::set<std::string> existing_ids;
-  std::vector<const NotificationList::Notification*> result;
-  for (NotificationList::Notifications::const_iterator iter = old_list.begin();
-       iter != old_list.end(); ++iter) {
-    existing_ids.insert(iter->id);
-  }
-  for (NotificationList::Notifications::const_iterator iter = new_list.begin();
-       iter != new_list.end(); ++iter) {
-    if (existing_ids.find(iter->id) == existing_ids.end())
-      result.push_back(&(*iter));
-  }
-  return result;
-}
-
 }  // namespace
 
 // Popup notifications contents.
 class PopupBubbleContentsView : public views::View {
  public:
   explicit PopupBubbleContentsView(NotificationList::Delegate* list_delegate)
       : list_delegate_(list_delegate) {
     SetLayoutManager(
         new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 1));
 
@@ skipping 30 matching lines @@
     return content_->child_count();
   }
 
  private:
   NotificationList::Delegate* list_delegate_;
   views::View* content_;
 
   DISALLOW_COPY_AND_ASSIGN(PopupBubbleContentsView);
 };
 
+// The timer to call OnAutoClose for |notification|.
+class MessagePopupBubble::AutocloseTimer {
+ public:
+  AutocloseTimer(const NotificationList::Notification& notification,
+                 MessagePopupBubble* bubble)
+      : id_(notification.id),
+        bubble_(bubble) {
+    int seconds = kAutocloseDefaultDelaySeconds;
+    if (notification.priority > ui::notifications::DEFAULT_PRIORITY)
+      seconds = kAutocloseHighPriorityDelaySeconds;
+    delay_ = base::TimeDelta::FromSeconds(seconds);
+  }

[dharcourt, 2013/01/30 23:24:47]

I may be misapplying that to this, but it seems this may be one of those cases
where the Chromium style recommends not using inline constructors
(http://dev.chromium.org/developers/coding-style/cpp-dos-and-donts#TOC-Stop-in...).

[Jun Mukai, 2013/01/31 18:59:09]

Thanks.  Moved out-of-line (and fixed PopupBubbleContentsView for consistency)

+
+  void Start() {
+    start_time_ = base::Time::Now();
+    timer_.Start(FROM_HERE,
+                 delay_,
+                 base::Bind(&MessagePopupBubble::OnAutoClose,
+                            base::Unretained(bubble_), id_));
+  }
+
+  void Suspend() {
+    base::TimeDelta passed = base::Time::Now() - start_time_;
+    delay_ = std::max(base::TimeDelta(), delay_ - passed);
+    timer_.Reset();
+  }
+
+ private:
+  const std::string id_;
+  base::TimeDelta delay_;
+  base::Time start_time_;
+  MessagePopupBubble* bubble_;
+  base::OneShotTimer<MessagePopupBubble> timer_;
+
+  DISALLOW_COPY_AND_ASSIGN(AutocloseTimer);
+};
+
 // MessagePopupBubble
 MessagePopupBubble::MessagePopupBubble(NotificationList::Delegate* delegate)
     : MessageBubbleBase(delegate),
-      contents_view_(NULL),
-      should_run_default_timer_(false),
-      should_run_high_timer_(false) {
+      contents_view_(NULL) {
 }
 
 MessagePopupBubble::~MessagePopupBubble() {
+  STLDeleteContainerPairSecondPointers(autoclose_timers_.begin(),
+                                       autoclose_timers_.end());
 }
 
 views::TrayBubbleView::InitParams MessagePopupBubble::GetInitParams(
     views::TrayBubbleView::AnchorAlignment anchor_alignment) {
   views::TrayBubbleView::InitParams init_params =
       GetDefaultInitParams(anchor_alignment);
   init_params.arrow_color = kBackgroundColor;
   init_params.close_on_deactivate = false;
   return init_params;
 }
 
 void MessagePopupBubble::InitializeContents(
     views::TrayBubbleView* new_bubble_view) {
   set_bubble_view(new_bubble_view);
   contents_view_ = new PopupBubbleContentsView(list_delegate());
   bubble_view()->AddChildView(contents_view_);
   UpdateBubbleView();
 }
 
 void MessagePopupBubble::OnBubbleViewDestroyed() {
   contents_view_ = NULL;
 }
 
 void MessagePopupBubble::UpdateBubbleView() {
-  NotificationList::Notifications new_notifications;
-  list_delegate()->GetNotificationList()->GetPopupNotifications(
-      &new_notifications);
-  if (new_notifications.size() == 0) {
+  NotificationList::Notifications popups;
+  list_delegate()->GetNotificationList()->GetPopupNotifications(&popups);
+
+  if (popups.size() == 0) {
     if (bubble_view())
       bubble_view()->delegate()->HideBubble(bubble_view());  // deletes |this|
     return;
   }
-  // Only reset the timer when the number of visible notifications changes.
-  std::vector<const NotificationList::Notification*> added =
-      GetNewNotifications(popup_notifications_, new_notifications);
-  bool run_default = false;
-  bool run_high = false;
-  for (std::vector<const NotificationList::Notification*>::const_iterator iter =
-           added.begin(); iter != added.end(); ++iter) {
-    if ((*iter)->priority == ui::notifications::DEFAULT_PRIORITY)
-      run_default = true;
-    else if ((*iter)->priority >= ui::notifications::HIGH_PRIORITY)
-      run_high = true;
-  }
-  // Currently MAX priority is same as HIGH priority.
-  if (run_high)
-    StartAutoCloseTimer(ui::notifications::MAX_PRIORITY);
-  if (run_default)
-    StartAutoCloseTimer(ui::notifications::DEFAULT_PRIORITY);
-  should_run_high_timer_ = run_high;
-  should_run_default_timer_ = run_default;
-  contents_view_->Update(new_notifications);
-  popup_notifications_.swap(new_notifications);
+
+  contents_view_->Update(popups);
   bubble_view()->Show();
   bubble_view()->UpdateBubble();
+
+  std::set<std::string> old_popup_ids;
+  old_popup_ids.swap(popup_ids_);
+
+  // Start autoclose timers.
+  for (NotificationList::Notifications::const_iterator iter = popups.begin();
+       iter != popups.end(); ++iter) {
+    std::map<std::string, AutocloseTimer*>::const_iterator timer_iter =
+        autoclose_timers_.find(iter->id);
+    if (timer_iter == autoclose_timers_.end()) {
+      AutocloseTimer *timer = new AutocloseTimer(*iter, this);
+      autoclose_timers_[iter->id] = timer;
+      timer->Start();
+    }
+    popup_ids_.insert(iter->id);
+    old_popup_ids.erase(iter->id);
+  }
+
+  // Stops timers whose notifications are gone.
+  for (std::set<std::string>::const_iterator iter = old_popup_ids.begin();
+       iter != old_popup_ids.end(); ++iter) {
+    DeleteTimer(*iter);
+  }
 }
 
 void MessagePopupBubble::OnMouseEnteredView() {
-  StopAutoCloseTimer();
+  for (std::map<std::string, AutocloseTimer*>::iterator iter =
+           autoclose_timers_.begin(); iter != autoclose_timers_.end(); ++iter) {
+    iter->second->Suspend();
+  }
 }
 
 void MessagePopupBubble::OnMouseExitedView() {
-  if (should_run_high_timer_)
-    StartAutoCloseTimer(ui::notifications::HIGH_PRIORITY);
-  if (should_run_default_timer_)
-    StartAutoCloseTimer(ui::notifications::DEFAULT_PRIORITY);
+  for (std::map<std::string, AutocloseTimer*>::iterator iter =
+           autoclose_timers_.begin(); iter != autoclose_timers_.end(); ++iter) {
+    iter->second->Start();
+  }
 }
 
-void MessagePopupBubble::StartAutoCloseTimer(int priority) {
-  base::TimeDelta seconds;
-  base::OneShotTimer<MessagePopupBubble>* timer = NULL;
-  if (priority == ui::notifications::MAX_PRIORITY) {
-    seconds = base::TimeDelta::FromSeconds(kAutocloseHighPriorityDelaySeconds);
-    timer = &autoclose_high_;
-  } else {
-    seconds = base::TimeDelta::FromSeconds(kAutocloseDefaultDelaySeconds);
-    timer = &autoclose_default_;
-  }
-
-  timer->Start(FROM_HERE,
-               seconds,
-               base::Bind(&MessagePopupBubble::OnAutoClose,
-                          base::Unretained(this), priority));
-}
-
-void MessagePopupBubble::StopAutoCloseTimer() {
-  autoclose_high_.Stop();
-  autoclose_default_.Stop();
-}
-
-void MessagePopupBubble::OnAutoClose(int priority) {
-  list_delegate()->GetNotificationList()->MarkPopupsAsShown(priority);
-  if (priority == ui::notifications::MAX_PRIORITY)
-    list_delegate()->GetNotificationList()->MarkPopupsAsShown(
-        ui::notifications::HIGH_PRIORITY);
-
-  if (priority >= ui::notifications::MAX_PRIORITY)
-    should_run_high_timer_ = false;
-  else
-    should_run_default_timer_ = false;
+void MessagePopupBubble::OnAutoClose(const std::string& id) {
+  DeleteTimer(id);
+  list_delegate()->GetNotificationList()->MarkSinglePopupAsShown(id, false);
   UpdateBubbleView();
 }
 
+void MessagePopupBubble::DeleteTimer(const std::string& id) {
+  std::map<std::string, AutocloseTimer*>::iterator iter =
+      autoclose_timers_.find(id);
+  if (iter != autoclose_timers_.end()) {
+    delete iter->second;
+    autoclose_timers_.erase(iter);

[dharcourt, 2013/01/30 23:24:47]

Will this make autoclose_timers_ briefly contain a pointer to an invalid timer?
Is there any way this could be a problem? If so it seems like it would be easy
to remove the timer autoclose_timers_ before deleting it.

[Jun Mukai, 2013/01/31 18:59:09]

using scoped_ptr to ensure releasing the object after erase()

+  }
+}
+
 size_t MessagePopupBubble::NumMessageViewsForTest() const {
   return contents_view_->NumMessageViews();
 }
 
 }  // namespace message_center