Remove obsolete code that handles menu key release for chromeos

ui/views/focus/focus_manager.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/focus/focus_manager.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
@@ skipping 12 matching lines @@
 namespace views {
 
 bool FocusManager::shortcut_handling_suspended_ = false;
 
 FocusManager::FocusManager(Widget* widget, FocusManagerDelegate* delegate)
     : widget_(widget),
       delegate_(delegate),
       focused_view_(NULL),
       accelerator_manager_(new ui::AcceleratorManager),
       focus_change_reason_(kReasonDirectFocusChange),
-#if defined(USE_X11)
-      should_handle_menu_key_release_(false),
-#endif
       is_changing_focus_(false) {
   DCHECK(widget_);
   stored_focused_view_storage_id_ =
       ViewStorage::GetInstance()->CreateStorageID();
 }
 
 FocusManager::~FocusManager() {
 }
 
 bool FocusManager::OnKeyEvent(const ui::KeyEvent& event) {
   const int key_code = event.key_code();
 
-#if defined(USE_X11)
-  // TODO(ben): beng believes that this should be done in
-  // RootWindowHosLinux for aura/linux.
-
-  // Always reset |should_handle_menu_key_release_| unless we are handling a
-  // VKEY_MENU key release event. It ensures that VKEY_MENU accelerator can only
-  // be activated when handling a VKEY_MENU key release event which is preceded
-  // by an un-handled VKEY_MENU key press event.
-  if (key_code != ui::VKEY_MENU || event.type() != ui::ET_KEY_RELEASED)
-    should_handle_menu_key_release_ = false;
-
-  if (event.type() == ui::ET_KEY_PRESSED) {
-    // VKEY_MENU is triggered by key release event.
-    // FocusManager::OnKeyEvent() returns false when the key has been consumed.
-    if ((key_code == ui::VKEY_MENU) &&
-        (event.flags() & ~ui::EF_ALT_DOWN) == 0) {
-      should_handle_menu_key_release_ = true;
-      return false;
-    }
-    // Pass through to the rest of OnKeyEvent.
-  } else if (key_code == ui::VKEY_MENU && should_handle_menu_key_release_ &&
-             (event.flags() & ~ui::EF_ALT_DOWN) == 0) {
-    // Trigger VKEY_MENU when only this key is pressed and released, and both
-    // press and release events are not handled by others.
-    ui::Accelerator accelerator(ui::VKEY_MENU, ui::EF_NONE);
-    return ProcessAccelerator(accelerator);
-  } else if (event.type() != ui::ET_KEY_RELEASED) {
-    return false;
-  }
-#else
   if (event.type() != ui::ET_KEY_PRESSED && event.type() != ui::ET_KEY_RELEASED)
     return false;
-#endif
 
   if (shortcut_handling_suspended())
     return true;
 
   int modifiers = ui::EF_NONE;
   if (event.IsShiftDown())
     modifiers |= ui::EF_SHIFT_DOWN;
   if (event.IsControlDown())
     modifiers |= ui::EF_CONTROL_DOWN;
   if (event.IsAltDown())
@@ skipping 210 matching lines @@
   FOR_EACH_OBSERVER(FocusChangeListener, focus_change_listeners_,
                     OnDidChangeFocus(old_focused_view, focused_view_));
 }
 
 void FocusManager::ClearFocus() {
   SetFocusedView(NULL);
   ClearNativeFocus();
 }
 
 void FocusManager::StoreFocusedView() {
-#if defined(USE_X11)
-  // Forget menu key state when the window lost focus.
-  should_handle_menu_key_release_ = false;
-#endif
   ViewStorage* view_storage = ViewStorage::GetInstance();
   if (!view_storage) {
     // This should never happen but bug 981648 seems to indicate it could.
     NOTREACHED();
     return;
   }
 
   // TODO(jcivelli): when a TabContents containing a popup is closed, the focus
   // is stored twice causing an assert. We should find a better alternative than
   // removing the view from the storage explicitly.
@@ skipping 13 matching lines @@
     // is not changing due to a user-initiated event.
     AutoNativeNotificationDisabler local_notification_disabler;
     ClearFocus();
   }
 
   if (v)
     v->SchedulePaint();  // Remove focus border.
 }
 
 void FocusManager::RestoreFocusedView() {
-#if defined(USE_X11)
-  DCHECK(!should_handle_menu_key_release_);
-#endif
   ViewStorage* view_storage = ViewStorage::GetInstance();
   if (!view_storage) {
     // This should never happen but bug 981648 seems to indicate it could.
     NOTREACHED();
     return;
   }
 
   View* view = view_storage->RetrieveView(stored_focused_view_storage_id_);
   if (view) {
     if (ContainsView(view)) {
@@ skipping 76 matching lines @@
 }
 
 bool FocusManager::ProcessAccelerator(const ui::Accelerator& accelerator) {
   if (accelerator_manager_->Process(accelerator))
     return true;
   if (delegate_.get())
     return delegate_->ProcessAccelerator(accelerator);
   return false;
 }
 
-void FocusManager::MaybeResetMenuKeyState(const ui::KeyEvent& key) {
-#if defined(USE_X11)
-  // Always reset |should_handle_menu_key_release_| unless we are handling a
-  // VKEY_MENU key release event. It ensures that VKEY_MENU accelerator can only
-  // be activated when handling a VKEY_MENU key release event which is preceded
-  // by an unhandled VKEY_MENU key press event. See also HandleKeyboardEvent().
-  if (key.key_code() != ui::VKEY_MENU || key.type() != ui::ET_KEY_RELEASED)
-    should_handle_menu_key_release_ = false;
-#endif
-}
-
 ui::AcceleratorTarget* FocusManager::GetCurrentTargetForAccelerator(
     const ui::Accelerator& accelerator) const {
   ui::AcceleratorTarget* target =
       accelerator_manager_->GetCurrentTarget(accelerator);
   if (!target && delegate_.get())
     target = delegate_->GetCurrentTargetForAccelerator(accelerator);
   return target;
 }
 
 bool FocusManager::HasPriorityHandler(
@@ skipping 17 matching lines @@
 
 void FocusManager::AddFocusChangeListener(FocusChangeListener* listener) {
   focus_change_listeners_.AddObserver(listener);
 }
 
 void FocusManager::RemoveFocusChangeListener(FocusChangeListener* listener) {
   focus_change_listeners_.RemoveObserver(listener);
 }
 
 }  // namespace views