Revert of Do not activate TrayBubbleView by default

ash/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/system/tray/system_tray.h"
 
 #include <algorithm>
 #include <map>
 #include <vector>
 
-#include "ash/accelerators/accelerator_controller.h"
 #include "ash/key_event_watcher.h"
 #include "ash/login_status.h"
 #include "ash/public/cpp/config.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ash/session/session_controller.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shell.h"
 #include "ash/shell_port.h"
 #include "ash/strings/grit/ash_strings.h"
@@ skipping 90 matching lines @@
   explicit SystemBubbleWrapper(SystemTrayBubble* bubble)
       : bubble_(bubble), is_persistent_(false) {}
 
   // Initializes the bubble view and creates |bubble_wrapper_|.
   void InitView(TrayBackgroundView* tray,
                 views::View* anchor,
                 const gfx::Insets& anchor_insets,
                 TrayBubbleView::InitParams* init_params,
                 bool is_persistent) {
     DCHECK(anchor);
-
-    is_persistent_ = is_persistent;
-
     const LoginStatus login_status =
         Shell::Get()->session_controller()->login_status();
     bubble_->InitView(anchor, login_status, init_params);
     bubble_->bubble_view()->set_anchor_view_insets(anchor_insets);
     bubble_wrapper_.reset(new TrayBubbleWrapper(tray, bubble_->bubble_view()));
+    is_persistent_ = is_persistent;
+
+    // If ChromeVox is enabled, focus the default item if no item is focused and
+    // there isn't a delayed close.
+    if (Shell::Get()->accessibility_delegate()->IsSpokenFeedbackEnabled() &&
+        !is_persistent) {
+      bubble_->FocusDefaultIfNeeded();
+    }
   }
 
   // Convenience accessors:
   SystemTrayBubble* bubble() const { return bubble_.get(); }
   SystemTrayBubble::BubbleType bubble_type() const {
     return bubble_->bubble_type();
   }
   TrayBubbleView* bubble_view() const { return bubble_->bubble_view(); }
   bool is_persistent() const { return is_persistent_; }
 
