Add message to Ash message center for no 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 38 matching lines @@
 
 // Web Notification Bubble constants
 const int kWebNotificationBubbleMinHeight = 80;
 const int kWebNotificationBubbleMaxHeight = 480;
 // Delay laying out the Bubble until all notifications have been added and icons
 // have had a chance to load.
 const int kUpdateDelayMs = 50;
 // Limit the number of visible notifications.
 const int kMaxVisibleNotifications = 100;
 const int kAutocloseDelaySeconds = 5;
+const SkColor kMessageCountColor = SkColorSetARGB(0xff, 0xff, 0xff, 0xff);
+const SkColor kMessageCountDimmedColor = SkColorSetARGB(0x60, 0xff, 0xff, 0xff);
 
 // Individual notifications constants
 const int kWebNotificationWidth = 320;
 const int kWebNotificationButtonWidth = 32;
 const int kWebNotificationIconSize = 40;
 
 // Menu constants
 const int kTogglePermissionCommand = 0;
 const int kToggleExtensionCommand = 1;
 const int kShowSettingsCommand = 2;
@@ skipping 361 matching lines @@
       const views::GestureEvent& event) OVERRIDE {
     if (event.type() != ui::ET_GESTURE_TAP)
       return ui::GESTURE_STATUS_UNKNOWN;
     tray_->OnClicked(notification_.id);
     return ui::GESTURE_STATUS_CONSUMED;
   }
 
   // Overridden from ButtonListener.
   virtual void ButtonPressed(views::Button* sender,
                              const views::Event& event) OVERRIDE {
-    if (sender == close_button_)
+    if (sender == close_button_) {
       tray_->RemoveNotification(notification_.id);
+      tray_->HideMessageCenterBubbleIfEmpty();
+    }
   }
 
   // Overridden from MenuButtonListener.
   virtual void OnMenuButtonClicked(
       View* source, const gfx::Point& point) OVERRIDE {
     if (source != menu_button_)
       return;
     WebNotificationMenuModel menu_model(tray_, notification_);
     views::MenuModelAdapter menu_model_adapter(&menu_model);
     views::MenuRunner menu_runner(menu_model_adapter.CreateMenu());
@@ skipping 45 matching lines @@
     close_all_button_ = new TrayPopupTextButton(
         this, rb.GetLocalizedString(IDS_ASH_WEB_NOTFICATION_TRAY_CLEAR_ALL));
 
     layout->StartRow(0, 0);
     layout->AddView(close_all_button_);
   }
 
   virtual ~WebNotificationButtonView() {
   }
 
+  void SetCloseAllVisible(bool visible) {
+    close_all_button_->SetVisible(visible);
+  }
+
   // Overridden from ButtonListener.
   virtual void ButtonPressed(views::Button* sender,
                              const views::Event& event) OVERRIDE {
-    if (sender == close_all_button_)
+    if (sender == close_all_button_) {
       tray_->RemoveAllNotifications();
+      tray_->HideMessageCenterBubbleIfEmpty();
+    }
   }
 
  private:
   WebNotificationTray* tray_;
   TrayPopupTextButton* close_all_button_;
 
   DISALLOW_COPY_AND_ASSIGN(WebNotificationButtonView);
 };
 
 class WebContentsView : public views::View {
@@ skipping 16 matching lines @@
 
  protected:
   WebNotificationTray* tray_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebContentsView);
 };
 
 class MessageCenterContentsView : public WebContentsView {
  public:
+  class ScrollContentView : public views::View {
+   public:
+    ScrollContentView() {
+      views::BoxLayout* layout =
+          new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 1);
+      layout->set_spread_blank_space(true);
+      SetLayoutManager(layout);
+    }
+
+    virtual ~ScrollContentView() {};
+
+    virtual gfx::Size GetPreferredSize() OVERRIDE {
+      if (!preferred_size_.IsEmpty())
+        return preferred_size_;
+      return views::View::GetPreferredSize();
+    }
+
+    void set_preferred_size(const gfx::Size& size) { preferred_size_ = size; }
+
+   private:
+    gfx::Size preferred_size_;
+    DISALLOW_COPY_AND_ASSIGN(ScrollContentView);
+  };
+
   explicit MessageCenterContentsView(WebNotificationTray* tray)
       : WebContentsView(tray) {
     SetLayoutManager(
         new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 1));
     set_background(views::Background::CreateSolidBackground(kBackgroundColor));
 
