Send notification to users upon receiving sms messages

ash/common/system/tray/system_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/tray/system_tray.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
 #include "ash/common/key_event_watcher.h"
 #include "ash/common/login_status.h"
 #include "ash/common/material_design/material_design_controller.h"
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shelf/wm_shelf_util.h"
 #include "ash/common/system/chromeos/audio/tray_audio.h"
 #include "ash/common/system/chromeos/bluetooth/tray_bluetooth.h"
 #include "ash/common/system/chromeos/brightness/tray_brightness.h"
 #include "ash/common/system/chromeos/cast/tray_cast.h"
 #include "ash/common/system/chromeos/enterprise/tray_enterprise.h"
 #include "ash/common/system/chromeos/media_security/multi_profile_media_tray_item.h"
 #include "ash/common/system/chromeos/network/tray_network.h"
-#include "ash/common/system/chromeos/network/tray_sms.h"
 #include "ash/common/system/chromeos/network/tray_vpn.h"
 #include "ash/common/system/chromeos/power/power_status.h"
 #include "ash/common/system/chromeos/power/tray_power.h"
 #include "ash/common/system/chromeos/screen_security/screen_capture_tray_item.h"
 #include "ash/common/system/chromeos/screen_security/screen_share_tray_item.h"
 #include "ash/common/system/chromeos/session/tray_session_length_limit.h"
 #include "ash/common/system/chromeos/settings/tray_settings.h"
 #include "ash/common/system/chromeos/supervised/tray_supervised_user.h"
 #include "ash/common/system/chromeos/tray_caps_lock.h"
 #include "ash/common/system/chromeos/tray_tracing.h"
@@ skipping 165 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ActivationObserver);
 };
 
 // SystemTray
 
 SystemTray::SystemTray(WmShelf* wm_shelf)
     : TrayBackgroundView(wm_shelf),
       web_notification_tray_(nullptr),
       detailed_item_(nullptr),
       default_bubble_height_(0),
-      hide_notifications_(false),
       full_system_tray_menu_(false),
       tray_accessibility_(nullptr),
       tray_audio_(nullptr),
       tray_cast_(nullptr),
       tray_date_(nullptr),
       tray_network_(nullptr),
       tray_tiles_(nullptr),
       tray_system_info_(nullptr),
       tray_update_(nullptr),
       screen_capture_tray_item_(nullptr),
       screen_share_tray_item_(nullptr) {
   if (MaterialDesignController::IsShelfMaterial()) {
     SetInkDropMode(InkDropMode::ON);
     SetContentsBackground(false);
 
     // Since |system_tray| locates on the right most position, no separator is
     // required on its right side.
     set_separator_visibility(false);
   } else {
     SetContentsBackground(true);
   }
 }
 
 SystemTray::~SystemTray() {
   // Destroy any child views that might have back pointers before ~View().
   activation_observer_.reset();
   key_event_watcher_.reset();
   system_bubble_.reset();
-  notification_bubble_.reset();
   for (const auto& item : items_)
     item->DestroyTrayView();
 }
 
 void SystemTray::InitializeTrayItems(
     SystemTrayDelegate* delegate,
     WebNotificationTray* web_notification_tray) {
   DCHECK(web_notification_tray);
   web_notification_tray_ = web_notification_tray;
   TrayBackgroundView::Initialize();
@@ skipping 35 matching lines @@
   AddTrayItem(base::MakeUnique<TrayEnterprise>(this));
   AddTrayItem(base::MakeUnique<TraySupervisedUser>(this));
   AddTrayItem(base::MakeUnique<TrayIME>(this));
   AddTrayItem(base::WrapUnique(tray_accessibility_));
   AddTrayItem(base::MakeUnique<TrayTracing>(this));
   AddTrayItem(
       base::MakeUnique<TrayPower>(this, message_center::MessageCenter::Get()));
   tray_network_ = new TrayNetwork(this);
   AddTrayItem(base::WrapUnique(tray_network_));
   AddTrayItem(base::MakeUnique<TrayVPN>(this));
-  AddTrayItem(base::MakeUnique<TraySms>(this));
   AddTrayItem(base::MakeUnique<TrayBluetooth>(this));
   tray_cast_ = new TrayCast(this);
   AddTrayItem(base::WrapUnique(tray_cast_));
   screen_capture_tray_item_ = new ScreenCaptureTrayItem(this);
   AddTrayItem(base::WrapUnique(screen_capture_tray_item_));
   screen_share_tray_item_ = new ScreenShareTrayItem(this);
   AddTrayItem(base::WrapUnique(screen_share_tray_item_));
   AddTrayItem(base::MakeUnique<MultiProfileMediaTrayItem>(this));
   tray_audio_ = new TrayAudio(this);
   AddTrayItem(base::WrapUnique(tray_audio_));
@@ skipping 83 matching lines @@
     if (GetSystemBubble()) {
       GetSystemBubble()
           ->bubble_view()
           ->GetWidget()
           ->SetVisibilityAnimationTransition(
               views::Widget::VisibilityTransition::ANIMATE_NONE);
     }
   }
 
   DestroySystemBubble();
