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