Use DOM- rather than Windows-based key code for non-layout cases.

ui/keyboard/keyboard_util.cc

 // Copyright (c) 2013 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/keyboard/keyboard_util.h"
 
 #include <string>
 
+#include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string16.h"
 #include "grit/keyboard_resources.h"
 #include "grit/keyboard_resources_map.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/text_input_client.h"
 #include "ui/events/event_processor.h"
+#include "ui/events/event_utils.h"
+#include "ui/events/keycodes/dom3/dom_code.h"
+#include "ui/events/keycodes/dom3/dom_key.h"
 #include "ui/events/keycodes/dom4/keycode_converter.h"
+#include "ui/events/keycodes/keyboard_code_conversion.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_controller_proxy.h"
 #include "ui/keyboard/keyboard_switches.h"
 #include "url/gurl.h"
 
 namespace {
 
 const char kKeyDown[] ="keydown";
 const char kKeyUp[] = "keyup";
 
 void SendProcessKeyEvent(ui::EventType type,
                          aura::WindowTreeHost* host) {
-  ui::KeyEvent event(type, ui::VKEY_PROCESSKEY, ui::EF_NONE);
+  ui::KeyEvent event(type, ui::VKEY_PROCESSKEY, ui::DomCode::NONE, ui::EF_NONE,
+                     ui::DomKey::PROCESS, 0, ui::EventTimeForNow());
   event.SetTranslated(true);
   ui::EventDispatchDetails details =
       host->event_processor()->OnEventFromSource(&event);
   CHECK(!details.dispatcher_destroyed);
 }
 
 base::LazyInstance<base::Time> g_keyboard_load_time_start =
     LAZY_INSTANCE_INITIALIZER;
 
 bool g_accessibility_keyboard_enabled = false;
@@ skipping 139 matching lines @@
 
 // TODO(varunjain): It would be cleaner to have something in the
 // ui::TextInputClient interface, say MoveCaretInDirection(). The code in
 // here would get the ui::InputMethod from the root_window, and the
 // ui::TextInputClient from that (see above in InsertText()).
 bool MoveCursor(int swipe_direction,
                 int modifier_flags,
                 aura::WindowTreeHost* host) {
   if (!host)
     return false;
-  ui::KeyboardCode codex = ui::VKEY_UNKNOWN;
-  ui::KeyboardCode codey = ui::VKEY_UNKNOWN;
+  ui::DomCode domcodex = ui::DomCode::NONE;
+  ui::DomCode domcodey = ui::DomCode::NONE;
   if (swipe_direction & kCursorMoveRight)
-    codex = ui::VKEY_RIGHT;
+    domcodex = ui::DomCode::ARROW_RIGHT;
   else if (swipe_direction & kCursorMoveLeft)
-    codex = ui::VKEY_LEFT;
+    domcodex = ui::DomCode::ARROW_LEFT;
 
   if (swipe_direction & kCursorMoveUp)
-    codey = ui::VKEY_UP;
+    domcodey = ui::DomCode::ARROW_UP;
   else if (swipe_direction & kCursorMoveDown)
-    codey = ui::VKEY_DOWN;
+    domcodey = ui::DomCode::ARROW_DOWN;
 
   // First deal with the x movement.
-  if (codex != ui::VKEY_UNKNOWN) {
-    ui::KeyEvent press_event(ui::ET_KEY_PRESSED, codex, modifier_flags);
+  if (domcodex != ui::DomCode::NONE) {
+    ui::KeyboardCode codex = ui::VKEY_UNKNOWN;
+    ui::DomKey domkeyx = ui::DomKey::NONE;
+    base::char16 cx;
+    ignore_result(DomCodeToUsLayoutMeaning(domcodex, ui::EF_NONE, &domkeyx,
+                                           &cx, &codex));
+    ui::KeyEvent press_event(ui::ET_KEY_PRESSED, codex, domcodex,
+                             modifier_flags, domkeyx, cx,
+                             ui::EventTimeForNow());
     ui::EventDispatchDetails details =
         host->event_processor()->OnEventFromSource(&press_event);
     CHECK(!details.dispatcher_destroyed);
-    ui::KeyEvent release_event(ui::ET_KEY_RELEASED, codex, modifier_flags);
+    ui::KeyEvent release_event(ui::ET_KEY_RELEASED, codex, domcodex,
+                               modifier_flags, domkeyx, cx,
+                               ui::EventTimeForNow());
     details = host->event_processor()->OnEventFromSource(&release_event);
     CHECK(!details.dispatcher_destroyed);
   }
 
   // Then deal with the y movement.
-  if (codey != ui::VKEY_UNKNOWN) {
-    ui::KeyEvent press_event(ui::ET_KEY_PRESSED, codey, modifier_flags);
+  if (domcodey != ui::DomCode::NONE) {
+    ui::KeyboardCode codey = ui::VKEY_UNKNOWN;
+    ui::DomKey domkeyy = ui::DomKey::NONE;
+    base::char16 cy;
+    ignore_result(DomCodeToUsLayoutMeaning(domcodey, ui::EF_NONE, &domkeyy,
+                                           &cy, &codey));
+    ui::KeyEvent press_event(ui::ET_KEY_PRESSED, codey, domcodey,
+                             modifier_flags, domkeyy, cy,
+                             ui::EventTimeForNow());
     ui::EventDispatchDetails details =
         host->event_processor()->OnEventFromSource(&press_event);
     CHECK(!details.dispatcher_destroyed);
-    ui::KeyEvent release_event(ui::ET_KEY_RELEASED, codey, modifier_flags);
+    ui::KeyEvent release_event(ui::ET_KEY_RELEASED, codey, domcodey,
+                               modifier_flags, domkeyy, cy,
+                               ui::EventTimeForNow());
     details = host->event_processor()->OnEventFromSource(&release_event);
     CHECK(!details.dispatcher_destroyed);
   }

[sadrul, 2015/04/21 19:42:17]

Can lines 214:229 and 234:249 be moved to a separate function? (feel free to do
that in a separate CL)

[kpschoedel, 2015/04/21 19:53:15]

Yes. I'm still thinking about how best to express this as I work through this
set of CLs toward immutable KeyEvent (crbug.com/444045). There are both
layout-independent (like this) and layout-dependent cases of building a KeyEvent
starting from incomplete information, and I want to be sure the distinction is
clear at the call sites.

   return true;
 }
 
 bool SendKeyEvent(const std::string type,
                   int key_value,
                   int key_code,
                   std::string key_name,
                   int modifiers,
                   aura::WindowTreeHost* host) {
   ui::EventType event_type = ui::ET_UNKNOWN;
@@ skipping 30 matching lines @@
         // metric will be used to determine the error rate for the keyboard.
         UMA_HISTOGRAM_CUSTOM_COUNTS(
             "VirtualKeyboard.KeystrokesBetweenBackspaces",
             keys_seen, 1, 1000, 50);
         keys_seen = 0;
       } else {
         ++keys_seen;
       }
     }
 
+    ui::DomCode dom_code = ui::DomCode::NONE;
+    if (!key_name.empty())
+      dom_code = ui::KeycodeConverter::CodeStringToDomCode(key_name.c_str());
+    if (dom_code == ui::DomCode::NONE)
+      dom_code = ui::UsLayoutKeyboardCodeToDomCode(code);
+    CHECK(dom_code != ui::DomCode::NONE);
     ui::KeyEvent event(
         event_type,
         code,
-        ui::KeycodeConverter::CodeStringToDomCode(key_name.c_str()),
+        dom_code,
         modifiers);
     ui::EventDispatchDetails details =
         host->event_processor()->OnEventFromSource(&event);
     CHECK(!details.dispatcher_destroyed);
   }
   return true;
 }
 
 void MarkKeyboardLoadStarted() {
   if (!g_keyboard_load_time_start.Get().ToInternalValue())
@@ skipping 104 matching lines @@
 }
 
 void LogKeyboardControlEvent(KeyboardControlEvent event) {
   UMA_HISTOGRAM_ENUMERATION(
       "VirtualKeyboard.KeyboardControlEvent",
       event,
       keyboard::KEYBOARD_CONTROL_MAX);
 }
 
 }  // namespace keyboard