Merge from Chromium at DEPS revision 278205

This commit was generated by merge_to_master.py.

Change-Id: I23f1e7ea8c154ba72e7fb594436216f861f868ab

6 files changed, 222 insertions, 48 deletions

diff --git a/athena/input/DEPS b/athena/input/DEPS
index 5b66b22c14..c280756495 100644
--- a/athena/input/DEPS
+++ b/athena/input/DEPS
@@ -4,10 +4,6 @@ include_rules = [
   "+ui/events",
   "+ui/wm/core",
   "+ui/wm/public",
+  "+ui/views",
 ]
 
-specific_include_rules = {
-  ".*unittest\.cc": [
-    "+athena/test",
-  ],
-}
diff --git a/athena/input/accelerator_manager_impl.cc b/athena/input/accelerator_manager_impl.cc
index cdd4673b2b..4fabe62808 100644
--- a/athena/input/accelerator_manager_impl.cc
+++ b/athena/input/accelerator_manager_impl.cc
@@ -4,12 +4,16 @@
 
 #include "athena/input/accelerator_manager_impl.h"
 
+#include "athena/common/switches.h"
 #include "athena/input/public/input_manager.h"
 #include "base/logging.h"
 #include "ui/aura/window.h"
 #include "ui/base/accelerators/accelerator_manager.h"
 #include "ui/events/event.h"
 #include "ui/events/event_target.h"
+#include "ui/views/focus/focus_manager.h"
+#include "ui/views/focus/focus_manager_delegate.h"
+#include "ui/views/focus/focus_manager_factory.h"
 #include "ui/wm/core/accelerator_delegate.h"
 #include "ui/wm/core/accelerator_filter.h"
 #include "ui/wm/core/nested_accelerator_controller.h"