@@ skipping 59 matching lines @@
 
   // Since user avatar is on the right hand side of System tray of a
   // horizontal shelf and that is sufficient to indicate separation, no
   // separator is required.
   set_separator_visibility(false);
 }
 
 SystemTray::~SystemTray() {
   // Destroy any child views that might have back pointers before ~View().
   activation_observer_.reset();
+  key_event_watcher_.reset();
   system_bubble_.reset();
   for (const auto& item : items_)
     item->OnTrayViewDestroyed();
 }
 
 void SystemTray::InitializeTrayItems(
     SystemTrayDelegate* delegate,
     WebNotificationTray* web_notification_tray) {
   DCHECK(web_notification_tray);
   web_notification_tray_ = web_notification_tray;
@@ skipping 206 matching lines @@
   if (Shell::Get()->session_controller()->IsKioskSession())
     return;
 
   // Destroy any existing bubble and create a new one.
   SystemTrayBubble::BubbleType bubble_type =
       detailed ? SystemTrayBubble::BUBBLE_TYPE_DETAILED
                : SystemTrayBubble::BUBBLE_TYPE_DEFAULT;
 
   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 (Shell::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();
 
     // Remember if the menu is a single property (like e.g. volume) or the
     // full tray menu. Note that in case of the |BUBBLE_USE_EXISTING| case
     // above, |full_system_tray_menu_| does not get changed since the fact that
     // the menu is full (or not) doesn't change even if a "single property"
     // (like network) replaces most of the menu.
     full_system_tray_menu_ = items.size() > 1;
 
     TrayBubbleView::InitParams init_params;
     init_params.anchor_alignment = GetAnchorAlignment();
     init_params.min_width = kTrayMenuMinimumWidth;
     init_params.max_width = kTrayPopupMaxWidth;
+    // TODO(oshima): Change TrayBubbleView itself.
+    init_params.can_activate = false;
     // The bubble is not initially activatable, but will become activatable if
     // the user presses Tab. For behavioral consistency with the non-activatable
     // scenario, don't close on deactivation after Tab either.
     init_params.close_on_deactivate = false;
     if (detailed) {
       // This is the case where a volume control or brightness control bubble
       // is created.
       init_params.max_height = default_bubble_height_;
     } else {
       init_params.bg_color = kHeaderBackgroundColor;
     }
     SystemTrayBubble* bubble = new SystemTrayBubble(this, items, bubble_type);
 
     system_bubble_.reset(new SystemBubbleWrapper(bubble));
     system_bubble_->InitView(this, GetBubbleAnchor(), GetBubbleAnchorInsets(),
                              &init_params, persistent);
 
     activation_observer_.reset(persistent ? nullptr
                                           : new ActivationObserver(this));
 
     // Record metrics for the system menu when the default view is invoked.
     if (!detailed)
       RecordSystemMenuMetrics();
   }
   // Save height of default view for creating detailed views directly.
   if (!detailed)
     default_bubble_height_ = system_bubble_->bubble_view()->height();
 
+  key_event_watcher_.reset();
+  if (can_activate)
+    CreateKeyEventWatcher();
+
   if (detailed && items.size() > 0)
     detailed_item_ = items[0];
   else
     detailed_item_ = NULL;
 
   UpdateWebNotifications();
   shelf()->UpdateAutoHideState();
 
   // When we show the system menu in our alternate shelf layout, we need to
   // tint the background.
@@ skipping 70 matching lines @@
 void SystemTray::OnMouseEnteredView() {
   if (system_bubble_)
     system_bubble_->bubble()->StopAutoCloseTimer();
 }
 
 void SystemTray::OnMouseExitedView() {
   if (system_bubble_)
     system_bubble_->bubble()->RestartAutoCloseTimer();
 }
 
-void SystemTray::RegisterAccelerators(
-    const std::vector<ui::Accelerator>& accelerators,
-    views::TrayBubbleView* tray_bubble_view) {
-  Shell::Get()->accelerator_controller()->Register(accelerators,
-                                                   tray_bubble_view);
-}
-
-void SystemTray::UnregisterAllAccelerators(
-    views::TrayBubbleView* tray_bubble_view) {
-  Shell::Get()->accelerator_controller()->UnregisterAll(tray_bubble_view);
-}
-
 base::string16 SystemTray::GetAccessibleNameForBubble() {
   return GetAccessibleNameForTray();
 }
 
-bool SystemTray::ShouldEnableExtraKeyboardAccessibility() {
-  // Do not enable extra keyboard accessibility for persistent system bubble.
-  // e.g. volume slider. Persistent system bubble is a bubble which is not
-  // closed even if user clicks outside of the bubble.
-  return system_bubble_ && !system_bubble_->is_persistent() &&
-         Shell::Get()->accessibility_delegate()->IsSpokenFeedbackEnabled();
-}
-
 void SystemTray::HideBubble(const TrayBubbleView* bubble_view) {
   HideBubbleWithView(bubble_view);
 }
 
 void SystemTray::CloseBubble(const ui::KeyEvent& key_event) {
   CloseSystemBubble();
 }
 
 void SystemTray::ActivateAndStartNavigation(const ui::KeyEvent& key_event) {
   if (!system_bubble_)
     return;
   ActivateBubble();
 
   views::Widget* widget = GetSystemBubble()->bubble_view()->GetWidget();
   widget->GetFocusManager()->OnKeyEvent(key_event);
 }
 
+void SystemTray::CreateKeyEventWatcher() {
+  key_event_watcher_ = ShellPort::Get()->CreateKeyEventWatcher();
+  // mustash does not yet support KeyEventWatcher. http://crbug.com/649600.
+  if (!key_event_watcher_)
+    return;
+  key_event_watcher_->AddKeyEventCallback(
+      ui::Accelerator(ui::VKEY_ESCAPE, ui::EF_NONE),
+      base::Bind(&SystemTray::CloseBubble, base::Unretained(this)));
+  key_event_watcher_->AddKeyEventCallback(
+      ui::Accelerator(ui::VKEY_TAB, ui::EF_NONE),
+      base::Bind(&SystemTray::ActivateAndStartNavigation,
+                 base::Unretained(this)));
+  key_event_watcher_->AddKeyEventCallback(
+      ui::Accelerator(ui::VKEY_TAB, ui::EF_SHIFT_DOWN),
+      base::Bind(&SystemTray::ActivateAndStartNavigation,
+                 base::Unretained(this)));
+}
+
 void SystemTray::ActivateBubble() {
   TrayBubbleView* bubble_view = GetSystemBubble()->bubble_view();
   // If system tray bubble is in the process of closing, do not try to activate
   // bubble.
   if (bubble_view->GetWidget()->IsClosed())
     return;
   bubble_view->set_can_activate(true);
   bubble_view->GetWidget()->Activate();
 }
 
 bool SystemTray::PerformAction(const ui::Event& event) {
   // If we're already showing the default view or detailed view in system menu,
   // hide it; otherwise, show it (and hide any popup that's currently shown).
   if (HasSystemBubbleType(SystemTrayBubble::BUBBLE_TYPE_DEFAULT) ||
       (HasSystemBubbleType(SystemTrayBubble::BUBBLE_TYPE_DETAILED) &&
        full_system_tray_menu_)) {
     system_bubble_->bubble()->Close();
   } else {
     ShowDefaultView(BUBBLE_CREATE_NEW);
     if (event.IsKeyEvent() || (event.flags() & ui::EF_TOUCH_ACCESSIBILITY))
       ActivateBubble();
   }
   return true;
 }
 
 void SystemTray::CloseSystemBubbleAndDeactivateSystemTray() {
   activation_observer_.reset();
+  key_event_watcher_.reset();
   system_bubble_.reset();
   // When closing a system bubble with the alternate shelf layout, we need to
   // turn off the active tinting of the shelf.
   if (full_system_tray_menu_) {
     SetIsActive(false);
     full_system_tray_menu_ = false;
   }
 }
 
 void SystemTray::RecordSystemMenuMetrics() {
@@ skipping 17 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