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.

[dmazzoni, 2017/06/20 16:32:54]

Maybe the comment should mention spoken feedback?

// Do not enable extra keyboard accessibility for persistent system bubbles,
// which are those that are not closed even if the user clicks outside
// of the bubble, e.g. the volume slider - but do enable extra keyboard
// accessibility for them if spoken feedback is enabled.

[yawano, 2017/06/21 01:20:04]

No, we don't enable extra keyboard accessibility for persistent system bubbles
even if spoken feedback is enabled. Extra keyboard accessibility moves focus to
the first focusable item in persistent system bubble. If we move the focus, it
causes spoken feedback.

My assumption is that for persistent system bubble, user don't want move focus
on to it, e.g. volume slider. Note that user can still move the focus to an
element in volume slider by pressing Tab.

Also this should be same with the current behavior.

+  // 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