-  UpdateNotificationBubble();
-}
-
-void SystemTray::ShowNotificationView(SystemTrayItem* item) {
-  if (std::find(notification_items_.begin(), notification_items_.end(), item) !=
-      notification_items_.end())
-    return;
-  notification_items_.push_back(item);
-  UpdateNotificationBubble();
-}
-
-void SystemTray::HideNotificationView(SystemTrayItem* item) {
-  auto found_iter =
-      std::find(notification_items_.begin(), notification_items_.end(), item);
-  if (found_iter == notification_items_.end())
-    return;
-  notification_items_.erase(found_iter);
-  // Only update the notification bubble if visible (i.e. don't create one).
-  if (notification_bubble_)
-    UpdateNotificationBubble();
 }
 
 void SystemTray::UpdateAfterLoginStatusChange(LoginStatus login_status) {
   DestroySystemBubble();
-  UpdateNotificationBubble();
 
   for (const auto& item : items_)
     item->UpdateAfterLoginStatusChange(login_status);
 
   // Items default to SHELF_ALIGNMENT_BOTTOM. Update them if the initial
   // position of the shelf differs.
   if (!IsHorizontalAlignment(shelf_alignment()))
     UpdateAfterShelfAlignmentChange(shelf_alignment());
 
   SetVisible(true);
   PreferredSizeChanged();
 }
 
 void SystemTray::UpdateAfterShelfAlignmentChange(ShelfAlignment alignment) {
   for (const auto& item : items_)
     item->UpdateAfterShelfAlignmentChange(alignment);
 }
 
-void SystemTray::SetHideNotifications(bool hide_notifications) {
-  if (notification_bubble_)
-    notification_bubble_->bubble()->SetVisible(!hide_notifications);
-  hide_notifications_ = hide_notifications;
-}
-
 bool SystemTray::ShouldShowShelf() const {
   return system_bubble_.get() && system_bubble_->bubble()->ShouldShowShelf();
 }
 
 bool SystemTray::HasSystemBubble() const {
   return system_bubble_.get() != NULL;
 }
 
-bool SystemTray::HasNotificationBubble() const {
-  return notification_bubble_.get() != NULL;
-}
-
 SystemTrayBubble* SystemTray::GetSystemBubble() {
   if (!system_bubble_)
     return NULL;
   return system_bubble_->bubble();
 }
 
