Revert of Show small notification icons in notification tray

ash/common/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/common/system/web_notification/web_notification_tray.h"
 
 #include "ash/common/ash_switches.h"
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/shelf_constants.h"
@@ skipping 44 matching lines @@
 }
 
 }  // namespace message_center
 
 #endif  // defined(OS_CHROMEOS)
 
 namespace ash {
 namespace {
 
 // Menu commands
-constexpr int kToggleQuietMode = 0;
-constexpr int kEnableQuietModeDay = 2;
-
-constexpr int kMaximumSmallIconCount = 3;
-
-constexpr gfx::Size kTrayItemInnerIconSize(16, 16);
-constexpr gfx::Size kTrayItemInnerBellIconSize(18, 18);
-constexpr gfx::Size kTrayItemOuterSize(26, 26);
-constexpr gfx::Insets kTrayItemInsets(3, 3);
-
-constexpr int kTrayItemAnimationDurationMS = 200;
-
-constexpr size_t kMaximumNotificationNumber = 99;
-
-// Flag to disable animation. Only for testing.
-bool disable_animations_for_test = false;
+const int kToggleQuietMode = 0;
+const int kEnableQuietModeDay = 2;
 }
 
 namespace {
 
 const SkColor kWebNotificationColorNoUnread =
     SkColorSetARGB(128, 255, 255, 255);
 const SkColor kWebNotificationColorWithUnread = SK_ColorWHITE;
 const int kNoUnreadIconSize = 18;
 }
 
@@ skipping 30 matching lines @@
   // Convenience accessors.
   views::TrayBubbleView* bubble_view() const { return bubble_->bubble_view(); }
 
  private:
   std::unique_ptr<message_center::MessageBubbleBase> bubble_;
   std::unique_ptr<TrayBubbleWrapper> bubble_wrapper_;
 
   DISALLOW_COPY_AND_ASSIGN(WebNotificationBubbleWrapper);
 };
 
