Focus launcher if spoken feedback is enabled and no other windows visible.

ash/launcher/launcher.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/launcher/launcher.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "ash/focus_cycler.h"
 #include "ash/launcher/launcher_delegate.h"
 #include "ash/launcher/launcher_model.h"
 #include "ash/launcher/launcher_navigator.h"
 #include "ash/launcher/launcher_view.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/shelf_layout_manager.h"
 #include "ash/wm/window_properties.h"
 #include "grit/ash_resources.h"
+#include "ui/aura/client/activation_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/views/accessible_pane_view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
@@ skipping 29 matching lines @@
   virtual void OnPaintBackground(gfx::Canvas* canvas) OVERRIDE;
 
   // views::WidgetDelegateView overrides:
   virtual views::Widget* GetWidget() OVERRIDE {
     return View::GetWidget();
   }
   virtual const views::Widget* GetWidget() const OVERRIDE {
     return View::GetWidget();
   }
   virtual bool CanActivate() const OVERRIDE {
-    // We don't want mouse clicks to activate us, but we need to allow
-    // activation when the user is using the keyboard (FocusCycler).
-    return focus_cycler_ && focus_cycler_->widget_activating() == GetWidget();
+    // Allow to activate as fallback.
+    if (launcher_->activating_as_fallback_ &&
+        Shell::GetInstance()->delegate()->IsSpokenFeedbackEnabled()) {
+      return true;
+    }
+    // Allow to activate from the focus cycler.
+    if (focus_cycler_ && focus_cycler_->widget_activating() == GetWidget())
+      return true;
+    // Disallow activating in other cases, especially when using mouse.
+    return false;
   }
 
   // BackgroundAnimatorDelegate overrides:
   virtual void UpdateBackground(int alpha) OVERRIDE;
 
  private:
   Launcher* launcher_;
   internal::FocusCycler* focus_cycler_;
   int alpha_;
 
@@ skipping 113 matching lines @@
 
 // Launcher --------------------------------------------------------------------
 
 Launcher::Launcher(aura::Window* window_container,
                    internal::ShelfLayoutManager* shelf_layout_manager)
     : widget_(NULL),
       window_container_(window_container),
       delegate_view_(new DelegateView(this)),
       launcher_view_(NULL),
       alignment_(SHELF_ALIGNMENT_BOTTOM),
-      background_animator_(delegate_view_, 0, kLauncherBackgroundAlpha) {
+      background_animator_(delegate_view_, 0, kLauncherBackgroundAlpha),
+      activating_as_fallback_(false) {
   model_.reset(new LauncherModel);
   delegate_.reset(
       Shell::GetInstance()->delegate()->CreateLauncherDelegate(model_.get()));
 
   widget_.reset(new views::Widget);
   views::Widget::InitParams params(
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   params.transparent = true;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.parent = Shell::GetContainer(
       window_container_->GetRootWindow(),
       ash::internal::kShellWindowId_LauncherContainer);
   launcher_view_ = new internal::LauncherView(
       model_.get(), delegate_.get(), shelf_layout_manager);
   launcher_view_->Init();
   delegate_view_->AddChildView(launcher_view_);
   params.delegate = delegate_view_;
   widget_->Init(params);
   widget_->GetNativeWindow()->SetName("LauncherWindow");
   // The launcher should not take focus when it is initially shown.
   widget_->set_focus_on_creation(false);
   widget_->SetContentsView(delegate_view_);
   widget_->GetNativeView()->SetName("LauncherView");
   widget_->GetNativeView()->SetProperty(internal::kStayInSameRootWindowKey,
                                         true);
   // SetBounds() has to be called after kStayInSameRootWindowKey is set.
   gfx::Size pref =
       static_cast<views::View*>(launcher_view_)->GetPreferredSize();
   widget_->SetBounds(gfx::Rect(pref));
+
+  widget_->AddObserver(this);
 }
 
 Launcher::~Launcher() {
+  widget_->RemoveObserver(this);
 }
 
 // static
 Launcher* Launcher::ForPrimaryDisplay() {
   return internal::RootWindowController::ForLauncher(
       Shell::GetPrimaryRootWindow())->launcher();
 }
 
 // static
 Launcher* Launcher::ForWindow(aura::Window* window) {
@@ skipping 118 matching lines @@
 views::View* Launcher::GetAppListButtonView() const {
   return launcher_view_->GetAppListButtonView();
 }
 
 void Launcher::SetWidgetBounds(const gfx::Rect bounds) {
   widget_->SetBounds(bounds);
   if (dimmer_.get())
     dimmer_->SetBounds(bounds);
 }
 
+void Launcher::OnWidgetActivationChanged(views::Widget* widget, bool active) {
+  activating_as_fallback_ = false;
+  if (active) {
+    delegate_view_->SetPaneFocusAndFocusDefault();
+  } else {
+    delegate_view_->GetFocusManager()->ClearFocus();
+  }
+}
+
 internal::LauncherView* Launcher::GetLauncherViewForTest() {
   return launcher_view_;
 }
 
 }  // namespace ash