ESC accelerator and consistent overview mode for Athena homecard

athena/input/accelerator_manager_impl.cc

 // Copyright 2014 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 "athena/input/accelerator_manager_impl.h"
 
 #include "athena/input/public/input_manager.h"
 #include "athena/util/switches.h"
 #include "base/logging.h"
 #include "ui/aura/window.h"
@@ skipping 11 matching lines @@
 
 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 void Unregister(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
 // wm::NestedAcceleratorController while accelerators in normal case are
 // handled by wm::AcceleratorFilter. These delegates act bridges in these
@@ skipping 93 matching lines @@
 
 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(
+    ui_accelerator_manager_->Register(
         accelerator, ui::AcceleratorManager::kNormalPriority, target);
   }
 
+  virtual void Unregister(const ui::Accelerator& accelerator,
+                          ui::AcceleratorTarget* target) OVERRIDE {
+    ui_accelerator_manager_->Unregister(accelerator, 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(
+    focus_manager_->RegisterAccelerator(
         accelerator, ui::AcceleratorManager::kNormalPriority, target);
   }
 
+  virtual void Unregister(const ui::Accelerator& accelerator,
+                          ui::AcceleratorTarget* target) OVERRIDE {
+    focus_manager_->UnregisterAccelerator(accelerator, 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);
   }
 
@@ skipping 131 matching lines @@
                            ? ui::ET_KEY_PRESSED
                            : ui::ET_KEY_RELEASED);
   accelerator_wrapper_->Register(accelerator, this);
   accelerators_.insert(
       std::make_pair(accelerator,
                      InternalData(accelerator_data.command_id,
                                   handler,
                                   accelerator_data.accelerator_flags)));
 }
 
+void AcceleratorManagerImpl::UnregisterAccelerator(
+    const AcceleratorData& accelerator_data,
+    AcceleratorHandler* handler) {
+  ui::Accelerator accelerator(accelerator_data.keycode,
+                              accelerator_data.keyevent_flags);
+  accelerator.set_type(accelerator_data.trigger_event == TRIGGER_ON_PRESS
+                           ? ui::ET_KEY_PRESSED
+                           : ui::ET_KEY_RELEASED);

[Greg Levin, 2014/09/25 18:38:50]

Fix indenting

[Greg Levin, 2014/10/02 21:56:09]

Done.

+  accelerator_wrapper_->Unregister(accelerator, this);
+  std::map<ui::Accelerator, InternalData>::const_iterator iter =
+        accelerators_.find(accelerator);
+  if (iter != accelerators_.end())
+    accelerators_.erase(iter);
+}
+
 // 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