-    scroll_content_ = new views::View;
-    scroll_content_->SetLayoutManager(
-        new views::BoxLayout(views::BoxLayout::kVertical, 0, 0, 1));
-
+    scroll_content_ = new ScrollContentView;
     scroller_ = new internal::FixedSizedScrollView;
     scroller_->SetContentsView(scroll_content_);
     AddChildView(scroller_);
 
     button_view_ = new internal::WebNotificationButtonView(tray);
     AddChildView(button_view_);
   }
 
   void Update(const WebNotificationList::Notifications& notifications) {
     scroll_content_->RemoveAllChildViews(true);
     int num_children = 0;
     for (WebNotificationList::Notifications::const_iterator iter =
              notifications.begin(); iter != notifications.end(); ++iter) {
       WebNotificationView* view = new WebNotificationView(tray_, *iter);
       scroll_content_->AddChildView(view);
       if (++num_children >= kMaxVisibleNotifications)
         break;
     }
+    if (num_children == 0) {
+      views::Label* label = new views::Label(l10n_util::GetStringUTF16(
+          IDS_ASH_WEB_NOTFICATION_TRAY_NO_MESSAGES));
+      label->SetFont(label->font().DeriveFont(2));
+      label->SetHorizontalAlignment(views::Label::ALIGN_CENTER);
+      scroll_content_->AddChildView(label);
+      button_view_->SetCloseAllVisible(false);
+    } else {
+      button_view_->SetCloseAllVisible(true);
+    }
     SizeScrollContent();
+    Layout();
     GetWidget()->GetRootView()->SchedulePaint();
   }
 
  private:
   void SizeScrollContent() {
     gfx::Size scroll_size = scroll_content_->GetPreferredSize();
-    int button_height = button_view_->GetPreferredSize().height();
-    int scroll_height = std::min(
-        std::max(scroll_size.height(),
-                 kWebNotificationBubbleMinHeight - button_height),
-        kWebNotificationBubbleMaxHeight - button_height);
+    const int button_height = button_view_->GetPreferredSize().height();
+    const int min_height = kWebNotificationBubbleMinHeight - button_height;
+    const int max_height = kWebNotificationBubbleMaxHeight - button_height;
+    int scroll_height = std::min(std::max(
+        scroll_size.height(), min_height), max_height);
     scroll_size.set_height(scroll_height);
+    if (scroll_height == min_height)
+      scroll_content_->set_preferred_size(scroll_size);
+    else
+      scroll_content_->set_preferred_size(gfx::Size());
     scroller_->SetFixedSize(scroll_size);
     scroller_->SizeToPreferredSize();
   }
 
   internal::FixedSizedScrollView* scroller_;
