Take GetCharacterFromKeyCode() out behind the barn.

ui/events/test/event_generator.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 "ui/events/test/event_generator.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 522 matching lines @@
   if (window_context)
     current_location_ = delegate()->CenterOfWindow(window_context);
   current_target_ = delegate()->GetTargetAt(current_location_);
 }
 
 void EventGenerator::DispatchKeyEvent(bool is_press,
                                       ui::KeyboardCode key_code,
                                       int flags) {
 #if defined(OS_WIN)
   UINT key_press = WM_KEYDOWN;
-  uint16 character = ui::GetCharacterFromKeyCode(key_code, flags);
+  uint16 character = ui::DomCodeToUsLayoutCharacter(
+      ui::UsLayoutKeyboardCodeToDomCode(key_code), flags);

[Wez, 2015/04/21 22:08:46]

This changes the behaviour slightly - e.g. the top-level alpha key on a PC
keyboard will generate Q (US English) or A (French layout) with the old code,
since it's based on the VKEY, while this implementation will always generate Q.

Is that an issue? More generally, is the fact that this code path is US English
only an issue right now?

[kpschoedel, 2015/04/21 22:36:38]

GetCharacterFromKeyCode() was a hard-coded US layout as well.
|DomCodeToUsLayoutCharacter(UsLayoutKeyboardCodeToDomCode())| should always
return the same character as |GetCharacterFromKeyCode()| did, but I'll write a
temporary test to verify that before landing this change.

   if (is_press && character) {
     MSG native_event = { NULL, WM_KEYDOWN, key_code, 0 };
     TestKeyEvent keyev(native_event, flags);
     Dispatch(&keyev);
     // On Windows, WM_KEYDOWN event is followed by WM_CHAR with a character
     // if the key event cooresponds to a real character.
     key_press = WM_CHAR;
     key_code = static_cast<ui::KeyboardCode>(character);
   }
   MSG native_event =
       { NULL, (is_press ? key_press : WM_KEYUP), key_code, 0 };
   native_event.time = Now().InMicroseconds();
   TestKeyEvent keyev(native_event, flags);

[Wez, 2015/04/21 22:08:46]

nit: Hadn't noticed this before... should we be (ab)using TestKeyEvent in this
way?

nit: Also, it looks like this chunk of code could be simplified to remove
key_press, and to avoid overwriting key_code, pretty easily, to make things more
readable.

[kpschoedel, 2015/04/21 22:36:38]

I've planned to visit this for crbug.com/444045

 #elif defined(USE_X11)
   ui::ScopedXI2Event xevent;
   xevent.InitKeyEvent(is_press ? ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED,
                       key_code,
                       flags);
   static_cast<XEvent*>(xevent)->xkey.time = Now().InMicroseconds();
   ui::KeyEvent keyev(xevent);
 #else
   ui::EventType type = is_press ? ui::ET_KEY_PRESSED : ui::ET_KEY_RELEASED;
   ui::KeyEvent keyev(type, key_code, flags);
@@ skipping 91 matching lines @@
   return default_delegate;
 }
 
 EventGeneratorDelegate* EventGenerator::delegate() {
   return const_cast<EventGeneratorDelegate*>(
       const_cast<const EventGenerator*>(this)->delegate());
 }
 
 }  // namespace test
 }  // namespace ui