@@ -18,6 +22,18 @@
 
 namespace athena {
 
+// This wrapper interface provides a common interface that handles global
+// accelerators as well as local accelerators.
+class AcceleratorManagerImpl::AcceleratorWrapper {
+ public:
+  virtual ~AcceleratorWrapper() {}
+  virtual void Register(const ui::Accelerator& accelerator,
+                        ui::AcceleratorTarget* target) = 0;
+  virtual bool Process(const ui::Accelerator& accelerator) = 0;
+  virtual ui::AcceleratorTarget* GetCurrentTarget(
+      const ui::Accelerator& accelertor) const = 0;
+};
+
 namespace {
 
 // Accelerators inside nested message loop are handled by
@@ -37,9 +53,8 @@ class NestedAcceleratorDelegate : public wm::NestedAcceleratorDelegate {
   // wm::NestedAcceleratorDelegate:
   virtual Result ProcessAccelerator(
       const ui::Accelerator& accelerator) OVERRIDE {
-    return accelerator_manager_->ProcessAccelerator(accelerator)
-               ? RESULT_PROCESSED
-               : RESULT_NOT_PROCESSED;
+    return accelerator_manager_->Process(accelerator) ? RESULT_PROCESSED
+                                                      : RESULT_NOT_PROCESSED;
   }
 
   AcceleratorManagerImpl* accelerator_manager_;
@@ -60,17 +75,120 @@ class AcceleratorDelegate : public wm::AcceleratorDelegate {
                                   KeyType key_type) OVERRIDE {
     aura::Window* target = static_cast<aura::Window*>(event.target());
     if (!target->IsRootWindow() &&
-        !accelerator_manager_->IsReservedAccelerator(accelerator)) {
+        !accelerator_manager_->IsRegistered(accelerator, AF_RESERVED)) {
       // TODO(oshima): do the same when the active window is in fullscreen.
       return false;
     }
-    return accelerator_manager_->ProcessAccelerator(accelerator);
+    return accelerator_manager_->Process(accelerator);
   }
 
   AcceleratorManagerImpl* accelerator_manager_;
   DISALLOW_COPY_AND_ASSIGN(AcceleratorDelegate);
 };
 
+class FocusManagerDelegate : public views::FocusManagerDelegate {
+ public:
+  explicit FocusManagerDelegate(AcceleratorManagerImpl* accelerator_manager)
+      : accelerator_manager_(accelerator_manager) {}
+  virtual ~FocusManagerDelegate() {}
+
+  virtual bool ProcessAccelerator(const ui::Accelerator& accelerator) OVERRIDE {
+    return accelerator_manager_->Process(accelerator);
+  }
+
+  virtual ui::AcceleratorTarget* GetCurrentTargetForAccelerator(
+      const ui::Accelerator& accelerator) const OVERRIDE {
+    return accelerator_manager_->IsRegistered(accelerator, AF_NONE)
+               ? accelerator_manager_
+               : NULL;
+  }
+
+ private:
+  AcceleratorManagerImpl* accelerator_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(FocusManagerDelegate);
+};
+
+// Key strokes must be sent to web contents to give them a chance to
+// consume them unless they are reserved, and unhandled key events are
+// sent back to focus manager asynchronously. This installs the athena's
+// focus manager that handles athena shell's accelerators.
+class FocusManagerFactory : public views::FocusManagerFactory {
+ public:
+  explicit FocusManagerFactory(AcceleratorManagerImpl* accelerator_manager)
+      : accelerator_manager_(accelerator_manager) {}
+  virtual ~FocusManagerFactory() {}
+
+  virtual views::FocusManager* CreateFocusManager(
+      views::Widget* widget,
+      bool desktop_widget) OVERRIDE {
+    return new views::FocusManager(
+        widget,
+        desktop_widget ? NULL : new FocusManagerDelegate(accelerator_manager_));
+  }
+
+ private:
+  AcceleratorManagerImpl* accelerator_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(FocusManagerFactory);
+};
+
+class UIAcceleratorManagerWrapper
+    : public AcceleratorManagerImpl::AcceleratorWrapper {
+ public:
+  UIAcceleratorManagerWrapper()
+      : ui_accelerator_manager_(new ui::AcceleratorManager) {}
+  virtual ~UIAcceleratorManagerWrapper() {}
+
+  virtual void Register(const ui::Accelerator& accelerator,
+                        ui::AcceleratorTarget* target) OVERRIDE {
+    return ui_accelerator_manager_->Register(
+        accelerator, ui::AcceleratorManager::kNormalPriority, target);
+  }
+
+  virtual bool Process(const ui::Accelerator& accelerator) OVERRIDE {
+    return ui_accelerator_manager_->Process(accelerator);
+  }
+
+  virtual ui::AcceleratorTarget* GetCurrentTarget(
+      const ui::Accelerator& accelerator) const OVERRIDE {
+    return ui_accelerator_manager_->GetCurrentTarget(accelerator);
+  }
+
+ private:
+  scoped_ptr<ui::AcceleratorManager> ui_accelerator_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(UIAcceleratorManagerWrapper);
+};
+
+class FocusManagerWrapper : public AcceleratorManagerImpl::AcceleratorWrapper {
+ public:
+  explicit FocusManagerWrapper(views::FocusManager* focus_manager)
+      : focus_manager_(focus_manager) {}
+  virtual ~FocusManagerWrapper() {}
+
+  virtual void Register(const ui::Accelerator& accelerator,
+                        ui::AcceleratorTarget* target) OVERRIDE {
+    return focus_manager_->RegisterAccelerator(
+        accelerator, ui::AcceleratorManager::kNormalPriority, target);
+  }
+
+  virtual bool Process(const ui::Accelerator& accelerator) OVERRIDE {
+    NOTREACHED();
+    return true;
+  }
+
+  virtual ui::AcceleratorTarget* GetCurrentTarget(
+      const ui::Accelerator& accelerator) const OVERRIDE {
+    return focus_manager_->GetCurrentTargetForAccelerator(accelerator);
+  }
+
+ private:
+  views::FocusManager* focus_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(FocusManagerWrapper);
+};
+
 }  // namespace
 
 class AcceleratorManagerImpl::InternalData {
@@ -80,7 +198,7 @@ class AcceleratorManagerImpl::InternalData {
 
   bool IsNonAutoRepeatable() const { return flags_ & AF_NON_AUTO_REPEATABLE; }
   bool IsDebug() const { return flags_ & AF_DEBUG; }
-  bool IsReserved() const { return flags_ & AF_RESERVED; }
+  int flags() const { return flags_; }
 
   bool IsCommandEnabled() const {
     return handler_->IsCommandEnabled(command_id_);
@@ -98,16 +216,30 @@ class AcceleratorManagerImpl::InternalData {
   // This class is copyable by design.
 };
 
-AcceleratorManagerImpl::AcceleratorManagerImpl()
-    : accelerator_manager_(new ui::AcceleratorManager) {
+// static
+AcceleratorManagerImpl*
+AcceleratorManagerImpl::CreateGlobalAcceleratorManager() {
+  return new AcceleratorManagerImpl(new UIAcceleratorManagerWrapper());
+}
+
+scoped_ptr<AcceleratorManager> AcceleratorManagerImpl::CreateForFocusManager(
+    views::FocusManager* focus_manager) {
+  return scoped_ptr<AcceleratorManager>(
+             new AcceleratorManagerImpl(new FocusManagerWrapper(focus_manager)))
+      .Pass();
 }
 
 AcceleratorManagerImpl::~AcceleratorManagerImpl() {
   nested_accelerator_controller_.reset();
   accelerator_filter_.reset();
+  // Reset to use the default focus manager because the athena's
+  // FocusManager has the reference to this object.
+  views::FocusManagerFactory::Install(NULL);
 }
 
 void AcceleratorManagerImpl::Init() {
+  views::FocusManagerFactory::Install(new FocusManagerFactory(this));
+
   ui::EventTarget* toplevel = InputManager::Get()->GetTopmostEventTarget();
   nested_accelerator_controller_.reset(
       new wm::NestedAcceleratorController(new NestedAcceleratorDelegate(this)));
@@ -125,18 +257,24 @@ void AcceleratorManagerImpl::OnRootWindowCreated(aura::Window* root_window) {
                                     nested_accelerator_controller_.get());
 }
 
-bool AcceleratorManagerImpl::IsReservedAccelerator(
-    const ui::Accelerator& accelerator) const {
+bool AcceleratorManagerImpl::Process(const ui::Accelerator& accelerator) {
+  return accelerator_wrapper_->Process(accelerator);
+}
+
+bool AcceleratorManagerImpl::IsRegistered(const ui::Accelerator& accelerator,
+                                          int flags) const {
   std::map<ui::Accelerator, InternalData>::const_iterator iter =
       accelerators_.find(accelerator);
   if (iter == accelerators_.end())
     return false;
-  return iter->second.IsReserved();
+  DCHECK(accelerator_wrapper_->GetCurrentTarget(accelerator));
+  return flags == AF_NONE || iter->second.flags() & flags;
 }
 
-bool AcceleratorManagerImpl::ProcessAccelerator(
-    const ui::Accelerator& accelerator) {
-  return accelerator_manager_->Process(accelerator);
+AcceleratorManagerImpl::AcceleratorManagerImpl(
+    AcceleratorWrapper* accelerator_wrapper)
+    : accelerator_wrapper_(accelerator_wrapper),
+      debug_accelerators_enabled_(switches::IsDebugAcceleratorsEnabled()) {
 }
 
 void AcceleratorManagerImpl::RegisterAccelerators(
@@ -147,8 +285,8 @@ void AcceleratorManagerImpl::RegisterAccelerators(
     RegisterAccelerator(accelerators[i], handler);
 }
 
-void AcceleratorManagerImpl::EnableDebugAccelerators() {
-  debug_accelerators_enabled_ = true;
+void AcceleratorManagerImpl::SetDebugAcceleratorsEnabled(bool enabled) {
+  debug_accelerators_enabled_ = enabled;
 }
 
 bool AcceleratorManagerImpl::AcceleratorPressed(
@@ -178,8 +316,7 @@ void AcceleratorManagerImpl::RegisterAccelerator(
   accelerator.set_type(accelerator_data.trigger_event == TRIGGER_ON_PRESS
                            ? ui::ET_KEY_PRESSED
                            : ui::ET_KEY_RELEASED);
-  accelerator_manager_->Register(
-      accelerator, ui::AcceleratorManager::kNormalPriority, this);
+  accelerator_wrapper_->Register(accelerator, this);
   accelerators_.insert(
       std::make_pair(accelerator,
                      InternalData(accelerator_data.command_id,
@@ -187,4 +324,15 @@ void AcceleratorManagerImpl::RegisterAccelerator(
                                   accelerator_data.accelerator_flags)));
 }
 
+// static
+AcceleratorManager* AcceleratorManager::Get() {
+  return InputManager::Get()->GetAcceleratorManager();
+}
+
+// static
+scoped_ptr<AcceleratorManager> AcceleratorManager::CreateForFocusManager(
+    views::FocusManager* focus_manager) {
+  return AcceleratorManagerImpl::CreateForFocusManager(focus_manager).Pass();
+}
+
 }  // namespace athena
diff --git a/athena/input/accelerator_manager_impl.h b/athena/input/accelerator_manager_impl.h
index 1a5e8a95eb..5891b8599e 100644
--- a/athena/input/accelerator_manager_impl.h
+++ b/athena/input/accelerator_manager_impl.h
@@ -17,10 +17,6 @@ namespace aura {
 class Window;
 }
 
-namespace ui {
-class AcceleratorManager;
-}
-
 namespace wm {
 class AcceleratorFilter;
 class NestedAcceleratorController;
@@ -35,38 +31,52 @@ namespace athena {
 class AcceleratorManagerImpl : public AcceleratorManager,
                                public ui::AcceleratorTarget {
  public:
-  AcceleratorManagerImpl();
+  class AcceleratorWrapper;
+
+  // Creates an AcceleratorManager for global accelerators.
+  // This is the one returned by AcceleratorManager::Get()
+  static AcceleratorManagerImpl* CreateGlobalAcceleratorManager();
+
+  // Creates an AcceleratorManager for focus manager.
+  static scoped_ptr<AcceleratorManager> CreateForFocusManager(
+      views::FocusManager* focus_manager);
+
   virtual ~AcceleratorManagerImpl();
 
   void Init();
 
   void OnRootWindowCreated(aura::Window* root_window);
 
-  bool IsReservedAccelerator(const ui::Accelerator& accelerator) const;
-  bool ProcessAccelerator(const ui::Accelerator& accelerator);
+  bool Process(const ui::Accelerator& accelerator);
+
+  // AcceleratorManager:
+  // This is made public so that implementation classes can use this.
+  virtual bool IsRegistered(const ui::Accelerator& accelerator,
+                            int flags) const OVERRIDE;
 
  private:
+  class InternalData;
+
+  explicit AcceleratorManagerImpl(AcceleratorWrapper* wrapper);
+
   // AcceleratorManager:
   virtual void RegisterAccelerators(const AcceleratorData accelerators[],
                                     size_t num_accelerators,
                                     AcceleratorHandler* handler) OVERRIDE;
-  virtual void EnableDebugAccelerators() OVERRIDE;
+  virtual void SetDebugAcceleratorsEnabled(bool enabled) OVERRIDE;
 
   // ui::AcceleratorTarget:
   virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE;
   virtual bool CanHandleAccelerators() const OVERRIDE;
 
-  class InternalData;
-
   void RegisterAccelerator(const AcceleratorData& accelerator,
                            AcceleratorHandler* handler);
 
-  bool debug_accelerators_enabled_;
   std::map<ui::Accelerator, InternalData> accelerators_;
-  scoped_ptr<ui::AcceleratorManager> accelerator_manager_;
-
+  scoped_ptr<AcceleratorWrapper> accelerator_wrapper_;
   scoped_ptr<wm::AcceleratorFilter> accelerator_filter_;
   scoped_ptr<wm::NestedAcceleratorController> nested_accelerator_controller_;
+  bool debug_accelerators_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(AcceleratorManagerImpl);
 };
diff --git a/athena/input/accelerator_manager_unittest.cc b/athena/input/accelerator_manager_unittest.cc
index cd80e8658d..4f4c753356 100644
--- a/athena/input/accelerator_manager_unittest.cc
+++ b/athena/input/accelerator_manager_unittest.cc
@@ -96,12 +96,13 @@ TEST_F(InputManagerTest, Basic) {
   EXPECT_EQ(COMMAND_A, test_handler.GetFiredCommandIdAndReset());
 
   // Debug accelerators.
+  accelerator_manager->SetDebugAcceleratorsEnabled(false);
   generator.PressKey(ui::VKEY_C, ui::EF_SHIFT_DOWN);
   EXPECT_EQ(kInvalidCommandId, test_handler.GetFiredCommandIdAndReset());
-
-  accelerator_manager->EnableDebugAccelerators();
+  accelerator_manager->SetDebugAcceleratorsEnabled(true);
   generator.PressKey(ui::VKEY_C, ui::EF_SHIFT_DOWN);
   EXPECT_EQ(COMMAND_C, test_handler.GetFiredCommandIdAndReset());
+  accelerator_manager->SetDebugAcceleratorsEnabled(false);
 
   // Non auto repeatable
   generator.PressKey(ui::VKEY_D, ui::EF_SHIFT_DOWN);
@@ -109,12 +110,10 @@ TEST_F(InputManagerTest, Basic) {
   generator.PressKey(ui::VKEY_D, ui::EF_SHIFT_DOWN | ui::EF_IS_REPEAT);
   EXPECT_EQ(kInvalidCommandId, test_handler.GetFiredCommandIdAndReset());
 
-  // Non reserved accelerator won't be handled unless there is
-  // a view's focus manager.
-  // TODO(oshima): Support view's focus manager. Investigate we can implement
-  // the non reserved behavior without view's focus manager.
+  // TODO(oshima): Add scenario where the key event is consumed by
+  // an app.
   generator.PressKey(ui::VKEY_E, ui::EF_SHIFT_DOWN);
-  EXPECT_EQ(kInvalidCommandId, test_handler.GetFiredCommandIdAndReset());
+  EXPECT_EQ(COMMAND_E, test_handler.GetFiredCommandIdAndReset());
 }
 
 }  // namespace athena
diff --git a/athena/input/input_manager_impl.cc b/athena/input/input_manager_impl.cc
index 3d1c803783..b0b11a9e39 100644
--- a/athena/input/input_manager_impl.cc
+++ b/athena/input/input_manager_impl.cc
@@ -8,6 +8,7 @@
 #include "base/logging.h"
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/env.h"
+#include "ui/aura/window.h"
 #include "ui/events/event_target.h"
 
 namespace athena {
@@ -36,7 +37,7 @@ class InputManagerImpl : public InputManager,
   // Overridden from aura::client::EventClient:
   virtual bool CanProcessEventsWithinSubtree(
       const aura::Window* window) const OVERRIDE {
-    return true;
+    return window && !window->ignore_events();
   }
   virtual ui::EventTarget* GetToplevelEventTarget() OVERRIDE { return this; }
 
@@ -53,7 +54,8 @@ class InputManagerImpl : public InputManager,
 };
 
 InputManagerImpl::InputManagerImpl()
-    : accelerator_manager_(new AcceleratorManagerImpl) {
+    : accelerator_manager_(
+          AcceleratorManagerImpl::CreateGlobalAcceleratorManager()) {
   DCHECK(!instance);
   instance = this;
 }
diff --git a/athena/input/public/accelerator_manager.h b/athena/input/public/accelerator_manager.h
index e0a1ad447b..b572c50f75 100644
--- a/athena/input/public/accelerator_manager.h
+++ b/athena/input/public/accelerator_manager.h
@@ -6,12 +6,17 @@
 #define ATHENA_INPUT_PUBLIC_ACCELERATOR_MANAGER_H_
 
 #include "athena/athena_export.h"
+#include "base/memory/scoped_ptr.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 
 namespace ui {
 class Accelerator;
 }
 
+namespace views {
+class FocusManager;
+}
+
 namespace athena {
 
 enum TriggerEvent {
@@ -53,18 +58,32 @@ class ATHENA_EXPORT AcceleratorHandler {
                                   const ui::Accelerator& accelerator) = 0;
 };
 
-class AcceleratorManager {
+class ATHENA_EXPORT AcceleratorManager {
  public:
+  // Returns an AccelerarManager for global acelerators.
+  static AcceleratorManager* Get();
+
+  // Creates an AcceleratorManager for application windows that
+  // define their own accelerators.
+  static scoped_ptr<AcceleratorManager> CreateForFocusManager(
+      views::FocusManager* focus_manager);
+
   virtual ~AcceleratorManager() {}
 
+  // Tells if the accelerator is registered with the given flag.  If
+  // flags is AF_NONE, it simply tells if the accelerator is
+  // registered with any flags.
+  virtual bool IsRegistered(const ui::Accelerator& accelerator,
+                            int flags) const = 0;
+
   // Register accelerators and its handler that will be invoked when
   // one of accelerator is fired.
   virtual void RegisterAccelerators(const AcceleratorData accelerators[],
                                     size_t num_accelerators,
                                     AcceleratorHandler* handler) = 0;
 
-  // Enables accelerators that has a AF_DEBUG flag.
-  virtual void EnableDebugAccelerators() = 0;
+  // Enables/Disables accelerators that has a AF_DEBUG flag.
+  virtual void SetDebugAcceleratorsEnabled(bool enabled) = 0;
 };
 
 }  // namespace athena