Handle all accelerators in focus manager when focused view doesn't want to ta...

chrome/views/focus/focus_manager.cc

 // Copyright (c) 2006-2008 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 <algorithm>
 
 #include "base/histogram.h"
 #include "base/logging.h"
 #include "base/win_util.h"
 #include "chrome/browser/renderer_host/render_widget_host_view_win.h"
@@ skipping 289 matching lines @@
           repeat_count, flags))) {
     // This should not be processed as an accelerator.
     return true;
   }
 
   // Process keyboard accelerators.
   // We process accelerators here as we have no way of knowing if a HWND has
   // really processed a key event. If the key combination matches an
   // accelerator, the accelerator is triggered, otherwise we forward the
   // event to the HWND.
-  int modifiers = 0;
-  if (win_util::IsShiftPressed())
-    modifiers |= Event::EF_SHIFT_DOWN;
-  if (win_util::IsCtrlPressed())
-    modifiers |= Event::EF_CONTROL_DOWN;
-  if (win_util::IsAltPressed())
-    modifiers |= Event::EF_ALT_DOWN;
   Accelerator accelerator(Accelerator(static_cast<int>(virtual_key_code),
                                       win_util::IsShiftPressed(),
                                       win_util::IsCtrlPressed(),
                                       win_util::IsAltPressed()));
-  if (ProcessAccelerator(accelerator, true)) {
+  if (ProcessAccelerator(accelerator)) {
     // If a shortcut was activated for this keydown message, do not
     // propagate the message further.
     return false;
   }
   return true;
 }
 
 bool FocusManager::OnPostActivate(HWND window,
                                   int activation_state,
                                   int minimized_state) {
@@ skipping 310 matching lines @@
 void FocusManager::UnregisterAccelerators(AcceleratorTarget* target) {
   for (AcceleratorMap::iterator iter = accelerators_.begin();
        iter != accelerators_.end();) {
     if (iter->second == target)
       accelerators_.erase(iter++);
     else
       ++iter;
   }
 }
 
-bool FocusManager::ProcessAccelerator(const Accelerator& accelerator,
-                                      bool prioritary_accelerators_only) {
-  if (!prioritary_accelerators_only ||
-      accelerator.IsCtrlDown() || accelerator.IsAltDown() ||
-      accelerator.GetKeyCode() == VK_ESCAPE ||
-      accelerator.GetKeyCode() == VK_RETURN ||
-      (accelerator.GetKeyCode() >= VK_F1 &&
-          accelerator.GetKeyCode() <= VK_F24) ||
-      (accelerator.GetKeyCode() >= VK_BROWSER_BACK &&
-          accelerator.GetKeyCode() <= VK_BROWSER_HOME)) {
-    FocusManager* focus_manager = this;
-    do {
-      AcceleratorTarget* target =
-          focus_manager->GetTargetForAccelerator(accelerator);
-      if (target) {
-        // If there is focused view, we give it a chance to process that
-        // accelerator.
-        if (!focused_view_ ||
-            !focused_view_->OverrideAccelerator(accelerator)) {
-          if (target->AcceleratorPressed(accelerator))
-            return true;
-        }
+bool FocusManager::ProcessAccelerator(const Accelerator& accelerator) {
+  FocusManager* focus_manager = this;
+  do {
+    AcceleratorTarget* target =
+        focus_manager->GetTargetForAccelerator(accelerator);
+    if (target) {
+      // If there is focused view, we give it a chance to process that
+      // accelerator.
+      if (!focused_view_ ||
+          !focused_view_->OverrideAccelerator(accelerator)) {
+        if (target->AcceleratorPressed(accelerator))
+          return true;
       }
+    }
 
-      // When dealing with child windows that have their own FocusManager (such
-      // as ConstrainedWindow), we still want the parent FocusManager to process
-      // the accelerator if the child window did not process it.
-      focus_manager = focus_manager->GetParentFocusManager();
-    } while (focus_manager);
-  }
+    // When dealing with child windows that have their own FocusManager (such
+    // as ConstrainedWindow), we still want the parent FocusManager to process
+    // the accelerator if the child window did not process it.
+    focus_manager = focus_manager->GetParentFocusManager();
+  } while (focus_manager);
   return false;
 }
 
 AcceleratorTarget* FocusManager::GetTargetForAccelerator(
     const Accelerator& accelerator) const {
   AcceleratorMap::const_iterator iter = accelerators_.find(accelerator);
   if (iter != accelerators_.end())
     return iter->second;
   return NULL;
 }
@@ skipping 36 matching lines @@
       std::find(focus_change_listeners_.begin(), focus_change_listeners_.end(),
                 listener);
   if (place == focus_change_listeners_.end()) {
     NOTREACHED() << "Removing a listener that isn't registered.";
     return;
   }
   focus_change_listeners_.erase(place);
 }
 
 }  // namespace views