Reland: Show message center on lock screen

ui/message_center/message_center_impl.cc

 // Copyright (c) 2013 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_center_impl.h"
 
 #include <algorithm>
 #include <deque>
 #include <utility>
 
@@ skipping 338 matching lines @@
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // MessageCenterImpl
 
 MessageCenterImpl::MessageCenterImpl()
     : MessageCenter(),
       popup_timers_controller_(new PopupTimersController(this)),
       settings_provider_(NULL) {
-  notification_list_.reset(new NotificationList());
+  notification_list_.reset(new NotificationList(this));
 
   bool enable_message_center_changes_while_open = true;  // enable by default
   std::string arg = base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
       switches::kMessageCenterChangesWhileOpen);
   if (!arg.empty()) {
     if (arg == "enabled")
       enable_message_center_changes_while_open = true;
     else if (arg == "disabled")
       enable_message_center_changes_while_open = false;
   }
@@ skipping 63 matching lines @@
 void MessageCenterImpl::NotifierGroupChanged() {}
 
 void MessageCenterImpl::NotifierEnabledChanged(
     const NotifierId& notifier_id, bool enabled) {
   if (!enabled) {
     RemoveNotificationsForNotifierId(notifier_id);
   }
 }
 
 void MessageCenterImpl::SetVisibility(Visibility visibility) {
-  std::set<std::string> updated_ids;
-  notification_list_->SetMessageCenterVisible(
-      (visibility == VISIBILITY_MESSAGE_CENTER), &updated_ids);
-  notification_cache_.RecountUnread();
+  visible_ = (visibility == VISIBILITY_MESSAGE_CENTER);
 
-  for (const auto& id : updated_ids) {
-    FOR_EACH_OBSERVER(
-        MessageCenterObserver, observer_list_, OnNotificationUpdated(id));
+  if (visible_ && !locked_) {
+    std::set<std::string> updated_ids;
+    notification_list_->SetNotificationsShown(blockers_, &updated_ids);
+    notification_cache_.RecountUnread();
+
+    for (const auto& id : updated_ids) {
+      FOR_EACH_OBSERVER(
+          MessageCenterObserver, observer_list_, OnNotificationUpdated(id));
+    }
   }
 
   if (notification_queue_ &&
       visibility == VISIBILITY_TRANSIENT) {
     notification_queue_->ApplyChanges(this);
   }
 
   FOR_EACH_OBSERVER(MessageCenterObserver,
                     observer_list_,
                     OnCenterVisibilityChanged(visibility));
 }
 
 bool MessageCenterImpl::IsMessageCenterVisible() const {
-  return notification_list_->is_message_center_visible();
+  return visible_;
 }
 
 size_t MessageCenterImpl::NotificationCount() const {
   return notification_cache_.visible_notifications.size();
 }
 
 size_t MessageCenterImpl::UnreadNotificationCount() const {
   return notification_cache_.unread_count;
 }
 
 bool MessageCenterImpl::HasPopupNotifications() const {
   return !IsMessageCenterVisible() &&
       notification_list_->HasPopupNotifications(blockers_);
 }
 
 bool MessageCenterImpl::IsQuietMode() const {
   return notification_list_->quiet_mode();
 }
 
+bool MessageCenterImpl::IsLockedState() const {
+  return locked_;
+}
+
 bool MessageCenterImpl::HasClickedListener(const std::string& id) {
   scoped_refptr<NotificationDelegate> delegate =
       notification_list_->GetNotificationDelegate(id);
   return delegate.get() && delegate->HasClickedListener();
 }
 
 message_center::Notification* MessageCenterImpl::FindVisibleNotificationById(
     const std::string& id) {
   return notification_list_->GetNotificationById(id);
 }
@@ skipping 15 matching lines @@
 
 //------------------------------------------------------------------------------
 // Client code interface.
 void MessageCenterImpl::AddNotification(
     std::unique_ptr<Notification> notification) {
   DCHECK(notification);
   const std::string id = notification->id();
   for (size_t i = 0; i < blockers_.size(); ++i)
     blockers_[i]->CheckState();
 
-  if (notification_queue_ &&
-      notification_list_->is_message_center_visible()) {
+  if (notification_queue_ && visible_) {
     notification_queue_->AddNotification(std::move(notification));
     return;
   }
 
   AddNotificationImmediately(std::move(notification));
 }
 
 void MessageCenterImpl::AddNotificationImmediately(
     std::unique_ptr<Notification> notification) {
   const std::string id = notification->id();
@@ skipping 14 matching lines @@
         MessageCenterObserver, observer_list_, OnNotificationAdded(id));
   }
 }
 
 void MessageCenterImpl::UpdateNotification(
     const std::string& old_id,
     std::unique_ptr<Notification> new_notification) {
   for (size_t i = 0; i < blockers_.size(); ++i)
     blockers_[i]->CheckState();
 
-  if (notification_queue_ &&
-      notification_list_->is_message_center_visible()) {
+  if (notification_queue_ && visible_) {
     // We will allow notifications that are progress types (and stay progress
     // types) to be updated even if the message center is open.  There are 3
     // requirements here:
     //  * Notification of type PROGRESS exists with same ID in the center
     //  * There are no queued updates for this notification (they imply a change
     //    that violates the PROGRESS invariant
     //  * The new notification is type PROGRESS.
     // TODO(dewittj): Ensure this works when the ID is changed by the caller.
     // This shouldn't be an issue in practice since only W3C notifications
     // change the ID on update, and they don't have progress type notifications.
@@ skipping 27 matching lines @@
   } else {
     FOR_EACH_OBSERVER(MessageCenterObserver, observer_list_,
                       OnNotificationRemoved(old_id, false));
     FOR_EACH_OBSERVER(MessageCenterObserver, observer_list_,
                       OnNotificationAdded(new_id));
   }
 }
 
 void MessageCenterImpl::RemoveNotification(const std::string& id,
                                            bool by_user) {
-  if (notification_queue_ && !by_user &&
-      notification_list_->is_message_center_visible()) {
+  if (notification_queue_ && !by_user && visible_) {
     notification_queue_->EraseNotification(id, by_user);
     return;
   }
 
   RemoveNotificationImmediately(id, by_user);
 }
 
 void MessageCenterImpl::RemoveNotificationImmediately(
     const std::string& id, bool by_user) {
   if (FindVisibleNotificationById(id) == NULL)
@@ skipping 231 matching lines @@
 void MessageCenterImpl::SetQuietMode(bool in_quiet_mode) {
   if (in_quiet_mode != notification_list_->quiet_mode()) {
     notification_list_->SetQuietMode(in_quiet_mode);
     FOR_EACH_OBSERVER(MessageCenterObserver,
                       observer_list_,
                       OnQuietModeChanged(in_quiet_mode));
   }
   quiet_mode_timer_.reset();
 }
 
+void MessageCenterImpl::SetLockedState(bool locked) {
+  if (locked != locked_) {
+    locked_ = locked;
+    FOR_EACH_OBSERVER(MessageCenterObserver, observer_list_,
+                      OnLockedStateChanged(locked));
+  }
+}
+
 void MessageCenterImpl::EnterQuietModeWithExpire(
     const base::TimeDelta& expires_in) {
   if (quiet_mode_timer_) {
     // Note that the capital Reset() is the method to restart the timer, not
     // scoped_ptr::reset().
     quiet_mode_timer_->Reset();
   } else {
     notification_list_->SetQuietMode(true);
     FOR_EACH_OBSERVER(
         MessageCenterObserver, observer_list_, OnQuietModeChanged(true));
@@ skipping 22 matching lines @@
 }
 
 void MessageCenterImpl::EnableChangeQueueForTest(bool enable) {
   if (enable)
     notification_queue_.reset(new internal::ChangeQueue());
   else
     notification_queue_.reset();
 }
 
 }  // namespace message_center