Remove support for Windows-style keycodes.

remoting/host/event_executor_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 "remoting/host/event_executor.h"
 
 #include <windows.h>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 31 matching lines @@
   // InputStub interface.
   virtual void InjectKeyEvent(const KeyEvent& event) OVERRIDE;
   virtual void InjectMouseEvent(const MouseEvent& event) OVERRIDE;
 
   // EventExecutor interface.
   virtual void OnSessionStarted(
       scoped_ptr<protocol::ClipboardStub> client_clipboard) OVERRIDE;
   virtual void OnSessionFinished() OVERRIDE;
 
  private:
-  HKL GetForegroundKeyboardLayout();
   void HandleKey(const KeyEvent& event);
   void HandleMouse(const MouseEvent& event);
 
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
   scoped_ptr<Clipboard> clipboard_;
 
   DISALLOW_COPY_AND_ASSIGN(EventExecutorWin);
 };
 
@@ skipping 61 matching lines @@
     ui_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&EventExecutorWin::OnSessionFinished,
                    base::Unretained(this)));
     return;
   }
 
   clipboard_->Stop();
 }
 
-HKL EventExecutorWin::GetForegroundKeyboardLayout() {
-  HKL layout = 0;
-
-  // Can return NULL if a window is losing focus.
-  HWND foreground = GetForegroundWindow();
-  if (foreground) {
-    // Can return 0 if the window no longer exists.
-    DWORD thread_id = GetWindowThreadProcessId(foreground, 0);
-    if (thread_id) {
-      // Can return 0 if the thread no longer exists, or if we're
-      // running on Windows Vista and the window is a command-prompt.
-      layout = GetKeyboardLayout(thread_id);
-    }
-  }
-
-  // If we couldn't determine a layout then use the system default.
-  if (!layout) {
-    SystemParametersInfo(SPI_GETDEFAULTINPUTLANG, 0, &layout, 0);
-  }
-
-  return layout;
-}
-
 void EventExecutorWin::HandleKey(const KeyEvent& event) {
   // HostEventDispatcher should filter events missing the pressed field.
   DCHECK(event.has_pressed());
+  DCHECK(event.has_usb_keycode());
 
   // Reset the system idle suspend timeout.
   SetThreadExecutionState(ES_SYSTEM_REQUIRED);
 
-  // The mapping between scancodes and VKEY values depends on the foreground
-  // window's current keyboard layout.
-  HKL layout = GetForegroundKeyboardLayout();
-
   // Populate the a Windows INPUT structure for the event.
   INPUT input;
   memset(&input, 0, sizeof(input));
   input.type = INPUT_KEYBOARD;
   input.ki.time = 0;
-  input.ki.dwFlags = event.pressed() ? 0 : KEYEVENTF_KEYUP;
+  input.ki.dwFlags = KEYEVENTF_SCANCODE;
+  if (!event.pressed())
+    input.ki.dwFlags |= KEYEVENTF_KEYUP;
 
-  int scancode = kInvalidKeycode;
-  if (event.has_usb_keycode()) {
-    // If the event contains a USB-style code, map to a Windows scancode, and
-    // set a flag to have Windows look up the corresponding VK code.
-    input.ki.dwFlags |= KEYEVENTF_SCANCODE;
-    scancode = UsbKeycodeToNativeKeycode(event.usb_keycode());
-    VLOG(3) << "Converting USB keycode: " << std::hex << event.usb_keycode()
-            << " to scancode: " << scancode << std::dec;
-  } else {
-    // If the event provides only a VKEY then use it, and map to the scancode.
-    input.ki.wVk = event.keycode();
-    scancode = MapVirtualKeyEx(event.keycode(), MAPVK_VK_TO_VSC_EX, layout);
-    VLOG(3) << "Converting VKEY: " << std::hex << event.keycode()
-            << " to scancode: " << scancode << std::dec;
-  }
+  int scancode = UsbKeycodeToNativeKeycode(event.usb_keycode());
+  VLOG(3) << "Converting USB keycode: " << std::hex << event.usb_keycode()
+          << " to scancode: " << scancode << std::dec;
 
-  // Ignore events with no VK- or USB-keycode, or which can't be mapped.
+  // Ignore events which can't be mapped.
   if (scancode == kInvalidKeycode)
     return;
 
   // Windows scancodes are only 8-bit, so store the low-order byte into the
   // event and set the extended flag if any high-order bits are set. The only
   // high-order values we should see are 0xE0 or 0xE1. The extended bit usually
   // distinguishes keys with the same meaning, e.g. left & right shift.
   input.ki.wScan = scancode & 0xFF;
   if ((scancode & 0xFF00) != 0x0000) {
     input.ki.dwFlags |= KEYEVENTF_EXTENDEDKEY;
@@ skipping 88 matching lines @@
 }  // namespace
 
 scoped_ptr<EventExecutor> EventExecutor::Create(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   return scoped_ptr<EventExecutor>(
       new EventExecutorWin(main_task_runner, ui_task_runner));
 }
 
 }  // namespace remoting