Do not activate TrayBubbleView by default

ui/views/bubble/tray_bubble_view.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 "ui/views/bubble/tray_bubble_view.h"
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "cc/paint/paint_flags.h"
@@ skipping 176 matching lines @@
       owned_bubble_border_(bubble_border_),
       is_gesture_dragging_(false),
       mouse_actively_entered_(false) {
   DCHECK(delegate_);
   DCHECK(params_.parent_window);
   DCHECK(anchor_widget());  // Computed by BubbleDialogDelegateView().
   bubble_border_->set_use_theme_background_color(!init_params.bg_color);
   bubble_border_->set_alignment(BubbleBorder::ALIGN_EDGE_TO_ANCHOR_EDGE);
   bubble_border_->set_paint_arrow(BubbleBorder::PAINT_NONE);
   set_parent_window(params_.parent_window);
-  set_can_activate(params_.can_activate);
+  set_can_activate(false);
   set_notify_enter_exit_on_child(true);
   set_close_on_deactivate(init_params.close_on_deactivate);
   set_margins(gfx::Insets());
   SetPaintToLayer();
 
   bubble_content_mask_.reset(
       new TrayBubbleContentMask(bubble_border_->GetBorderCornerRadius()));
 
   layout_->SetDefaultFlex(1);
   SetLayoutManager(layout_);
 }
 
 TrayBubbleView::~TrayBubbleView() {
   mouse_watcher_.reset();
-  // Inform host items (models) that their views are being destroyed.
-  if (delegate_)
+  if (delegate_) {
+    delegate_->UnregisterAllAccelerators(this);
+
+    // Inform host items (models) that their views are being destroyed.
     delegate_->BubbleViewDestroyed();
+  }
 }
 
 // static
 bool TrayBubbleView::IsATrayBubbleOpen() {
   return g_current_tray_bubble_showing_count_ > 0;
 }
 
 void TrayBubbleView::InitializeAndShowBubble() {
   layer()->parent()->SetMaskLayer(bubble_content_mask_->layer());
 
   GetWidget()->Show();
   GetWidget()->GetNativeWindow()->SetEventTargeter(
       std::unique_ptr<ui::EventTargeter>(new BubbleWindowTargeter(this)));
   UpdateBubble();
 
   ++g_current_tray_bubble_showing_count_;
+
+  // If TrayBubbleView cannot be activated, register accelerators to capture key
+  // events for activating the view or closing it. TrayBubbleView expects that
+  // those accelerators are registered at the global level.
+  if (delegate_ && !CanActivate()) {
+    delegate_->RegisterAccelerators(
+        {ui::Accelerator(ui::VKEY_ESCAPE, ui::EF_NONE),
+         ui::Accelerator(ui::VKEY_TAB, ui::EF_NONE),
+         ui::Accelerator(ui::VKEY_TAB, ui::EF_SHIFT_DOWN)},
+        this);
+  }
 }
 
 void TrayBubbleView::UpdateBubble() {
   if (GetWidget()) {
     SizeToContents();
     bubble_content_mask_->layer()->SetBounds(layer()->bounds());
     GetWidget()->GetRootView()->SchedulePaint();
+
+    // When extra keyboard accessibility is enabled, focus the default item if
+    // no item is focused.
+    if (delegate_ && delegate_->ShouldEnableExtraKeyboardAccessibility())
+      FocusDefaultIfNeeded();
   }
 }
 
 void TrayBubbleView::SetMaxHeight(int height) {
   params_.max_height = height;
   if (GetWidget())
     SizeToContents();
 }
 
 void TrayBubbleView::SetBottomPadding(int padding) {
   layout_->set_inside_border_insets(gfx::Insets(0, 0, padding, 0));
 }
 
 void TrayBubbleView::SetWidth(int width) {
   width = std::max(std::min(width, params_.max_width), params_.min_width);
   if (preferred_width_ == width)
     return;
   preferred_width_ = width;
   if (GetWidget())
     SizeToContents();
 }
 
 gfx::Insets TrayBubbleView::GetBorderInsets() const {
   return bubble_border_->GetInsets();
 }
 