-class WebNotificationItem : public views::View, public gfx::AnimationDelegate {
+class WebNotificationIcon : public views::View {
  public:
-  WebNotificationItem(gfx::AnimationContainer* container,
-                      WebNotificationTray* tray)
-      : tray_(tray) {
-    SetPaintToLayer(true);
-    layer()->SetFillsBoundsOpaquely(false);
-    views::View::SetVisible(false);
-    set_owned_by_client();
-
+  WebNotificationIcon() : is_bubble_visible_(false), unread_count_(0) {
     SetLayoutManager(new views::FillLayout);
 
-    animation_.reset(new gfx::SlideAnimation(this));
-    animation_->SetContainer(container);
-    animation_->SetSlideDuration(kTrayItemAnimationDurationMS);
-    animation_->SetTweenType(gfx::Tween::LINEAR);
+    gfx::ImageSkia image;
+    if (MaterialDesignController::IsShelfMaterial()) {
+      image = CreateVectorIcon(gfx::VectorIconId::SHELF_NOTIFICATIONS,
+                               kShelfIconColor);
+    } else {
+      image =
+          CreateVectorIcon(gfx::VectorIconId::NOTIFICATIONS, kNoUnreadIconSize,
+                           kWebNotificationColorNoUnread);
+    }
+
+    no_unread_icon_.SetImage(image);
+    no_unread_icon_.set_owned_by_client();
+
+    unread_label_.set_owned_by_client();
+    SetupLabelForTray(&unread_label_);
+
+    AddChildView(&no_unread_icon_);
   }
 
-  void SetVisible(bool set_visible) override {
-    if (!GetWidget() || disable_animations_for_test) {
-      views::View::SetVisible(set_visible);
+  void SetBubbleVisible(bool visible) {
+    if (visible == is_bubble_visible_)
       return;
-    }
 
-    if (!set_visible) {
-      animation_->Hide();
-      AnimationProgressed(animation_.get());
-    } else {
-      animation_->Show();
-      AnimationProgressed(animation_.get());
-      views::View::SetVisible(true);
-    }
+    is_bubble_visible_ = visible;
+    UpdateIconVisibility();
   }
 
-  void HideAndDelete() {
-    SetVisible(false);
-
-    if (!visible() && !animation_->is_animating()) {
-      if (parent())
-        parent()->RemoveChildView(this);
-      base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
-    } else {
-      delete_after_animation_ = true;
-    }
+  void SetUnreadCount(int unread_count) {
+    // base::FormatNumber doesn't convert to arabic numeric characters.
+    // TODO(mukai): use ICU to support conversion for such locales.
+    unread_count_ = unread_count;
+    UpdateIconVisibility();
   }
 
  protected:
   // Overridden from views::View:
   gfx::Size GetPreferredSize() const override {
-    if (!animation_.get() || !animation_->is_animating())
-      return kTrayItemOuterSize;
-
-    // Animate the width (or height) when this item shows (or hides) so that
-    // the icons on the left are shifted with the animation.
-    // Note that TrayItemView does the same thing.
-    gfx::Size size = kTrayItemOuterSize;
-    if (IsHorizontalLayout()) {
-      size.set_width(std::max(
-          1, gfx::ToRoundedInt(size.width() * animation_->GetCurrentValue())));
-    } else {
-      size.set_height(std::max(
-          1, gfx::ToRoundedInt(size.height() * animation_->GetCurrentValue())));
-    }
-    return size;
+    const int size = GetTrayConstant(TRAY_ITEM_HEIGHT_LEGACY);
+    return gfx::Size(size, size);
   }
 
   int GetHeightForWidth(int width) const override {
     return GetPreferredSize().height();
   }
 
-  bool IsHorizontalLayout() const {
-    return IsHorizontalAlignment(tray_->shelf_alignment());
-  }
+ private:
+  void UpdateIconVisibility() {
+    if (unread_count_ == 0) {
+      if (!Contains(&no_unread_icon_)) {
+        RemoveAllChildViews(false /* delete_children */);
+        AddChildView(&no_unread_icon_);
+      }
+    } else {
+      if (!Contains(&unread_label_)) {
+        RemoveAllChildViews(false /* delete_children */);
+        AddChildView(&unread_label_);
+      }
 
- private:
-  // gfx::AnimationDelegate:
-  void AnimationProgressed(const gfx::Animation* animation) override {
-    gfx::Transform transform;
-    if (IsHorizontalLayout()) {
-      transform.Translate(0, animation->CurrentValueBetween(
-                                 static_cast<double>(height()) / 2., 0.));
-    } else {
-      transform.Translate(
-          animation->CurrentValueBetween(static_cast<double>(width() / 2.), 0.),
-          0);
+      // TODO(mukai): move NINE_PLUS message to ui_strings, it doesn't need to
+      // be in ash_strings.
+      unread_label_.SetText(
+          (unread_count_ > 9) ? l10n_util::GetStringUTF16(
+                                    IDS_ASH_NOTIFICATION_UNREAD_COUNT_NINE_PLUS)
+                              : base::FormatNumber(unread_count_));
+      unread_label_.SetEnabledColor((unread_count_ > 0)
+                                        ? kWebNotificationColorWithUnread
+                                        : kWebNotificationColorNoUnread);
     }
-    transform.Scale(animation->GetCurrentValue(), animation->GetCurrentValue());
-    layer()->SetTransform(transform);
-    PreferredSizeChanged();
-  }
-  void AnimationEnded(const gfx::Animation* animation) override {
-    if (animation->GetCurrentValue() < 0.1)
-      views::View::SetVisible(false);
-
-    if (delete_after_animation_) {
-      if (parent())
-        parent()->RemoveChildView(this);
-      base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
-    }
-  }
-  void AnimationCanceled(const gfx::Animation* animation) override {
-    AnimationEnded(animation);
-  }
-
-  std::unique_ptr<gfx::SlideAnimation> animation_;
-  bool delete_after_animation_ = false;
-  WebNotificationTray* tray_;
-
-  DISALLOW_COPY_AND_ASSIGN(WebNotificationItem);
-};
-
-class WebNotificationImage : public WebNotificationItem {
- public:
-  WebNotificationImage(const gfx::ImageSkia& image,
-                       gfx::Size size,
-                       gfx::AnimationContainer* container,
-                       WebNotificationTray* tray)
-      : WebNotificationItem(container, tray) {
-    view_ = new views::ImageView();
-    view_->SetImage(image);
-    view_->SetImageSize(size);
-    AddChildView(view_);
-  }
-
- private:
-  views::ImageView* view_;
-
-  DISALLOW_COPY_AND_ASSIGN(WebNotificationImage);
-};
-
-class WebNotificationLabel : public WebNotificationItem {
- public:
-  WebNotificationLabel(gfx::AnimationContainer* container,
-                       WebNotificationTray* tray)
-      : WebNotificationItem(container, tray) {
-    view_ = new views::Label();
-    SetupLabelForTray(view_);
-  }
-
-  void SetNotificationCount(bool small_icons_exist, size_t notification_count) {
-    notification_count = std::min(notification_count,
-                                  kMaximumNotificationNumber);  // cap with 99
-
-    // TODO(yoshiki): Use a string for "99" and "+99".
-
-    base::string16 str = base::FormatNumber(notification_count);
-    if (small_icons_exist) {
-      if (!base::i18n::IsRTL())
-        str = base::ASCIIToUTF16("+") + str;
-      else
-        str = str + base::ASCIIToUTF16("+");
-    }
-
-    view_->SetText(str);
-    view_->SetEnabledColor(kWebNotificationColorWithUnread);
-    AddChildView(view_);
     SchedulePaint();
   }
 
- private:
-  views::Label* view_;
+  bool is_bubble_visible_;
+  int unread_count_;
 
-  DISALLOW_COPY_AND_ASSIGN(WebNotificationLabel);
+  views::ImageView no_unread_icon_;
+  views::Label unread_label_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebNotificationIcon);
 };
 
 WebNotificationTray::WebNotificationTray(WmShelf* shelf,
                                          WmWindow* status_area_window,
                                          SystemTray* system_tray)
     : TrayBackgroundView(shelf),
       status_area_window_(status_area_window),
       system_tray_(system_tray),
+      icon_(new WebNotificationIcon),
       show_message_center_on_unlock_(false),
       should_update_tray_content_(false),
       should_block_shelf_auto_hide_(false) {
   DCHECK(shelf);
   DCHECK(status_area_window_);
   DCHECK(system_tray_);
 
-  gfx::ImageSkia bell_image;
-  if (MaterialDesignController::IsShelfMaterial()) {
-    bell_image = CreateVectorIcon(gfx::VectorIconId::SHELF_NOTIFICATIONS,
-                                  kShelfIconColor);
-  } else {
-    bell_image =
-        CreateVectorIcon(gfx::VectorIconId::NOTIFICATIONS, kNoUnreadIconSize,
-                         kWebNotificationColorNoUnread);
-  }
-  bell_icon_.reset(new WebNotificationImage(bell_image,
-                                            kTrayItemInnerBellIconSize,
-                                            animation_container_.get(), this));
-  tray_container()->AddChildView(bell_icon_.get());
-
-  counter_.reset(new WebNotificationLabel(animation_container_.get(), this));
-  tray_container()->AddChildView(counter_.get());
-
+  tray_container()->AddChildView(icon_);
   SetContentsBackground();
   tray_container()->SetBorder(views::Border::NullBorder());
   message_center_tray_.reset(new message_center::MessageCenterTray(
       this, message_center::MessageCenter::Get()));
   popup_alignment_delegate_.reset(new AshPopupAlignmentDelegate(shelf));
   popup_collection_.reset(new message_center::MessagePopupCollection(
       message_center(), message_center_tray_.get(),
       popup_alignment_delegate_.get()));
   const display::Display& display =
       status_area_window_->GetDisplayNearestWindow();
   popup_alignment_delegate_->StartObserving(display::Screen::GetScreen(),
                                             display);
   OnMessageCenterTrayChanged();
-
-  tray_container()->SetMargin(kTrayItemInsets);
 }
 
 WebNotificationTray::~WebNotificationTray() {
   // Release any child views that might have back pointers before ~View().
   message_center_bubble_.reset();
   popup_alignment_delegate_.reset();
   popup_collection_.reset();
 }
 
-// static
-void WebNotificationTray::DisableAnimationsForTest(bool disable) {
-  disable_animations_for_test = disable;
-}
-
 // Public methods.
 
 bool WebNotificationTray::ShowMessageCenterInternal(bool show_settings) {
   if (!ShouldShowMessageCenter())
     return false;
 
   should_block_shelf_auto_hide_ = true;
   message_center::MessageCenterBubble* message_center_bubble =
       new message_center::MessageCenterBubble(message_center(),
                                               message_center_tray_.get(), true);
 
   int max_height;
-  if (IsHorizontalAlignment(shelf_alignment())) {
+  if (IsHorizontalAlignment(shelf()->GetAlignment())) {
     max_height = shelf()->GetIdealBounds().y();
   } else {
     // Assume the status area and bubble bottoms are aligned when vertical.
     gfx::Rect bounds_in_root =
         status_area_window_->GetRootWindow()->ConvertRectFromScreen(
             status_area_window_->GetBoundsInScreen());
     max_height = bounds_in_root.bottom();
   }
   message_center_bubble->SetMaxHeight(
       std::max(0, max_height - GetTrayConstant(TRAY_SPACING)));
   if (show_settings)
     message_center_bubble->SetSettingsVisible();
   message_center_bubble_.reset(
       new WebNotificationBubbleWrapper(this, message_center_bubble));
 
   system_tray_->SetHideNotifications(true);
   shelf()->UpdateAutoHideState();
+  icon_->SetBubbleVisible(true);
   SetDrawBackgroundAsActive(true);
   return true;
 }
 
 bool WebNotificationTray::ShowMessageCenter() {
   return ShowMessageCenterInternal(false /* show_settings */);
 }
 
 void WebNotificationTray::HideMessageCenter() {
   if (!message_center_bubble())
     return;
   SetDrawBackgroundAsActive(false);
   message_center_bubble_.reset();
   should_block_shelf_auto_hide_ = false;
   show_message_center_on_unlock_ = false;
   system_tray_->SetHideNotifications(false);
   shelf()->UpdateAutoHideState();
+  icon_->SetBubbleVisible(false);
 }
 
 void WebNotificationTray::SetTrayBubbleHeight(int height) {
   popup_alignment_delegate_->SetTrayBubbleHeight(height);
 }
 
 int WebNotificationTray::tray_bubble_height_for_test() const {
   return popup_alignment_delegate_->tray_bubble_height_for_test();
 }
 
@@ skipping 165 matching lines @@
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&WebNotificationTray::UpdateTrayContent, AsWeakPtr()));
 }
 
 void WebNotificationTray::UpdateTrayContent() {
   if (!should_update_tray_content_)
     return;
   should_update_tray_content_ = false;
 
-  std::unordered_set<std::string> notification_ids;
-  for (auto pair : visible_small_icons_)
-    notification_ids.insert(pair.first);
-
-  // Add small icons (up to kMaximumSmallIconCount = 3).
   message_center::MessageCenter* message_center =
       message_center_tray_->message_center();
-  size_t visible_small_icon_count = 0;
-  for (const auto* notification : message_center->GetVisibleNotifications()) {
-    gfx::Image image = notification->small_image();
-    if (image.IsEmpty())
-      continue;
-
-    if (visible_small_icon_count >= kMaximumSmallIconCount)
-      break;
-    visible_small_icon_count++;
-
-    notification_ids.erase(notification->id());
-    if (visible_small_icons_.count(notification->id()) != 0)
-      continue;
-
-    auto* item =
-        new WebNotificationImage(image.AsImageSkia(), kTrayItemInnerIconSize,
-                                 animation_container_.get(), this);
-    visible_small_icons_.insert(std::make_pair(notification->id(), item));
-
-    tray_container()->AddChildViewAt(item, 0);
-    item->SetVisible(true);
-  }
-
-  // Remove unnecessary icons.
-  for (const std::string& id : notification_ids) {
-    WebNotificationImage* item = visible_small_icons_[id];
-    visible_small_icons_.erase(id);
-    item->HideAndDelete();
-  }
-
-  // Show or hide the bell icon.
-  size_t visible_notification_count = message_center->NotificationCount();
-  bell_icon_->SetVisible(visible_notification_count == 0);
-
-  // Show or hide the counter.
-  size_t hidden_icon_count =
-      visible_notification_count - visible_small_icon_count;
-  if (hidden_icon_count != 0) {
-    counter_->SetVisible(true);
-    counter_->SetNotificationCount(
-        (visible_small_icon_count != 0),  // small_icons_exist
-        hidden_icon_count);
-  } else {
-    counter_->SetVisible(false);
-  }
+  icon_->SetUnreadCount(message_center->UnreadNotificationCount());
 
   SetVisible(IsLoggedIn());
-  PreferredSizeChanged();
   Layout();
   SchedulePaint();
   if (IsLoggedIn())
     system_tray_->SetNextFocusableView(this);
 }
 
 void WebNotificationTray::ClickedOutsideBubble() {
   // Only hide the message center
   if (!message_center_bubble())
     return;
@@ skipping 20 matching lines @@
 
 message_center::MessageCenterBubble*
 WebNotificationTray::GetMessageCenterBubbleForTest() {
   if (!message_center_bubble())
     return NULL;
   return static_cast<message_center::MessageCenterBubble*>(
       message_center_bubble()->bubble());
 }
 
 }  // namespace ash