Home | History | Annotate | Download | only in tray 
      1 // Copyright (c) 2012 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 "ash/system/tray/system_tray.h"
      6 
      7 #include "ash/ash_switches.h"
      8 #include "ash/metrics/user_metrics_recorder.h"
      9 #include "ash/shelf/shelf_layout_manager.h"
     10 #include "ash/shell.h"
     11 #include "ash/shell_window_ids.h"
     12 #include "ash/system/audio/tray_audio.h"
     13 #include "ash/system/bluetooth/tray_bluetooth.h"
     14 #include "ash/system/date/tray_date.h"
     15 #include "ash/system/ime/tray_ime.h"
     16 #include "ash/system/status_area_widget.h"
     17 #include "ash/system/tray/system_tray_delegate.h"
     18 #include "ash/system/tray/system_tray_item.h"
     19 #include "ash/system/tray/tray_bubble_wrapper.h"
     20 #include "ash/system/tray/tray_constants.h"
     21 #include "ash/system/tray_accessibility.h"
     22 #include "ash/system/tray_update.h"
     23 #include "ash/system/user/login_status.h"
     24 #include "ash/system/user/tray_user.h"
     25 #include "ash/system/user/tray_user_separator.h"
     26 #include "ash/system/web_notification/web_notification_tray.h"
     27 #include "base/logging.h"
     28 #include "base/strings/utf_string_conversions.h"
     29 #include "base/timer/timer.h"
     30 #include "grit/ash_strings.h"
     31 #include "ui/aura/window_event_dispatcher.h"
     32 #include "ui/base/l10n/l10n_util.h"
     33 #include "ui/compositor/layer.h"
     34 #include "ui/events/event_constants.h"
     35 #include "ui/gfx/canvas.h"
     36 #include "ui/gfx/screen.h"
     37 #include "ui/gfx/skia_util.h"
     38 #include "ui/views/border.h"
     39 #include "ui/views/controls/label.h"
     40 #include "ui/views/layout/box_layout.h"
     41 #include "ui/views/layout/fill_layout.h"
     42 #include "ui/views/view.h"
     43 
     44 #if defined(OS_CHROMEOS)
     45 #include "ash/system/chromeos/audio/tray_audio_chromeos.h"
     46 #include "ash/system/chromeos/brightness/tray_brightness.h"
     47 #include "ash/system/chromeos/enterprise/tray_enterprise.h"
     48 #include "ash/system/chromeos/network/tray_network.h"
     49 #include "ash/system/chromeos/network/tray_sms.h"
     50 #include "ash/system/chromeos/network/tray_vpn.h"
     51 #include "ash/system/chromeos/power/power_status.h"
     52 #include "ash/system/chromeos/power/tray_power.h"
     53 #include "ash/system/chromeos/rotation/tray_rotation_lock.h"
     54 #include "ash/system/chromeos/screen_security/screen_capture_tray_item.h"
     55 #include "ash/system/chromeos/screen_security/screen_share_tray_item.h"
     56 #include "ash/system/chromeos/session/tray_session_length_limit.h"
     57 #include "ash/system/chromeos/settings/tray_settings.h"
     58 #include "ash/system/chromeos/supervised/tray_supervised_user.h"
     59 #include "ash/system/chromeos/tray_caps_lock.h"
     60 #include "ash/system/chromeos/tray_display.h"
     61 #include "ash/system/chromeos/tray_tracing.h"
     62 #include "ash/system/tray/media_security/multi_profile_media_tray_item.h"
     63 #include "ui/message_center/message_center.h"
     64 #elif defined(OS_WIN)
     65 #include "ash/system/win/audio/tray_audio_win.h"
     66 #include "media/audio/win/core_audio_util_win.h"
     67 #endif
     68 
     69 using views::TrayBubbleView;
     70 
     71 namespace ash {
     72 
     73 // The minimum width of the system tray menu width.
     74 const int kMinimumSystemTrayMenuWidth = 300;
     75 
     76 // Class to initialize and manage the SystemTrayBubble and TrayBubbleWrapper
     77 // instances for a bubble.
     78 
     79 class SystemBubbleWrapper {
     80  public:
     81   // Takes ownership of |bubble|.
     82   explicit SystemBubbleWrapper(SystemTrayBubble* bubble)
     83       : bubble_(bubble), is_persistent_(false) {}
     84 
     85   // Initializes the bubble view and creates |bubble_wrapper_|.
     86   void InitView(TrayBackgroundView* tray,
     87                 views::View* anchor,
     88                 TrayBubbleView::InitParams* init_params,
     89                 bool is_persistent) {
     90     DCHECK(anchor);
     91     user::LoginStatus login_status =
     92         Shell::GetInstance()->system_tray_delegate()->GetUserLoginStatus();
     93     bubble_->InitView(anchor, login_status, init_params);
     94     bubble_wrapper_.reset(new TrayBubbleWrapper(tray, bubble_->bubble_view()));
     95     // The system bubble should not have an arrow.
     96     bubble_->bubble_view()->SetArrowPaintType(
     97         views::BubbleBorder::PAINT_NONE);
     98     is_persistent_ = is_persistent;
     99 
    100     // If ChromeVox is enabled, focus the default item if no item is focused.
    101     if (Shell::GetInstance()->accessibility_delegate()->
    102         IsSpokenFeedbackEnabled()) {
    103       bubble_->FocusDefaultIfNeeded();
    104     }
    105   }
    106 
    107   // Convenience accessors:
    108   SystemTrayBubble* bubble() const { return bubble_.get(); }
    109   SystemTrayBubble::BubbleType bubble_type() const {
    110     return bubble_->bubble_type();
    111   }
    112   TrayBubbleView* bubble_view() const { return bubble_->bubble_view(); }
    113   bool is_persistent() const { return is_persistent_; }
    114 
    115  private:
    116   scoped_ptr<SystemTrayBubble> bubble_;
    117   scoped_ptr<TrayBubbleWrapper> bubble_wrapper_;
    118   bool is_persistent_;
    119 
    120   DISALLOW_COPY_AND_ASSIGN(SystemBubbleWrapper);
    121 };
    122 
    123 
    124 // SystemTray
    125 
    126 SystemTray::SystemTray(StatusAreaWidget* status_area_widget)
    127     : TrayBackgroundView(status_area_widget),
    128       items_(),
    129       default_bubble_height_(0),
    130       hide_notifications_(false),
    131       full_system_tray_menu_(false),
    132       tray_accessibility_(NULL),
    133       tray_date_(NULL) {
    134   SetContentsBackground();
    135 }
    136 
    137 SystemTray::~SystemTray() {
    138   // Destroy any child views that might have back pointers before ~View().
    139   system_bubble_.reset();
    140   notification_bubble_.reset();
    141   for (std::vector<SystemTrayItem*>::iterator it = items_.begin();
    142        it != items_.end();
    143        ++it) {
    144     (*it)->DestroyTrayView();
    145   }
    146 }
    147 
    148 void SystemTray::InitializeTrayItems(SystemTrayDelegate* delegate) {
    149   TrayBackgroundView::Initialize();
    150   CreateItems(delegate);
    151 }
    152 
    153 void SystemTray::CreateItems(SystemTrayDelegate* delegate) {
    154 #if !defined(OS_WIN)
    155   // Create user items for each possible user.
    156   ash::Shell* shell = ash::Shell::GetInstance();
    157   int maximum_user_profiles =
    158           shell->session_state_delegate()->GetMaximumNumberOfLoggedInUsers();
    159   for (int i = 0; i < maximum_user_profiles; i++)
    160     AddTrayItem(new TrayUser(this, i));
    161 
    162   if (maximum_user_profiles > 1) {
    163     // Add a special double line separator between users and the rest of the
    164     // menu if more then one user is logged in.
    165     AddTrayItem(new TrayUserSeparator(this));
    166   }
    167 #endif
    168 
    169   tray_accessibility_ = new TrayAccessibility(this);
    170   tray_date_ = new TrayDate(this);
    171 
    172 #if defined(OS_CHROMEOS)
    173   AddTrayItem(new TraySessionLengthLimit(this));
    174   AddTrayItem(new TrayEnterprise(this));
    175   AddTrayItem(new TraySupervisedUser(this));
    176   AddTrayItem(new TrayIME(this));
    177   AddTrayItem(tray_accessibility_);
    178   AddTrayItem(new TrayTracing(this));
    179   AddTrayItem(new TrayPower(this, message_center::MessageCenter::Get()));
    180   AddTrayItem(new TrayNetwork(this));
    181   AddTrayItem(new TrayVPN(this));
    182   AddTrayItem(new TraySms(this));
    183   AddTrayItem(new TrayBluetooth(this));
    184   AddTrayItem(new TrayDisplay(this));
    185   screen_capture_tray_item_ = new ScreenCaptureTrayItem(this);
    186   AddTrayItem(screen_capture_tray_item_);
    187   screen_share_tray_item_ = new ScreenShareTrayItem(this);
    188   AddTrayItem(screen_share_tray_item_);
    189   AddTrayItem(new MultiProfileMediaTrayItem(this));
    190   AddTrayItem(new TrayAudioChromeOs(this));
    191   AddTrayItem(new TrayBrightness(this));
    192   AddTrayItem(new TrayCapsLock(this));
    193   AddTrayItem(new TraySettings(this));
    194   AddTrayItem(new TrayUpdate(this));
    195   AddTrayItem(new TrayRotationLock(this));
    196   AddTrayItem(tray_date_);
    197 #elif defined(OS_WIN)
    198   AddTrayItem(tray_accessibility_);
    199   if (media::CoreAudioUtil::IsSupported())
    200     AddTrayItem(new TrayAudioWin(this));
    201   AddTrayItem(new TrayUpdate(this));
    202   AddTrayItem(tray_date_);
    203 #elif defined(OS_LINUX)
    204   AddTrayItem(new TrayIME(this));
    205   AddTrayItem(tray_accessibility_);
    206   AddTrayItem(new TrayBluetooth(this));
    207   AddTrayItem(new TrayUpdate(this));
    208   AddTrayItem(tray_date_);
    209 #endif
    210 
    211   SetVisible(ash::Shell::GetInstance()->system_tray_delegate()->
    212       GetTrayVisibilityOnStartup());
    213 }
    214 
    215 void SystemTray::AddTrayItem(SystemTrayItem* item) {
    216   items_.push_back(item);
    217 
    218   SystemTrayDelegate* delegate = Shell::GetInstance()->system_tray_delegate();
    219   views::View* tray_item = item->CreateTrayView(delegate->GetUserLoginStatus());
    220   item->UpdateAfterShelfAlignmentChange(shelf_alignment());
    221 
    222   if (tray_item) {
    223     tray_container()->AddChildViewAt(tray_item, 0);
    224     PreferredSizeChanged();
    225     tray_item_map_[item] = tray_item;
    226   }
    227 }
    228 
    229 void SystemTray::RemoveTrayItem(SystemTrayItem* item) {
    230   NOTIMPLEMENTED();
    231 }
    232 
    233 const std::vector<SystemTrayItem*>& SystemTray::GetTrayItems() const {
    234   return items_.get();
    235 }
    236 
    237 void SystemTray::ShowDefaultView(BubbleCreationType creation_type) {
    238   ShowDefaultViewWithOffset(
    239       creation_type,
    240       TrayBubbleView::InitParams::kArrowDefaultOffset,
    241       false);
    242 }
    243 
    244 void SystemTray::ShowPersistentDefaultView() {
    245   ShowItems(items_.get(),
    246             false,
    247             false,
    248             BUBBLE_CREATE_NEW,
    249             TrayBubbleView::InitParams::kArrowDefaultOffset,
    250             true);
    251 }
    252 
    253 void SystemTray::ShowDetailedView(SystemTrayItem* item,
    254                                   int close_delay,
    255                                   bool activate,
    256                                   BubbleCreationType creation_type) {
    257   std::vector<SystemTrayItem*> items;
    258   // The detailed view with timeout means a UI to show the current system state,
    259   // like the audio level or brightness. Such UI should behave as persistent and
    260   // keep its own logic for the appearance.
    261   bool persistent = (
    262       !activate && close_delay > 0 && creation_type == BUBBLE_CREATE_NEW);
    263   items.push_back(item);
    264   ShowItems(
    265       items, true, activate, creation_type, GetTrayXOffset(item), persistent);
    266   if (system_bubble_)
    267     system_bubble_->bubble()->StartAutoCloseTimer(close_delay);
    268 }
    269 
    270 void SystemTray::SetDetailedViewCloseDelay(int close_delay) {
    271   if (HasSystemBubbleType(SystemTrayBubble::BUBBLE_TYPE_DETAILED))
    272     system_bubble_->bubble()->StartAutoCloseTimer(close_delay);
    273 }
    274 
    275 void SystemTray::HideDetailedView(SystemTrayItem* item) {
    276   if (item != detailed_item_)
    277     return;
    278   DestroySystemBubble();
    279   UpdateNotificationBubble();
    280 }
    281 
    282 void SystemTray::ShowNotificationView(SystemTrayItem* item) {
    283   if (std::find(notification_items_.begin(), notification_items_.end(), item)
    284       != notification_items_.end())
    285     return;
    286   notification_items_.push_back(item);
    287   UpdateNotificationBubble();
    288 }
    289 
    290 void SystemTray::HideNotificationView(SystemTrayItem* item) {
    291   std::vector<SystemTrayItem*>::iterator found_iter =
    292       std::find(notification_items_.begin(), notification_items_.end(), item);
    293   if (found_iter == notification_items_.end())
    294     return;
    295   notification_items_.erase(found_iter);
    296   // Only update the notification bubble if visible (i.e. don't create one).
    297   if (notification_bubble_)
    298     UpdateNotificationBubble();
    299 }
    300 
    301 void SystemTray::UpdateAfterLoginStatusChange(user::LoginStatus login_status) {
    302   DestroySystemBubble();
    303   UpdateNotificationBubble();
    304 
    305   for (std::vector<SystemTrayItem*>::iterator it = items_.begin();
    306       it != items_.end();
    307       ++it) {
    308     (*it)->UpdateAfterLoginStatusChange(login_status);
    309   }
    310 
    311   // Items default to SHELF_ALIGNMENT_BOTTOM. Update them if the initial
    312   // position of the shelf differs.
    313   if (shelf_alignment() != SHELF_ALIGNMENT_BOTTOM)
    314     UpdateAfterShelfAlignmentChange(shelf_alignment());
    315 
    316   SetVisible(true);
    317   PreferredSizeChanged();
    318 }
    319 
    320 void SystemTray::UpdateAfterShelfAlignmentChange(ShelfAlignment alignment) {
    321   for (std::vector<SystemTrayItem*>::iterator it = items_.begin();
    322       it != items_.end();
    323       ++it) {
    324     (*it)->UpdateAfterShelfAlignmentChange(alignment);
    325   }
    326 }
    327 
    328 void SystemTray::SetHideNotifications(bool hide_notifications) {
    329   if (notification_bubble_)
    330     notification_bubble_->bubble()->SetVisible(!hide_notifications);
    331   hide_notifications_ = hide_notifications;
    332 }
    333 
    334 bool SystemTray::ShouldShowShelf() const {
    335   return system_bubble_.get() && system_bubble_->bubble()->ShouldShowShelf();
    336 }
    337 
    338 bool SystemTray::HasSystemBubble() const {
    339   return system_bubble_.get() != NULL;
    340 }
    341 
    342 bool SystemTray::HasNotificationBubble() const {
    343   return notification_bubble_.get() != NULL;
    344 }
    345 
    346 SystemTrayBubble* SystemTray::GetSystemBubble() {
    347   if (!system_bubble_)
    348     return NULL;
    349   return system_bubble_->bubble();
    350 }
    351 
    352 bool SystemTray::IsAnyBubbleVisible() const {
    353   return ((system_bubble_.get() &&
    354            system_bubble_->bubble()->IsVisible()) ||
    355           (notification_bubble_.get() &&
    356            notification_bubble_->bubble()->IsVisible()));
    357 }
    358 
    359 bool SystemTray::IsMouseInNotificationBubble() const {
    360   if (!notification_bubble_)
    361     return false;
    362   return notification_bubble_->bubble_view()->GetBoundsInScreen().Contains(
    363       Shell::GetScreen()->GetCursorScreenPoint());
    364 }
    365 
    366 bool SystemTray::CloseSystemBubble() const {
    367   if (!system_bubble_)
    368     return false;
    369   system_bubble_->bubble()->Close();
    370   return true;
    371 }
    372 
    373 views::View* SystemTray::GetHelpButtonView() const {
    374   return tray_date_->GetHelpButtonView();
    375 }
    376 
    377 bool SystemTray::CloseNotificationBubbleForTest() const {
    378   if (!notification_bubble_)
    379     return false;
    380   notification_bubble_->bubble()->Close();
    381   return true;
    382 }
    383 
    384 // Private methods.
    385 
    386 bool SystemTray::HasSystemBubbleType(SystemTrayBubble::BubbleType type) {
    387   DCHECK(type != SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION);
    388   return system_bubble_.get() && system_bubble_->bubble_type() == type;
    389 }
    390 
    391 void SystemTray::DestroySystemBubble() {
    392   CloseSystemBubbleAndDeactivateSystemTray();
    393   detailed_item_ = NULL;
    394   UpdateWebNotifications();
    395 }
    396 
    397 void SystemTray::DestroyNotificationBubble() {
    398   if (notification_bubble_) {
    399     notification_bubble_.reset();
    400     UpdateWebNotifications();
    401   }
    402 }
    403 
    404 base::string16 SystemTray::GetAccessibleNameForTray() {
    405   base::string16 time = GetAccessibleTimeString(base::Time::Now());
    406   base::string16 battery = base::ASCIIToUTF16("");
    407 #if defined(OS_CHROMEOS)
    408   battery = PowerStatus::Get()->GetAccessibleNameString(false);
    409 #endif
    410   return l10n_util::GetStringFUTF16(
    411       IDS_ASH_STATUS_TRAY_ACCESSIBLE_DESCRIPTION, time, battery);
    412 }
    413 
    414 int SystemTray::GetTrayXOffset(SystemTrayItem* item) const {
    415   // Don't attempt to align the arrow if the shelf is on the left or right.
    416   if (shelf_alignment() != SHELF_ALIGNMENT_BOTTOM &&
    417       shelf_alignment() != SHELF_ALIGNMENT_TOP)
    418     return TrayBubbleView::InitParams::kArrowDefaultOffset;
    419 
    420   std::map<SystemTrayItem*, views::View*>::const_iterator it =
    421       tray_item_map_.find(item);
    422   if (it == tray_item_map_.end())
    423     return TrayBubbleView::InitParams::kArrowDefaultOffset;
    424 
    425   const views::View* item_view = it->second;
    426   if (item_view->bounds().IsEmpty()) {
    427     // The bounds of item could be still empty if it does not have a visible
    428     // tray view. In that case, use the default (minimum) offset.
    429     return TrayBubbleView::InitParams::kArrowDefaultOffset;
    430   }
    431 
    432   gfx::Point point(item_view->width() / 2, 0);
    433   ConvertPointToWidget(item_view, &point);
    434   return point.x();
    435 }
    436 
    437 void SystemTray::ShowDefaultViewWithOffset(BubbleCreationType creation_type,
    438                                            int arrow_offset,
    439                                            bool persistent) {
    440   if (creation_type != BUBBLE_USE_EXISTING) {
    441     Shell::GetInstance()->metrics()->RecordUserMetricsAction(
    442         ash::UMA_STATUS_AREA_MENU_OPENED);
    443   }
    444   ShowItems(items_.get(), false, true, creation_type, arrow_offset, persistent);
    445 }
    446 
    447 void SystemTray::ShowItems(const std::vector<SystemTrayItem*>& items,
    448                            bool detailed,
    449                            bool can_activate,
    450                            BubbleCreationType creation_type,
    451                            int arrow_offset,
    452                            bool persistent) {
    453   // No system tray bubbles in kiosk mode.
    454   if (Shell::GetInstance()->system_tray_delegate()->GetUserLoginStatus() ==
    455       ash::user::LOGGED_IN_KIOSK_APP) {
    456     return;
    457   }
    458 
    459   // Destroy any existing bubble and create a new one.
    460   SystemTrayBubble::BubbleType bubble_type = detailed ?
    461       SystemTrayBubble::BUBBLE_TYPE_DETAILED :
    462       SystemTrayBubble::BUBBLE_TYPE_DEFAULT;
    463 
    464   // Destroy the notification bubble here so that it doesn't get rebuilt
    465   // while we add items to the main bubble_ (e.g. in HideNotificationView).
    466   notification_bubble_.reset();
    467   if (system_bubble_.get() && creation_type == BUBBLE_USE_EXISTING) {
    468     system_bubble_->bubble()->UpdateView(items, bubble_type);
    469     // If ChromeVox is enabled, focus the default item if no item is focused.
    470     if (Shell::GetInstance()->accessibility_delegate()->
    471         IsSpokenFeedbackEnabled()) {
    472       system_bubble_->bubble()->FocusDefaultIfNeeded();
    473     }
    474   } else {
    475     // Remember if the menu is a single property (like e.g. volume) or the
    476     // full tray menu. Note that in case of the |BUBBLE_USE_EXISTING| case
    477     // above, |full_system_tray_menu_| does not get changed since the fact that
    478     // the menu is full (or not) doesn't change even if a "single property"
    479     // (like network) replaces most of the menu.
    480     full_system_tray_menu_ = items.size() > 1;
    481     // The menu width is fixed, and it is a per language setting.
    482     int menu_width = std::max(kMinimumSystemTrayMenuWidth,
    483         Shell::GetInstance()->system_tray_delegate()->GetSystemTrayMenuWidth());
    484 
    485     TrayBubbleView::InitParams init_params(TrayBubbleView::ANCHOR_TYPE_TRAY,
    486                                            GetAnchorAlignment(),
    487                                            menu_width,
    488                                            kTrayPopupMaxWidth);
    489     init_params.can_activate = can_activate;
    490     init_params.first_item_has_no_margin = true;
    491     if (detailed) {
    492       // This is the case where a volume control or brightness control bubble
    493       // is created.
    494       init_params.max_height = default_bubble_height_;
    495       init_params.arrow_color = kBackgroundColor;
    496     } else {
    497       init_params.arrow_color = kHeaderBackgroundColor;
    498     }
    499     init_params.arrow_offset = arrow_offset;
    500     if (bubble_type == SystemTrayBubble::BUBBLE_TYPE_DEFAULT)
    501       init_params.close_on_deactivate = !persistent;
    502     // For Volume and Brightness we don't want to show an arrow when
    503     // they are shown in a bubble by themselves.
    504     init_params.arrow_paint_type = views::BubbleBorder::PAINT_NORMAL;
    505     if (items.size() == 1 && items[0]->ShouldHideArrow())
    506       init_params.arrow_paint_type = views::BubbleBorder::PAINT_TRANSPARENT;
    507     SystemTrayBubble* bubble = new SystemTrayBubble(this, items, bubble_type);
    508     system_bubble_.reset(new SystemBubbleWrapper(bubble));
    509     system_bubble_->InitView(this, tray_container(), &init_params, persistent);
    510   }
    511   // Save height of default view for creating detailed views directly.
    512   if (!detailed)
    513     default_bubble_height_ = system_bubble_->bubble_view()->height();
    514 
    515   if (detailed && items.size() > 0)
    516     detailed_item_ = items[0];
    517   else
    518     detailed_item_ = NULL;
    519 
    520   UpdateNotificationBubble();  // State changed, re-create notifications.
    521   if (!notification_bubble_)
    522     UpdateWebNotifications();
    523   GetShelfLayoutManager()->UpdateAutoHideState();
    524 
    525   // When we show the system menu in our alternate shelf layout, we need to
    526   // tint the background.
    527   if (full_system_tray_menu_)
    528     SetDrawBackgroundAsActive(true);
    529 }
    530 
    531 void SystemTray::UpdateNotificationBubble() {
    532   // Only show the notification bubble if we have notifications.
    533   if (notification_items_.empty()) {
    534     DestroyNotificationBubble();
    535     return;
    536   }
    537   // Destroy the existing bubble before constructing a new one.
    538   notification_bubble_.reset();
    539   SystemTrayBubble* notification_bubble;
    540   notification_bubble = new SystemTrayBubble(
    541       this, notification_items_, SystemTrayBubble::BUBBLE_TYPE_NOTIFICATION);
    542   views::View* anchor;
    543   TrayBubbleView::AnchorType anchor_type;
    544   // Tray items might want to show notifications while we are creating and
    545   // initializing the |system_bubble_| - but it might not be fully initialized
    546   // when coming here - this would produce a crashed like crbug.com/247416.
    547   // As such we check the existence of the widget here.
    548   if (system_bubble_.get() &&
    549       system_bubble_->bubble_view() &&
    550       system_bubble_->bubble_view()->GetWidget()) {
    551     anchor = system_bubble_->bubble_view();
    552     anchor_type = TrayBubbleView::ANCHOR_TYPE_BUBBLE;
    553   } else {
    554     anchor = tray_container();
    555     anchor_type = TrayBubbleView::ANCHOR_TYPE_TRAY;
    556   }
    557   TrayBubbleView::InitParams init_params(anchor_type,
    558                                          GetAnchorAlignment(),
    559                                          kTrayPopupMinWidth,
    560                                          kTrayPopupMaxWidth);
    561   init_params.first_item_has_no_margin = true;
    562   init_params.arrow_color = kBackgroundColor;
    563   init_params.arrow_offset = GetTrayXOffset(notification_items_[0]);
    564   notification_bubble_.reset(new SystemBubbleWrapper(notification_bubble));
    565   notification_bubble_->InitView(this, anchor, &init_params, false);
    566 
    567   if (notification_bubble->bubble_view()->child_count() == 0) {
    568     // It is possible that none of the items generated actual notifications.
    569     DestroyNotificationBubble();
    570     return;
    571   }
    572   if (hide_notifications_)
    573     notification_bubble->SetVisible(false);
    574   else
    575     UpdateWebNotifications();
    576 }
    577 
    578 void SystemTray::UpdateWebNotifications() {
    579   TrayBubbleView* bubble_view = NULL;
    580   if (notification_bubble_)
    581     bubble_view = notification_bubble_->bubble_view();
    582   else if (system_bubble_)
    583     bubble_view = system_bubble_->bubble_view();
    584 
    585   int height = 0;
    586   if (bubble_view) {
    587     gfx::Rect work_area = Shell::GetScreen()->GetDisplayNearestWindow(
    588         bubble_view->GetWidget()->GetNativeView()).work_area();
    589     if (GetShelfLayoutManager()->GetAlignment() != SHELF_ALIGNMENT_TOP) {
    590       height = std::max(
    591           0, work_area.height() - bubble_view->GetBoundsInScreen().y());
    592     } else {
    593       height = std::max(
    594           0, bubble_view->GetBoundsInScreen().bottom() - work_area.y());
    595     }
    596   }
    597   status_area_widget()->web_notification_tray()->SetSystemTrayHeight(height);
    598 }
    599 
    600 base::string16 SystemTray::GetAccessibleTimeString(
    601     const base::Time& now) const {
    602   base::HourClockType hour_type =
    603       ash::Shell::GetInstance()->system_tray_delegate()->GetHourClockType();
    604   return base::TimeFormatTimeOfDayWithHourClockType(
    605       now, hour_type, base::kKeepAmPm);
    606 }
    607 
    608 void SystemTray::SetShelfAlignment(ShelfAlignment alignment) {
    609   if (alignment == shelf_alignment())
    610     return;
    611   TrayBackgroundView::SetShelfAlignment(alignment);
    612   UpdateAfterShelfAlignmentChange(alignment);
    613   // Destroy any existing bubble so that it is rebuilt correctly.
    614   CloseSystemBubbleAndDeactivateSystemTray();
    615   // Rebuild any notification bubble.
    616   if (notification_bubble_) {
    617     notification_bubble_.reset();
    618     UpdateNotificationBubble();
    619   }
    620 }
    621 
    622 void SystemTray::AnchorUpdated() {
    623   if (notification_bubble_) {
    624     notification_bubble_->bubble_view()->UpdateBubble();
    625     // Ensure that the notification buble is above the shelf/status area.
    626     notification_bubble_->bubble_view()->GetWidget()->StackAtTop();
    627     UpdateBubbleViewArrow(notification_bubble_->bubble_view());
    628   }
    629   if (system_bubble_) {
    630     system_bubble_->bubble_view()->UpdateBubble();
    631     UpdateBubbleViewArrow(system_bubble_->bubble_view());
    632   }
    633 }
    634 
    635 void SystemTray::BubbleResized(const TrayBubbleView* bubble_view) {
    636   UpdateWebNotifications();
    637 }
    638 
    639 void SystemTray::HideBubbleWithView(const TrayBubbleView* bubble_view) {
    640   if (system_bubble_.get() && bubble_view == system_bubble_->bubble_view()) {
    641     DestroySystemBubble();
    642     UpdateNotificationBubble();  // State changed, re-create notifications.
    643     GetShelfLayoutManager()->UpdateAutoHideState();
    644   } else if (notification_bubble_.get() &&
    645              bubble_view == notification_bubble_->bubble_view()) {
    646     DestroyNotificationBubble();
    647   }
    648 }
    649 
    650 bool SystemTray::ClickedOutsideBubble() {
    651   if (!system_bubble_ || system_bubble_->is_persistent())
    652     return false;
    653   HideBubbleWithView(system_bubble_->bubble_view());
    654   return true;
    655 }
    656 
    657 void SystemTray::BubbleViewDestroyed() {
    658   if (system_bubble_) {
    659     system_bubble_->bubble()->DestroyItemViews();
    660     system_bubble_->bubble()->BubbleViewDestroyed();
    661   }
    662 }
    663 
    664 void SystemTray::OnMouseEnteredView() {
    665   if (system_bubble_)
    666     system_bubble_->bubble()->StopAutoCloseTimer();
    667 }
    668 
    669 void SystemTray::OnMouseExitedView() {
    670   if (system_bubble_)
    671     system_bubble_->bubble()->RestartAutoCloseTimer();
    672 }
    673 
    674 base::string16 SystemTray::GetAccessibleNameForBubble() {
    675   return GetAccessibleNameForTray();
    676 }
    677 
    678 gfx::Rect SystemTray::GetAnchorRect(
    679     views::Widget* anchor_widget,
    680     TrayBubbleView::AnchorType anchor_type,
    681     TrayBubbleView::AnchorAlignment anchor_alignment) const {
    682   return GetBubbleAnchorRect(anchor_widget, anchor_type, anchor_alignment);
    683 }
    684 
    685 void SystemTray::HideBubble(const TrayBubbleView* bubble_view) {
    686   HideBubbleWithView(bubble_view);
    687 }
    688 
    689 views::View* SystemTray::GetTrayItemViewForTest(SystemTrayItem* item) {
    690   std::map<SystemTrayItem*, views::View*>::iterator it =
    691       tray_item_map_.find(item);
    692   return it == tray_item_map_.end() ? NULL : it->second;
    693 }
    694 
    695 TrayDate* SystemTray::GetTrayDateForTesting() const { return tray_date_; }
    696 
    697 bool SystemTray::PerformAction(const ui::Event& event) {
    698   // If we're already showing the default view, hide it; otherwise, show it
    699   // (and hide any popup that's currently shown).
    700   if (HasSystemBubbleType(SystemTrayBubble::BUBBLE_TYPE_DEFAULT)) {
    701     system_bubble_->bubble()->Close();
    702   } else {
    703     int arrow_offset = TrayBubbleView::InitParams::kArrowDefaultOffset;
    704     if (event.IsMouseEvent() || event.type() == ui::ET_GESTURE_TAP) {
    705       const ui::LocatedEvent& located_event =
    706           static_cast<const ui::LocatedEvent&>(event);
    707       if (shelf_alignment() == SHELF_ALIGNMENT_BOTTOM ||
    708           shelf_alignment() == SHELF_ALIGNMENT_TOP) {
    709         gfx::Point point(located_event.x(), 0);
    710         ConvertPointToWidget(this, &point);
    711         arrow_offset = point.x();
    712       }
    713     }
    714     ShowDefaultViewWithOffset(BUBBLE_CREATE_NEW, arrow_offset, false);
    715   }
    716   return true;
    717 }
    718 
    719 void SystemTray::CloseSystemBubbleAndDeactivateSystemTray() {
    720   system_bubble_.reset();
    721   // When closing a system bubble with the alternate shelf layout, we need to
    722   // turn off the active tinting of the shelf.
    723   if (full_system_tray_menu_) {
    724     SetDrawBackgroundAsActive(false);
    725     full_system_tray_menu_ = false;
    726   }
    727 }
    728 
    729 }  // namespace ash
    730