Notificaitons refactor step 2

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.h"
+#include "ui/message_center/notification_types.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;
 
 }  // namespace
 
 // Popup notifications contents.
 class PopupBubbleContentsView : public views::View {
  public:
   explicit PopupBubbleContentsView(NotificationList::Delegate* list_delegate);
 
-  void Update(const NotificationList::Notifications& popup_notifications);
+  void Update(const NotificationList::PopupNotifications& popup_notifications);
 
   size_t NumMessageViews() const {
     return content_->child_count();
   }
 
  private:
   NotificationList::Delegate* list_delegate_;
   views::View* content_;
 
   DISALLOW_COPY_AND_ASSIGN(PopupBubbleContentsView);
@@ skipping 10 matching lines @@
   AddChildView(content_);
 
   if (get_use_acceleration_when_possible()) {
     content_->SetPaintToLayer(true);
     content_->SetFillsBoundsOpaquely(false);
     content_->layer()->SetMasksToBounds(true);
   }
 }
 
 void PopupBubbleContentsView::Update(
-    const NotificationList::Notifications& popup_notifications) {
+    const NotificationList::PopupNotifications& popup_notifications) {
   content_->RemoveAllChildViews(true);
-  for (NotificationList::Notifications::const_iterator iter =
+  for (NotificationList::PopupNotifications::const_iterator iter =
            popup_notifications.begin();
        iter != popup_notifications.end(); ++iter) {
-    MessageView* view =
-        NotificationView::ViewForNotification(*iter, list_delegate_);
-    view->SetUpView();
-    content_->AddChildView(view);
+    content_->AddChildView(
+        NotificationView::ViewForNotification(*(*iter), list_delegate_));
   }
   content_->SizeToPreferredSize();
   content_->InvalidateLayout();
   Layout();
   if (GetWidget())
     GetWidget()->GetRootView()->SchedulePaint();
 }
 
 // The timer to call OnAutoClose for |notification|.
 class MessagePopupBubble::AutocloseTimer {
  public:
-  AutocloseTimer(const Notification& notification, MessagePopupBubble* bubble);
+  AutocloseTimer(Notification* notification, MessagePopupBubble* bubble);
 
   void Start();
 
   void Suspend();
 
  private:
   const std::string id_;
   base::TimeDelta delay_;
   base::Time start_time_;
   MessagePopupBubble* bubble_;
   base::OneShotTimer<MessagePopupBubble> timer_;
 
   DISALLOW_COPY_AND_ASSIGN(AutocloseTimer);
 };
 
 MessagePopupBubble::AutocloseTimer::AutocloseTimer(
-    const Notification& notification,
+    Notification* notification,
     MessagePopupBubble* bubble)
-    : id_(notification.id),
+    : id_(notification->id()),
       bubble_(bubble) {
   int seconds = kAutocloseDefaultDelaySeconds;
-  if (notification.priority > ui::notifications::DEFAULT_PRIORITY)
+  if (notification->priority() > DEFAULT_PRIORITY)
     seconds = kAutocloseHighPriorityDelaySeconds;
   delay_ = base::TimeDelta::FromSeconds(seconds);
 }
 
 void MessagePopupBubble::AutocloseTimer::Start() {
   start_time_ = base::Time::Now();
   timer_.Start(FROM_HERE,
                delay_,
                base::Bind(&MessagePopupBubble::OnAutoClose,
                           base::Unretained(bubble_), id_));
@@ skipping 31 matching lines @@
   contents_view_ = new PopupBubbleContentsView(list_delegate());
   bubble_view()->AddChildView(contents_view_);
   UpdateBubbleView();
 }
 
 void MessagePopupBubble::OnBubbleViewDestroyed() {
   contents_view_ = NULL;
 }
 
 void MessagePopupBubble::UpdateBubbleView() {
-  NotificationList::Notifications popups;
-  list_delegate()->GetNotificationList()->GetPopupNotifications(&popups);
+  NotificationList::PopupNotifications popups =
+      list_delegate()->GetNotificationList()->GetPopupNotifications();
 
   if (popups.size() == 0) {
     if (bubble_view())
       bubble_view()->delegate()->HideBubble(bubble_view());  // deletes |this|
     return;
   }
 
   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();
+  for (NotificationList::PopupNotifications::const_iterator iter =
+           popups.begin();
        iter != popups.end(); ++iter) {
+    std::string id = (*iter)->id();
     std::map<std::string, AutocloseTimer*>::const_iterator timer_iter =
-        autoclose_timers_.find(iter->id);
+        autoclose_timers_.find(id);
     if (timer_iter == autoclose_timers_.end()) {
       AutocloseTimer *timer = new AutocloseTimer(*iter, this);
-      autoclose_timers_[iter->id] = timer;
+      autoclose_timers_[id] = timer;
       timer->Start();
     }
-    popup_ids_.insert(iter->id);
-    old_popup_ids.erase(iter->id);
+    popup_ids_.insert(id);
+    old_popup_ids.erase(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() {
@@ skipping 23 matching lines @@
     scoped_ptr<AutocloseTimer> release_timer(iter->second);
     autoclose_timers_.erase(iter);
   }
 }
 
 size_t MessagePopupBubble::NumMessageViewsForTest() const {
   return contents_view_->NumMessageViews();
 }
 
 }  // namespace message_center