Update appearance of read Ash notifications.

ash/system/web_notification/web_notification_tray.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/web_notification/web_notification_tray.h"
 
 #include "ash/system/status_area_widget.h"
 #include "ash/system/tray/system_tray.h"
 #include "ash/system/tray/tray_bubble_view.h"
 #include "ash/system/tray/tray_constants.h"
@@ skipping 62 matching lines @@
   return base::StringPrintf("%d", notification_count);
 }
 
 }  // namespace
 
 namespace ash {
 
 namespace internal {
 
 struct WebNotification {
-  WebNotification(const std::string& i,
-                  const string16& t,
-                  const string16& m,
-                  const string16& s,
-                  const std::string& e)
-      : id(i),
-        title(t),
-        message(m),
-        display_source(s),
-        extension_id(e) {
-  }
-
+  WebNotification() : is_read(false) {}
   std::string id;
   string16 title;
   string16 message;
   string16 display_source;
   std::string extension_id;
   gfx::ImageSkia image;
+  bool is_read;
 };
 
 // A helper class to manage the list of notifications.
 class WebNotificationList {
  public:
   typedef std::list<WebNotification> Notifications;
 
-  WebNotificationList() {
+  WebNotificationList()
+      : is_visible_(false),
+        unread_count_(0) {
+  }
+
+  void SetIsVisible(bool visible) {
+    if (is_visible_ == visible)
+      return;
+    is_visible_ = visible;
+    if (visible) {
+      // Clear the unread count when the list is shown.
+      unread_count_ = 0;
+    } else {
+      // Mark all notifications as read when the list is hidden.
+      for (Notifications::iterator iter = notifications_.begin();
+           iter != notifications_.end(); ++iter) {
+        iter->is_read = true;
+      }
+    }
   }
 
   void AddNotification(const std::string& id,
                        const string16& title,
                        const string16& message,
                        const string16& display_source,
                        const std::string& extension_id) {
+    WebNotification notification;
     Notifications::iterator iter = GetNotification(id);
     if (iter != notifications_.end()) {
-      // Update existing notification.
-      iter->title = title;
-      iter->message = message;
-      iter->display_source = display_source;
-      iter->extension_id = extension_id;
-    } else {
-      notifications_.push_front(
-          WebNotification(id, title, message, display_source, extension_id));
+      notification = *iter;
+      EraseNotification(iter);
     }
+    notification.id = id;
+    notification.title = title;
+    notification.message = message;
+    notification.display_source = display_source;
+    notification.extension_id = extension_id;
+    notification.is_read = false;
+    PushNotification(notification);
   }
 
   void UpdateNotificationMessage(const std::string& id,
                                  const string16& title,
                                  const string16& message) {
     Notifications::iterator iter = GetNotification(id);
     if (iter == notifications_.end())
       return;
-    iter->title = title;
-    iter->message = message;
+    // Copy and update notification, then move it to the front of the list.
+    WebNotification notification(*iter);
+    notification.title = title;
+    notification.message = message;
+    notification.is_read = false;
+    EraseNotification(iter);
+    PushNotification(notification);
   }
 
   bool RemoveNotification(const std::string& id) {
     Notifications::iterator iter = GetNotification(id);
     if (iter == notifications_.end())
       return false;
-    notifications_.erase(iter);
+    EraseNotification(iter);
     return true;
   }
 
   void RemoveAllNotifications() {
     notifications_.clear();
   }
 
   void RemoveNotificationsBySource(const std::string& id) {
     Notifications::iterator source_iter = GetNotification(id);
     if (source_iter == notifications_.end())
       return;
     string16 display_source = source_iter->display_source;
     for (Notifications::iterator loopiter = notifications_.begin();
          loopiter != notifications_.end(); ) {
       Notifications::iterator curiter = loopiter++;
       if (curiter->display_source == display_source)
-        notifications_.erase(curiter);
+        EraseNotification(curiter);
     }
   }
 
   void RemoveNotificationsByExtension(const std::string& id) {
     Notifications::iterator source_iter = GetNotification(id);
     if (source_iter == notifications_.end())
       return;
     std::string extension_id = source_iter->extension_id;
     for (Notifications::iterator loopiter = notifications_.begin();
          loopiter != notifications_.end(); ) {
       Notifications::iterator curiter = loopiter++;
       if (curiter->extension_id == extension_id)
-        notifications_.erase(curiter);
+        EraseNotification(curiter);
     }
   }
 
   bool SetNotificationImage(const std::string& id,
                             const gfx::ImageSkia& image) {
     Notifications::iterator iter = GetNotification(id);
     if (iter == notifications_.end())
       return false;
     iter->image = image;
     return true;
   }
 
+  std::string GetFirstId() {
+    if (notifications_.empty())
+      return std::string();
+    return notifications_.front().id;
+  }
+
   const Notifications& notifications() const { return notifications_; }
+  int unread_count() const { return unread_count_; }
 
  private:
   Notifications::iterator GetNotification(const std::string& id) {
     for (Notifications::iterator iter = notifications_.begin();
          iter != notifications_.end(); ++iter) {
       if (iter->id == id)
         return iter;
     }
     return notifications_.end();
   }
 
+  void EraseNotification(Notifications::iterator iter) {
+    if (!is_visible_ && !iter->is_read)
+      --unread_count_;
+    notifications_.erase(iter);
+  }
+
+  void PushNotification(const WebNotification& notification) {
+    if (!is_visible_)
+      ++unread_count_;
+    notifications_.push_front(notification);
+  }
+
   Notifications notifications_;
+  bool is_visible_;
+  int unread_count_;
 
   DISALLOW_COPY_AND_ASSIGN(WebNotificationList);
 };
 
 // A dropdown menu for notifications.
 class WebNotificationMenuModel : public ui::SimpleMenuModel,
                                  public ui::SimpleMenuModel::Delegate {
  public:
   explicit WebNotificationMenuModel(WebNotificationTray* tray,
                                     const WebNotification& notification)
@@ skipping 90 matching lines @@
     InitView(tray, notification);
   }
 
   virtual ~WebNotificationView() {
   }
 
   void InitView(WebNotificationTray* tray,
                 const WebNotification& notification) {
     set_border(views::Border::CreateSolidSidedBorder(
         1, 0, 0, 0, kBorderLightColor));
-    set_background(views::Background::CreateSolidBackground(kBackgroundColor));
+    SkColor bg_color = notification.is_read
+        ? kHeaderBackgroundColorLight : kBackgroundColor;
+    set_background(views::Background::CreateSolidBackground(bg_color));
 
     icon_ = new views::ImageView;
     icon_->SetImageSize(
         gfx::Size(kWebNotificationIconSize, kWebNotificationIconSize));
     icon_->SetImage(notification.image);
 
     views::Label* title = new views::Label(notification.title);
     title->SetHorizontalAlignment(views::Label::ALIGN_LEFT);
     title->SetFont(title->font().DeriveFont(0, gfx::Font::BOLD));
     views::Label* message = new views::Label(notification.message);
@@ skipping 246 matching lines @@
         new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 1));
     AddChildView(content_);
   }
 
   void Update(const WebNotificationList::Notifications& notifications) {
     content_->RemoveAllChildViews(true);
     WebNotificationList::Notifications::const_iterator iter =
         notifications.begin();
     WebNotificationView* view = new WebNotificationView(tray_, *iter);
     content_->AddChildView(view);
+    Layout();
     GetWidget()->GetRootView()->SchedulePaint();
   }
 
  private:
   WebNotificationTray* tray_;
   views::View* content_;
 
   DISALLOW_COPY_AND_ASSIGN(WebNotificationContentsView);
 };
 
