Switch from text insertion to key press and release events on the virtual k…

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/command_line.h"
 #include "base/logging.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/root_window.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ime/text_input_client.h"
+#include "ui/base/keycodes/keyboard_code_conversion.h"
 #include "ui/keyboard/keyboard_switches.h"
 
+namespace {
+
+const char kKeyPressed[] ="keyPressed";
+const char kKeyReleased[] = "keyReleased";
+
+const int kMinKeyCode = ui::VKEY_BACK;
+const int kMaxKeyCode = ui::VKEY_OEM_CLEAR;
+const int kMaxKeyChar = 0x7f;
+
+static bool initialized = false;
+static int unshifted_character_map[kMaxKeyChar];
+static int shifted_character_map[kMaxKeyChar];
+
+// Initializes mapping of characters to keycodes.
+void InitCharacterMapping() {
+  for (int i = kMinKeyCode; i <= kMaxKeyCode; i++) {
+      uint16 ch = ui::GetCharacterFromKeyCode(static_cast<ui::KeyboardCode>(i),

[bshe, 2013/07/25 15:33:05]

nit: indent is off here.

[kevers, 2013/07/26 00:53:30]

Fixed.

+                                              ui::EF_NONE);
+      if (ch > 0 && ch < kMaxKeyChar)
+        unshifted_character_map[ch] = i;
+      ch = ui::GetCharacterFromKeyCode(static_cast<ui::KeyboardCode>(i),
+                                       ui::EF_SHIFT_DOWN);
+      if (ch > 0 && ch < kMaxKeyChar)
+        shifted_character_map[ch] = i;
+  }
+  initialized = true;
+}
+
+// Creates a synthetic KeyEvent corresponding to a |char_code|. The KeyEvent
+// contains a keycode and modifier flags. The character code is also
+// explicitly set to enable key events for i18n characters not found on a
+// US-English keyboard.
+ui::KeyEvent CreateFabricatedKeyEvent(ui::EventType type, int char_code) {
+  if (!initialized)
+    InitCharacterMapping();
+
+  ui::KeyboardCode keyCode = ui::VKEY_UNKNOWN;
+  int flags = ui::EF_NONE;
+  if (char_code < kMaxKeyChar) {
+    int unshifted = unshifted_character_map[char_code];
+    if (unshifted > 0) {
+      keyCode = static_cast<ui::KeyboardCode>(unshifted);
+    } else {
+      int shifted = shifted_character_map[char_code];
+      if (shifted > 0) {
+         keyCode = static_cast<ui::KeyboardCode>(shifted);
+         flags = ui::EF_SHIFT_DOWN;
+      }
+    }
+  }
+  ui::KeyEvent event(type, keyCode, flags, false);
+  event.set_character(char_code);
+  event.set_unmodified_character(char_code);
+  return event;
+}
+
+}  // namespace
+
 namespace keyboard {
 
 bool IsKeyboardEnabled() {
   return CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableVirtualKeyboard);
 }
 
 bool InsertText(const base::string16& text, aura::RootWindow* root_window) {
   if (!root_window)
     return false;
 
   // Handle Backspace and Enter specially: using TextInputClient::InsertText is
   // very unreliable for these characters.
-  // TODO(bryeung): remove this code once virtual keyboards are able to send
+  // TODO(kevers): remove this code once virtual keyboards are able to send
   // these events directly via the Input Injection API.
   if (text.length() == 1) {
     ui::KeyboardCode code = ui::VKEY_UNKNOWN;
     if (text[0] == L'\n')
       code = ui::VKEY_RETURN;
     else if (text[0] == L'\b')
       code = ui::VKEY_BACK;
 
     if (code != ui::VKEY_UNKNOWN) {
       ui::KeyEvent press_event(ui::ET_KEY_PRESSED, code, 0, 0);
@@ skipping 13 matching lines @@
 
   ui::TextInputClient* tic = input_method->GetTextInputClient();
   if (!tic || tic->GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE)
     return false;
 
   tic->InsertText(text);
 
   return true;
 }
 
+bool DispatchKeyEvent(const std::string type,
+                      int char_code,
+                      aura::RootWindow* root_window) {
+  ui::EventType event_type = ui::ET_UNKNOWN;
+  if (type == kKeyPressed)
+    event_type = ui::ET_KEY_PRESSED;
+  else if (type == kKeyReleased)
+    event_type = ui::ET_KEY_RELEASED;
+  if (event_type == ui::ET_UNKNOWN)
+    return false;
+
+  ui::KeyEvent event = CreateFabricatedKeyEvent(event_type, char_code);
+  if (event.key_code() != ui::VKEY_UNKNOWN) {
+    root_window->AsRootWindowHostDelegate()->OnHostKeyEvent(&event);
+  } else if (event_type == ui::ET_KEY_RELEASED) {
+    // Though the KeyEvent has setters for unicode characters that are intended
+    // for use with a virtual keyboard, these values are ignored further down
+    // the pipeline, relying on the key code. The key code is 0 for most
+    // characters not found on a US-English keyboard (the assumed configuration
+    // for fabricated key events). Fall back on inserting raw text as a short-
+    // term measure.
+    // TODO(kevers): Fix handling of unicode characters to unify the code
+    // paths and fix use cases where raw injection fails.
+    base::string16 text;
+    base::char16 chars[] = {static_cast<char16>(char_code), 0};
+    text.append(chars);
+    return InsertText(text, root_window);
+  }
+  return true;
+}
+
 const GritResourceMap* GetKeyboardExtensionResources(size_t* size) {
   // This looks a lot like the contents of a resource map; however it is
   // necessary to have a custom path for the extension path, so the resource
   // map cannot be used directly.
   static const GritResourceMap kKeyboardResources[] = {
     {"keyboard/api_adapter.js", IDR_KEYBOARD_API_ADAPTER_JS},
     {"keyboard/constants.js", IDR_KEYBOARD_CONSTANTS_JS},
     {"keyboard/elements/kb-altkey.html", IDR_KEYBOARD_ELEMENTS_ALTKEY},
     {"keyboard/elements/kb-altkey-container.html",
         IDR_KEYBOARD_ELEMENTS_ALTKEY_CONTAINER},
@@ skipping 25 matching lines @@
     {"keyboard/main.css", IDR_KEYBOARD_MAIN_CSS},
     {"keyboard/polymer.min.js", IDR_KEYBOARD_POLYMER},
     {"keyboard/voice_input.js", IDR_KEYBOARD_VOICE_INPUT_JS},
   };
   static const size_t kKeyboardResourcesSize = arraysize(kKeyboardResources);
   *size = kKeyboardResourcesSize;
   return kKeyboardResources;
 }
 
 }  // namespace keyboard