Ensure that menus put in Chrome ASH on Windows 8 are operatable using the keyboard.

ui/aura/remote_root_window_host_win.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/aura/remote_root_window_host_win.h"
 
 #include <windows.h>
 
 #include <algorithm>
 
@@ skipping 11 matching lines @@
 
 namespace aura {
 
 namespace {
 
 const char* kRootWindowHostWinKey = "__AURA_REMOTE_ROOT_WINDOW_HOST_WIN__";
 
 // The touch id to be used for touch events coming in from Windows Ash.
 const int kRemoteWindowTouchId = 10;
 
+// Sets the keystate for the virtual key passed in to down or up.
+void SetKeyState(uint8* key_states, bool key_down, uint32 virtual_key_code) {
+  DCHECK(key_states);
+
+  if (key_down)
+    key_states[virtual_key_code] |= 0x80;
+  else
+    key_states[virtual_key_code] &= 0x7F;
+}
+
+// Sets the keyboard states for the Shift/Control/Alt/Caps lock keys.
+void SetVirtualKeyStates(uint32 flags) {
+  uint8 keyboard_state[256] = {0};
+  ::GetKeyboardState(keyboard_state);
+
+  SetKeyState(keyboard_state, !!(flags & ui::EF_SHIFT_DOWN), VK_SHIFT);
+  SetKeyState(keyboard_state, !!(flags & ui::EF_CONTROL_DOWN), VK_CONTROL);
+  SetKeyState(keyboard_state, !!(flags & ui::EF_ALT_DOWN), VK_MENU);
+  SetKeyState(keyboard_state, !!(flags & ui::EF_CAPS_LOCK_DOWN), VK_CAPITAL);
+
+  ::SetKeyboardState(keyboard_state);
+}
+
 }  // namespace
 
 void HandleOpenFile(
     const string16& title,
     const base::FilePath& default_path,
     const string16& filter,
     const OpenFileCompletion& callback) {
   DCHECK(aura::RemoteRootWindowHostWin::Instance());
   aura::RemoteRootWindowHostWin::Instance()->HandleOpenFile(title,
                                                             default_path,
@@ skipping 268 matching lines @@
   } else {
     mouse_event.SetClickCount(1);
     delegate_->OnHostMouseEvent(&mouse_event);
   }
 }
 
 void RemoteRootWindowHostWin::OnKeyDown(uint32 vkey,
                                         uint32 repeat_count,
                                         uint32 scan_code,
                                         uint32 flags) {
-  ui::KeyEvent event(ui::ET_KEY_PRESSED,
-                     ui::KeyboardCodeForWindowsKeyCode(vkey),
-                     flags,
-                     false);
-  delegate_->OnHostKeyEvent(&event);
+  DispatchKeyboardMessage(ui::ET_KEY_PRESSED, vkey, repeat_count, scan_code,
+                          flags, false);
 }
 
 void RemoteRootWindowHostWin::OnKeyUp(uint32 vkey,
                                       uint32 repeat_count,
                                       uint32 scan_code,
                                       uint32 flags) {
-  ui::KeyEvent event(ui::ET_KEY_RELEASED,
-                     ui::KeyboardCodeForWindowsKeyCode(vkey),
-                     flags,
-                     false);
-  delegate_->OnHostKeyEvent(&event);
+  DispatchKeyboardMessage(ui::ET_KEY_RELEASED, vkey, repeat_count, scan_code,
+                          flags, false);
 }
 
 void RemoteRootWindowHostWin::OnChar(uint32 key_code,
                                      uint32 repeat_count,
                                      uint32 scan_code,
                                      uint32 flags) {
-  ui::KeyEvent event(ui::ET_KEY_PRESSED,
-                     ui::KeyboardCodeForWindowsKeyCode(key_code),
-                     flags,
-                     true);
-  delegate_->OnHostKeyEvent(&event);
+  DispatchKeyboardMessage(ui::ET_KEY_PRESSED, key_code, repeat_count,
+                          scan_code, flags, true);
 }
 
 void RemoteRootWindowHostWin::OnVisibilityChanged(bool visible) {
   if (visible)
     delegate_->OnHostActivated();
 }
 
 void RemoteRootWindowHostWin::OnTouchDown(int32 x, int32 y, uint64 timestamp) {
   ui::TouchEvent event(ui::ET_TOUCH_PRESSED,
                        gfx::Point(x, y),
@@ skipping 41 matching lines @@
 
 void RemoteRootWindowHostWin::OnMultiFileOpenDone(
     bool success,
     const std::vector<base::FilePath>& files) {
   if (success) {
     multi_file_open_completion_callback_.Run(files, NULL);
   }
   multi_file_open_completion_callback_.Reset();
 }
 
+void RemoteRootWindowHostWin::DispatchKeyboardMessage(ui::EventType type,
+                                                      uint32 vkey,
+                                                      uint32 repeat_count,
+                                                      uint32 scan_code,
+                                                      uint32 flags,
+                                                      bool is_character) {
+  if (MessageLoop::current()->IsNested()) {
+    SetVirtualKeyStates(flags);
+
+    uint32 message = is_character ? WM_CHAR :
+        (type == ui::ET_KEY_PRESSED ? WM_KEYDOWN : WM_KEYUP);
+    ::PostThreadMessage(::GetCurrentThreadId(),
+                        message,
+                        vkey,
+                        repeat_count | scan_code >> 15);
+  } else {
+    ui::KeyEvent event(type,
+                       ui::KeyboardCodeForWindowsKeyCode(vkey),
+                       flags,
+                       is_character);
+    delegate_->OnHostKeyEvent(&event);
+  }
+}
+
 }  // namespace aura