-  views::View* scroll_content_;
+  ScrollContentView* scroll_content_;
   internal::WebNotificationButtonView* button_view_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageCenterContentsView);
 };
 
 class WebNotificationContentsView : public WebContentsView {
  public:
   explicit WebNotificationContentsView(WebNotificationTray* tray)
       : WebContentsView(tray) {
     SetLayoutManager(
@@ skipping 119 matching lines @@
   virtual void OnWidgetClosing(views::Widget* widget) OVERRIDE {
     CHECK_EQ(bubble_widget_, widget);
     bubble_widget_ = NULL;
     tray_->HideBubble(this);  // Will destroy |this|.
   }
 
  private:
   void UpdateBubbleView() {
     const WebNotificationList::Notifications& notifications =
         tray_->notification_list()->notifications();
-    if (notifications.size() == 0) {
-      tray_->HideBubble(this);  // deletes |this|!
-      return;
-    }
     contents_view_->Update(notifications);
     bubble_view_->Show();
     bubble_view_->UpdateBubble();
   }
 
   void StartAutoCloseTimer() {
     if (bubble_type_ != BUBBLE_TYPE_NOTIFICATION)
       return;
     autoclose_.Start(FROM_HERE,
                      base::TimeDelta::FromSeconds(kAutocloseDelaySeconds),
@@ skipping 24 matching lines @@
     : internal::TrayBackgroundView(status_area_widget),
       notification_list_(new WebNotificationList()),
       count_label_(NULL),
       delegate_(NULL),
       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);
+  count_label_->SetEnabledColor(kMessageCountDimmedColor);
 
   tray_container()->set_size(gfx::Size(kTrayWidth, kTrayHeight));
   tray_container()->AddChildView(count_label_);
 
   UpdateTray();
 }
 
 WebNotificationTray::~WebNotificationTray() {
 }
 
@@ skipping 38 matching lines @@
     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();
+  HideMessageCenterBubble();
   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();
@@ skipping 16 matching lines @@
     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;
-  if (message_center_bubble() || GetNotificationCount() == 0) {
+  if (message_center_bubble()) {
     UpdateTray();
     return;
   }
   notification_list_->SetIsVisible(true);  // clears notification count
   UpdateTray();
   HideNotificationBubble();
   message_center_bubble_.reset(
       new Bubble(this, Bubble::BUBBLE_TYPE_MESAGE_CENTER));
   status_area_widget()->SetHideSystemNotifications(true);
 }
 
 void WebNotificationTray::HideMessageCenterBubble() {
+  if (!message_center_bubble())
+    return;
   message_center_bubble_.reset();
   show_message_center_on_unlock_ = false;
   notification_list_->SetIsVisible(false);
   status_area_widget()->SetHideSystemNotifications(false);
 }
 
+void WebNotificationTray::HideMessageCenterBubbleIfEmpty() {
+  if (GetNotificationCount() == 0)
+    HideMessageCenterBubble();
+}
+
 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();
   if (notification_bubble()) {
     notification_bubble()->ScheduleUpdate();
@@ skipping 54 matching lines @@
   return true;
 }
 
 int WebNotificationTray::GetNotificationCount() const {
   return notification_list()->notifications().size();
 }
 
 void WebNotificationTray::UpdateTray() {
   count_label_->SetText(UTF8ToUTF16(
       GetNotificationText(notification_list()->unread_count())));
+  // Dim the message count text only if the message center is empty.
+  count_label_->SetEnabledColor(
+      (notification_list()->notifications().size() == 0) ?
+      kMessageCountDimmedColor : kMessageCountColor);
+  SetVisible((status_area_widget()->login_status() != user::LOGGED_IN_NONE));
   Layout();
   SchedulePaint();
 }
 
 void WebNotificationTray::UpdateTrayAndBubble() {
   UpdateTray();
-  if (GetNotificationCount() == 0) {
-    HideMessageCenterBubble();
-    HideNotificationBubble();
-    return;
-  }
+
   if (message_center_bubble())
     message_center_bubble()->ScheduleUpdate();
-  if (notification_bubble())
-    notification_bubble()->ScheduleUpdate();
+
+  if (notification_bubble()) {
+    if (GetNotificationCount() == 0)
+      HideNotificationBubble();
+    else
+      notification_bubble()->ScheduleUpdate();
+  }
 }
 
 void WebNotificationTray::HideBubble(Bubble* bubble) {
   if (bubble == message_center_bubble()) {
     HideMessageCenterBubble();
   } else if (bubble == notification_bubble()) {
     HideNotificationBubble();
   }
 }
 
 }  // namespace ash