+void TrayBubbleView::ResetDelegate() {
+  if (delegate_)
+    delegate_->UnregisterAllAccelerators(this);
+
+  delegate_ = nullptr;
+}
+
 int TrayBubbleView::GetDialogButtons() const {
   return ui::DIALOG_BUTTON_NONE;
 }
 
 void TrayBubbleView::OnBeforeBubbleWidgetInit(Widget::InitParams* params,
                                               Widget* bubble_widget) const {
   // Apply a WM-provided shadow (see ui/wm/core/).
   params->shadow_type = Widget::InitParams::SHADOW_TYPE_DROP;
   params->shadow_elevation = wm::ShadowElevation::LARGE;
 }
@@ skipping 90 matching lines @@
 
 void TrayBubbleView::MouseMovedOutOfHost() {
   // The mouse was accidentally over the bubble when it opened and the AutoClose
   // logic was not activated. Now that the user did move the mouse we tell the
   // delegate to disable AutoClose.
   delegate_->OnMouseEnteredView();
   mouse_actively_entered_ = true;
   mouse_watcher_->Stop();
 }
 
+bool TrayBubbleView::AcceleratorPressed(const ui::Accelerator& accelerator) {
+  if (accelerator == ui::Accelerator(ui::VKEY_ESCAPE, ui::EF_NONE)) {
+    CloseBubbleView();
+    return true;
+  }
+
+  if (accelerator == ui::Accelerator(ui::VKEY_TAB, ui::EF_NONE) ||
+      accelerator == ui::Accelerator(ui::VKEY_TAB, ui::EF_SHIFT_DOWN)) {
+    ui::KeyEvent key_event(
+        accelerator.key_state() == ui::Accelerator::KeyState::PRESSED
+            ? ui::EventType::ET_KEY_PRESSED
+            : ui::EventType::ET_KEY_RELEASED,
+        accelerator.key_code(), accelerator.modifiers());
+    ActivateAndStartNavigation(key_event);
+    return true;
+  }
+
+  return false;
+}
+
 void TrayBubbleView::ChildPreferredSizeChanged(View* child) {
   SizeToContents();
 }
 
 void TrayBubbleView::ViewHierarchyChanged(
     const ViewHierarchyChangedDetails& details) {
   if (details.is_add && details.child == this) {
     details.parent->SetPaintToLayer();
     details.parent->layer()->SetMasksToBounds(true);
   }
 }
 
+void TrayBubbleView::CloseBubbleView() {
+  if (!delegate_)
+    return;
+
+  delegate_->UnregisterAllAccelerators(this);
+  delegate_->HideBubble(this);
+}
+
+void TrayBubbleView::ActivateAndStartNavigation(const ui::KeyEvent& key_event) {
+  // No need to explicitly activate the widget. FocusManager will activate it if
+  // necessary.
+  set_can_activate(true);
+
+  if (!GetWidget()->GetFocusManager()->OnKeyEvent(key_event) && delegate_) {
+    // No need to handle accelerators by TrayBubbleView after focus has moved to
+    // the widget. The focused view will handle focus traversal.
+    // FocusManager::OnKeyEvent returns false when it consumes a key event.
+    delegate_->UnregisterAllAccelerators(this);
+  }
+}
+
+void TrayBubbleView::FocusDefaultIfNeeded() {
+  views::FocusManager* manager = GetFocusManager();
+  if (!manager || manager->GetFocusedView())
+    return;
+
+  views::View* view =
+      manager->GetNextFocusableView(nullptr, nullptr, false, false);
+  if (!view)
+    return;
+
+  // No need to explicitly activate the widget. View::RequestFocus will activate
+  // it if necessary.
+  set_can_activate(true);
+
+  view->RequestFocus();
+}
+
 }  // namespace views