-bool SystemTray::IsAnyBubbleVisible() const {
-  return ((system_bubble_.get() && system_bubble_->bubble()->IsVisible()) ||
-          (notification_bubble_.get() &&
-           notification_bubble_->bubble()->IsVisible()));
-}
-
-bool SystemTray::IsMouseInNotificationBubble() const {
-  if (!notification_bubble_)
-    return false;
-  return notification_bubble_->bubble_view()->GetBoundsInScreen().Contains(
-      display::Screen::GetScreen()->GetCursorScreenPoint());
+bool SystemTray::IsSystemBubbleVisible() const {
+  return HasSystemBubble() && system_bubble_->bubble()->IsVisible();
 }
 
 bool SystemTray::CloseSystemBubble() const {
   if (!system_bubble_)
     return false;
   CHECK(!activating_);
   system_bubble_->bubble()->Close();
   return true;
 }
 
 views::View* SystemTray::GetHelpButtonView() const {
   if (MaterialDesignController::IsSystemTrayMenuMaterial())
     return tray_tiles_->GetHelpButtonView();
   return tray_date_->GetHelpButtonView();
 }
 
 TrayAudio* SystemTray::GetTrayAudio() const {
   return tray_audio_;
 }
 
 // Private methods.
 
 bool SystemTray::HasSystemBubbleType(SystemTrayBubble::BubbleType type) {
-  DCHECK(type != SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION);
   return system_bubble_.get() && system_bubble_->bubble_type() == type;
 }
 
 void SystemTray::DestroySystemBubble() {
   CloseSystemBubbleAndDeactivateSystemTray();
   detailed_item_ = NULL;
   UpdateWebNotifications();
 }
 
-void SystemTray::DestroyNotificationBubble() {
-  if (notification_bubble_) {
-    notification_bubble_.reset();
-    UpdateWebNotifications();
-  }
-}
-
 base::string16 SystemTray::GetAccessibleNameForTray() {
   base::string16 time = GetAccessibleTimeString(base::Time::Now());
   base::string16 battery = PowerStatus::Get()->GetAccessibleNameString(false);
   return l10n_util::GetStringFUTF16(IDS_ASH_STATUS_TRAY_ACCESSIBLE_DESCRIPTION,
                                     time, battery);
 }
 
 void SystemTray::ShowItems(const std::vector<SystemTrayItem*>& items,
                            bool detailed,
                            bool can_activate,
                            BubbleCreationType creation_type,
                            bool persistent) {
   // No system tray bubbles in kiosk mode.
   SystemTrayDelegate* system_tray_delegate =
       WmShell::Get()->system_tray_delegate();
   if (system_tray_delegate->GetUserLoginStatus() == LoginStatus::KIOSK_APP ||
       system_tray_delegate->GetUserLoginStatus() ==
           LoginStatus::ARC_KIOSK_APP) {
     return;
   }
 
   // Destroy any existing bubble and create a new one.
   SystemTrayBubble::BubbleType bubble_type =
       detailed ? SystemTrayBubble::BUBBLE_TYPE_DETAILED
                : SystemTrayBubble::BUBBLE_TYPE_DEFAULT;
 
-  // Destroy the notification bubble here so that it doesn't get rebuilt
-  // while we add items to the main bubble_ (e.g. in HideNotificationView).
-  notification_bubble_.reset();
   if (system_bubble_.get() && creation_type == BUBBLE_USE_EXISTING) {
     system_bubble_->bubble()->UpdateView(items, bubble_type);
     // If ChromeVox is enabled, focus the default item if no item is focused.
     if (WmShell::Get()->accessibility_delegate()->IsSpokenFeedbackEnabled())
       system_bubble_->bubble()->FocusDefaultIfNeeded();
   } else {
     // Cleanup the existing bubble before showing a new one. Otherwise, it's
     // possible to confuse the new system bubble with the old one during
     // destruction, leading to subtle errors/crashes such as crbug.com/545166.
     DestroySystemBubble();
@@ skipping 47 matching lines @@
 
   key_event_watcher_.reset();
   if (can_activate)
     CreateKeyEventWatcher();
 
   if (detailed && items.size() > 0)
     detailed_item_ = items[0];
   else
     detailed_item_ = NULL;
 
-  UpdateNotificationBubble();  // State changed, re-create notifications.
-  if (!notification_bubble_)
-    UpdateWebNotifications();
+  UpdateWebNotifications();
   shelf()->UpdateAutoHideState();
 
   // When we show the system menu in our alternate shelf layout, we need to
   // tint the background.
   if (full_system_tray_menu_)
     SetIsActive(true);
 }
 
-// TODO(estade): there's only one thing that triggers a notification bubble,
-// and that's TraySms. We could delete a lot of code in SystemTray if that
-// used the message center notifications instead. See crbug.com/630641
-void SystemTray::UpdateNotificationBubble() {
-  // Only show the notification bubble if we have notifications.
-  if (notification_items_.empty()) {
-    DestroyNotificationBubble();
-    return;
-  }
-  // Destroy the existing bubble before constructing a new one.
-  notification_bubble_.reset();
-  SystemTrayBubble* notification_bubble;
-  notification_bubble = new SystemTrayBubble(
-      this, notification_items_, SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION);
-  // Tray items might want to show notifications while we are creating and
-  // initializing the |system_bubble_| - but it might not be fully initialized
-  // when coming here - this would produce a crashed like crbug.com/247416.
-  // As such we check the existence of the widget here.
-  TrayBubbleView::InitParams init_params(
-      GetAnchorAlignment(), kTrayPopupMinWidth, kTrayPopupMaxWidth);
-  views::View* anchor = GetBubbleAnchor();
-  gfx::Insets anchor_insets = GetBubbleAnchorInsets();
-  // If there's already a system menu bubble, stack this one on top.
-  if (system_bubble_.get() && system_bubble_->bubble_view() &&
-      system_bubble_->bubble_view()->GetWidget()) {
-    anchor = system_bubble_->bubble_view();
-    anchor_insets.Set(-message_center::kMarginBetweenItems, 0, 0, 0);
-    init_params.anchor_alignment = TrayBubbleView::ANCHOR_ALIGNMENT_BOTTOM;
-  }
-  init_params.bg_color = kBackgroundColor;
-  notification_bubble_.reset(new SystemBubbleWrapper(notification_bubble));
-  notification_bubble_->InitView(this, anchor, anchor_insets, &init_params,
-                                 false);
-
-  if (notification_bubble->bubble_view()->child_count() == 0) {
-    // It is possible that none of the items generated actual notifications.
-    DestroyNotificationBubble();
-    return;
-  }
-  if (hide_notifications_)
-    notification_bubble->SetVisible(false);
-  else
-    UpdateWebNotifications();
-}
-
 void SystemTray::UpdateWebNotifications() {
   TrayBubbleView* bubble_view = NULL;
-  if (notification_bubble_)
-    bubble_view = notification_bubble_->bubble_view();
-  else if (system_bubble_)
+  if (system_bubble_)
     bubble_view = system_bubble_->bubble_view();
 
   int height = 0;
   if (bubble_view) {
     gfx::Rect work_area =
         display::Screen::GetScreen()
             ->GetDisplayNearestWindow(bubble_view->GetWidget()->GetNativeView())
             .work_area();
     height =
         std::max(0, work_area.bottom() - bubble_view->GetBoundsInScreen().y());
@@ skipping 11 matching lines @@
 }
 
 void SystemTray::SetShelfAlignment(ShelfAlignment alignment) {
   if (alignment == shelf_alignment())
     return;
   TrayBackgroundView::SetShelfAlignment(alignment);
   UpdateAfterShelfAlignmentChange(alignment);
   // Destroy any existing bubble so that it is rebuilt correctly.
   CloseSystemBubbleAndDeactivateSystemTray();
   // Rebuild any notification bubble.
-  if (notification_bubble_) {
-    notification_bubble_.reset();
-    UpdateNotificationBubble();
-    // UpdateWebNotifications() should be called in UpdateNotificationBubble().
-  } else if (!hide_notifications_) {
-    UpdateWebNotifications();
-  }
+  UpdateWebNotifications();
 }
 
 void SystemTray::AnchorUpdated() {
-  if (notification_bubble_) {
-    notification_bubble_->bubble_view()->UpdateBubble();
-    // Ensure that the notification buble is above the shelf/status area.
-    notification_bubble_->bubble_view()->GetWidget()->StackAtTop();
-    UpdateBubbleViewArrow(notification_bubble_->bubble_view());
-  }
   if (system_bubble_) {
     system_bubble_->bubble_view()->UpdateBubble();
     UpdateBubbleViewArrow(system_bubble_->bubble_view());
   }
 }
 
 void SystemTray::BubbleResized(const TrayBubbleView* bubble_view) {
   UpdateWebNotifications();
 }
 
 void SystemTray::HideBubbleWithView(const TrayBubbleView* bubble_view) {
   if (system_bubble_.get() && bubble_view == system_bubble_->bubble_view()) {
     DestroySystemBubble();
-    UpdateNotificationBubble();  // State changed, re-create notifications.
     shelf()->UpdateAutoHideState();
-  } else if (notification_bubble_.get() &&
-             bubble_view == notification_bubble_->bubble_view()) {
-    DestroyNotificationBubble();
   }
 }
 
 void SystemTray::ClickedOutsideBubble() {
   if (!system_bubble_ || system_bubble_->is_persistent())
     return;
   HideBubbleWithView(system_bubble_->bubble_view());
 }
 
 void SystemTray::BubbleViewDestroyed() {
@@ skipping 148 matching lines @@
           .work_area()
           .height();
   if (work_area_height > 0) {
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Ash.SystemMenu.PercentageOfWorkAreaHeightCoveredByMenu",
         100 * bubble_view->height() / work_area_height, 1, 300, 100);
   }
 }
 
 }  // namespace ash