ui/message_center/notification.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/message_center/notification.h"
   6
   7 #include "base/logging.h"
   8 #include "ui/message_center/notification_delegate.h"
   9 #include "ui/message_center/notification_types.h"
  10
  11 namespace {
  12 unsigned g_next_serial_number_ = 0;
  13 }
  14
  15 namespace message_center {
  16
  17 NotificationItem::NotificationItem(const base::string16& title,
  18                                    const base::string16& message)
  19  : title(title),
  20    message(message) {
  21 }
  22
  23 ButtonInfo::ButtonInfo(const base::string16& title)
  24  : title(title) {
  25 }
  26
  27 RichNotificationData::RichNotificationData()
  28     : priority(DEFAULT_PRIORITY),
  29       never_timeout(false),
  30       timestamp(base::Time::Now()),
  31       progress(0),
  32       should_make_spoken_feedback_for_popup_updates(true),
  33       clickable(true) {}
  34
  35 RichNotificationData::RichNotificationData(const RichNotificationData& other)
  36     : priority(other.priority),
  37       never_timeout(other.never_timeout),
  38       timestamp(other.timestamp),
  39       context_message(other.context_message),
  40       image(other.image),
  41       small_image(other.small_image),
  42       items(other.items),
  43       progress(other.progress),
  44       buttons(other.buttons),
  45       should_make_spoken_feedback_for_popup_updates(
  46           other.should_make_spoken_feedback_for_popup_updates),
  47       clickable(other.clickable) {}
  48
  49 RichNotificationData::~RichNotificationData() {}
  50
  51 Notification::Notification(NotificationType type,
  52                            const std::string& id,
  53                            const base::string16& title,
  54                            const base::string16& message,
  55                            const gfx::Image& icon,
  56                            const base::string16& display_source,
  57                            const NotifierId& notifier_id,
  58                            const RichNotificationData& optional_fields,
  59                            NotificationDelegate* delegate)
  60     : type_(type),
  61       id_(id),
  62       title_(title),
  63       message_(message),
  64       icon_(icon),
  65       display_source_(display_source),
  66       notifier_id_(notifier_id),
  67       serial_number_(g_next_serial_number_++),
  68       optional_fields_(optional_fields),
  69       shown_as_popup_(false),
  70       is_read_(false),
  71       delegate_(delegate) {}
  72
  73 Notification::Notification(const Notification& other)
  74     : type_(other.type_),
  75       id_(other.id_),
  76       title_(other.title_),
  77       message_(other.message_),
  78       icon_(other.icon_),
  79       display_source_(other.display_source_),
  80       notifier_id_(other.notifier_id_),
  81       serial_number_(other.serial_number_),
  82       optional_fields_(other.optional_fields_),
  83       shown_as_popup_(other.shown_as_popup_),
  84       is_read_(other.is_read_),
  85       delegate_(other.delegate_) {}
  86
  87 Notification& Notification::operator=(const Notification& other) {
  88   type_ = other.type_;
  89   id_ = other.id_;
  90   title_ = other.title_;
  91   message_ = other.message_;
  92   icon_ = other.icon_;
  93   display_source_ = other.display_source_;
  94   notifier_id_ = other.notifier_id_;
  95   serial_number_ = other.serial_number_;
  96   optional_fields_ = other.optional_fields_;
  97   shown_as_popup_ = other.shown_as_popup_;
  98   is_read_ = other.is_read_;
  99   delegate_ = other.delegate_;
 100
 101   return *this;
 102 }
 103
 104 Notification::~Notification() {}
 105
 106 bool Notification::IsRead() const {
 107   return is_read_ || optional_fields_.priority == MIN_PRIORITY;
 108 }
 109
 110 void Notification::CopyState(Notification* base) {
 111   shown_as_popup_ = base->shown_as_popup();
 112   is_read_ = base->is_read_;
 113   if (!delegate_.get())
 114     delegate_ = base->delegate();
 115   optional_fields_.never_timeout = base->never_timeout();
 116 }
 117
 118 void Notification::SetButtonIcon(size_t index, const gfx::Image& icon) {
 119   if (index >= optional_fields_.buttons.size())
 120     return;
 121   optional_fields_.buttons[index].icon = icon;
 122 }
 123
 124 void Notification::SetSystemPriority() {
 125   optional_fields_.priority = SYSTEM_PRIORITY;
 126   optional_fields_.never_timeout = true;
 127 }
 128
 129 // static
 130 scoped_ptr<Notification> Notification::CreateSystemNotification(
 131     const std::string& notification_id,
 132     const base::string16& title,
 133     const base::string16& message,
 134     const gfx::Image& icon,
 135     const std::string& system_component_id,
 136     const base::Closure& click_callback) {
 137   scoped_ptr<Notification> notification(
 138       new Notification(
 139           NOTIFICATION_TYPE_SIMPLE,
 140           notification_id,
 141           title,
 142           message,
 143           icon,
 144           base::string16()  /* display_source */,
 145           NotifierId(NotifierId::SYSTEM_COMPONENT, system_component_id),
 146           RichNotificationData(),
 147           new HandleNotificationClickedDelegate(click_callback)));
 148   notification->SetSystemPriority();
 149   return notification.Pass();
 150 }
 151
 152 }  // namespace message_center