@@ skipping 136 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(Bubble);
 };
 
 WebNotificationTray::WebNotificationTray(
     internal::StatusAreaWidget* status_area_widget)
     : internal::TrayBackgroundView(status_area_widget),
       notification_list_(new WebNotificationList()),
       count_label_(NULL),
       delegate_(NULL),
-      show_message_center_on_unlock_(false),
-      unread_count_(0) {
+      show_message_center_on_unlock_(false) {
   count_label_ = new views::Label(UTF8ToUTF16("0"));
   internal::SetupLabelForTray(count_label_);
   gfx::Font font = count_label_->font();
   count_label_->SetFont(font.DeriveFont(0, font.GetStyle() & ~gfx::Font::BOLD));
   count_label_->SetHorizontalAlignment(views::Label::ALIGN_CENTER);
 
   tray_container()->set_size(gfx::Size(kTrayWidth, kTrayHeight));
   tray_container()->AddChildView(count_label_);
 
   UpdateTray();
 }
 
 WebNotificationTray::~WebNotificationTray() {
 }
 
 void WebNotificationTray::SetDelegate(Delegate* delegate) {
   DCHECK(!delegate_);
   delegate_ = delegate;
 }
 
 void WebNotificationTray::AddNotification(const std::string& id,
                                           const string16& title,
                                           const string16& message,
                                           const string16& display_source,
                                           const std::string& extension_id) {
   notification_list_->AddNotification(
       id, title, message, display_source, extension_id);
-  if (!message_center_bubble())
-    ++unread_count_;
   UpdateTrayAndBubble();
-  if (!message_center_bubble())
-    ShowNotificationBubble();
+  ShowNotificationBubble();
 }
 
 void WebNotificationTray::UpdateNotification(const std::string& id,
                                              const string16& title,
                                              const string16& message) {
   notification_list_->UpdateNotificationMessage(id, title, message);
   UpdateTrayAndBubble();
+  ShowNotificationBubble();
 }
 
 void WebNotificationTray::RemoveNotification(const std::string& id) {
+  if (id == notification_list_->GetFirstId())
+    HideNotificationBubble();
   if (!notification_list_->RemoveNotification(id))
     return;
   if (delegate_)
     delegate_->NotificationRemoved(id);
   UpdateTrayAndBubble();
 }
 
 void WebNotificationTray::RemoveAllNotifications() {
   const WebNotificationList::Notifications& notifications =
       notification_list_->notifications();
   if (delegate_) {
     for (WebNotificationList::Notifications::const_iterator loopiter =
              notifications.begin();
          loopiter != notifications.end(); ) {
       WebNotificationList::Notifications::const_iterator curiter = loopiter++;
       std::string notification_id = curiter->id;
       // May call RemoveNotification and erase curiter.
       delegate_->NotificationRemoved(notification_id);
     }
   }
   notification_list_->RemoveAllNotifications();
   UpdateTrayAndBubble();
 }
 
 void WebNotificationTray::SetNotificationImage(const std::string& id,
                                                const gfx::ImageSkia& image) {
   if (!notification_list_->SetNotificationImage(id, image))
     return;
   UpdateTrayAndBubble();
+  if (notification_bubble() && id == notification_list_->GetFirstId())
+    ShowNotificationBubble();
 }
 
 void WebNotificationTray::DisableByExtension(const std::string& id) {
   // When we disable notifications, we remove any existing matching
   // notifications to avoid adding complicated UI to re-enable the source.
+  if (id == notification_list_->GetFirstId())
+    HideNotificationBubble();
   notification_list_->RemoveNotificationsByExtension(id);
   UpdateTrayAndBubble();
   if (delegate_)
     delegate_->DisableExtension(id);
 }
 
 void WebNotificationTray::DisableByUrl(const std::string& id) {
   // See comment for DisableByExtension.
+  if (id == notification_list_->GetFirstId())
+    HideNotificationBubble();
   notification_list_->RemoveNotificationsBySource(id);
   UpdateTrayAndBubble();
   if (delegate_)
     delegate_->DisableNotificationsFromSource(id);
 }
 
 void WebNotificationTray::ShowMessageCenterBubble() {
   if (status_area_widget()->login_status() == user::LOGGED_IN_LOCKED)
     return;
-  unread_count_ = 0;
+  if (message_center_bubble() || GetNotificationCount() == 0) {
+    UpdateTray();
+    return;
+  }
+  notification_list_->SetIsVisible(true);  // clears notification count
   UpdateTray();
-  if (message_center_bubble())
-    return;
-  if (GetNotificationCount() == 0)
-    return;
-  notification_bubble_.reset();
+  HideNotificationBubble();
   message_center_bubble_.reset(
       new Bubble(this, Bubble::BUBBLE_TYPE_MESAGE_CENTER));
   status_area_widget()->SetHideSystemNotifications(true);
 }
 
 void WebNotificationTray::HideMessageCenterBubble() {
   message_center_bubble_.reset();
   show_message_center_on_unlock_ = false;
+  notification_list_->SetIsVisible(false);
   status_area_widget()->SetHideSystemNotifications(false);
 }
 
 void WebNotificationTray::ShowNotificationBubble() {
   if (status_area_widget()->login_status() == user::LOGGED_IN_LOCKED)
     return;
   if (message_center_bubble())
     return;
   if (!status_area_widget()->ShouldShowNonSystemNotifications())
     return;
   UpdateTray();
-  notification_bubble_.reset(
-      new Bubble(this, Bubble::BUBBLE_TYPE_NOTIFICATION));
+  if (notification_bubble()) {
+    notification_bubble()->ScheduleUpdate();
+  } else {
+    notification_bubble_.reset(
+        new Bubble(this, Bubble::BUBBLE_TYPE_NOTIFICATION));
+  }
 }
 
 void WebNotificationTray::HideNotificationBubble() {
   notification_bubble_.reset();
 }
 
 void WebNotificationTray::UpdateAfterLoginStatusChange(
     user::LoginStatus login_status) {
   if (login_status == user::LOGGED_IN_LOCKED) {
     if (message_center_bubble()) {
       message_center_bubble_.reset();
       show_message_center_on_unlock_ = true;
     }
-    if (notification_bubble())
-      notification_bubble_.reset();
+    HideNotificationBubble();
   } else {
     if (show_message_center_on_unlock_)
       ShowMessageCenterBubble();
     show_message_center_on_unlock_ = false;
   }
   UpdateTray();
 }
 
 void WebNotificationTray::ShowSettings(const std::string& id) {
   if (delegate_)
     delegate_->ShowSettings(id);
 }
 
 void WebNotificationTray::OnClicked(const std::string& id) {
   if (delegate_)
     delegate_->OnClicked(id);
 }
 
 void WebNotificationTray::SetShelfAlignment(ShelfAlignment alignment) {
   if (alignment == shelf_alignment())
     return;
   internal::TrayBackgroundView::SetShelfAlignment(alignment);
   if (alignment == SHELF_ALIGNMENT_BOTTOM)
     tray_container()->set_size(gfx::Size(kTrayWidth, kTrayHeight));
   else
     tray_container()->set_size(gfx::Size(kTraySideWidth, kTraySideHeight));
   // Destroy any existing bubble so that it will be rebuilt correctly.
-  message_center_bubble_.reset();
-  notification_bubble_.reset();
+  HideMessageCenterBubble();
+  HideNotificationBubble();
 }
 
 bool WebNotificationTray::PerformAction(const views::Event& event) {
   if (message_center_bubble())
     HideMessageCenterBubble();
   else
     ShowMessageCenterBubble();
   return true;
 }
 
 int WebNotificationTray::GetNotificationCount() const {
   return notification_list()->notifications().size();
 }
 
 void WebNotificationTray::UpdateTray() {
-  count_label_->SetText(UTF8ToUTF16(GetNotificationText(unread_count_)));
+  count_label_->SetText(UTF8ToUTF16(
+      GetNotificationText(notification_list()->unread_count())));
   Layout();
   SchedulePaint();
 }
 
 void WebNotificationTray::UpdateTrayAndBubble() {
   UpdateTray();
   if (GetNotificationCount() == 0) {
     HideMessageCenterBubble();
-    notification_bubble_.reset();
+    HideNotificationBubble();
     return;
   }
   if (message_center_bubble())
     message_center_bubble()->ScheduleUpdate();
   if (notification_bubble())
     notification_bubble()->ScheduleUpdate();
 }
 
 void WebNotificationTray::HideBubble(Bubble* bubble) {
   if (bubble == message_center_bubble()) {
     HideMessageCenterBubble();
   } else if (bubble == notification_bubble()) {
-    notification_bubble_.reset();
+    HideNotificationBubble();
   }
 }
 
 }  // namespace ash