DOM Level 3 .code and .key value enumerations.

ui/events/keycodes/dom4/keycode_converter.cc

 // Copyright 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/events/keycodes/dom4/keycode_converter.h"
 
+#include "base/logging.h"
+#include "ui/events/keycodes/dom3/domcode.h"
+#include "ui/events/keycodes/dom3/domkey.h"
+
 namespace ui {
 
 namespace {
 
+template<typename T>
+struct DomKeyCodeEntry {
+  const char *string;
+  T enumeration;
+};
+
+#if 1  // Work around #include order check to include generated tables.
+#include "ui/events/keycodes/dom3/domcode_string.h"
+#include "ui/events/keycodes/dom3/domcode_table.h"
+#include "ui/events/keycodes/dom3/domkey_string.h"
+#include "ui/events/keycodes/dom3/domkey_table.h"
+#endif
+
 #if defined(OS_WIN)
 #define USB_KEYMAP(usb, xkb, win, mac, code) {usb, win, code}
 #elif defined(OS_LINUX)
 #define USB_KEYMAP(usb, xkb, win, mac, code) {usb, xkb, code}
 #elif defined(OS_MACOSX)
 #define USB_KEYMAP(usb, xkb, win, mac, code) {usb, mac, code}
 #else
 #define USB_KEYMAP(usb, xkb, win, mac, code) {usb, 0, code}
 #endif
-#include "ui/events/keycodes/dom4/keycode_converter_data.h"
+#include "ui/events/keycodes/dom3/native_code_data.h"
 
 const size_t kKeycodeMapEntries = arraysize(usb_keycode_map);
+const size_t kDomCodeStringTableEntries = arraysize(dom_code_string);
+const size_t kDomCodeTableEntries = arraysize(dom_code_table);
+const size_t kDomKeyStringTableEntries = arraysize(dom_key_string);
+const size_t kDomKeyTableEntries = arraysize(dom_key_table);
 
 }  // namespace
 
 // static
 size_t KeycodeConverter::NumKeycodeMapEntriesForTest() {
   return kKeycodeMapEntries;
 }
 
 // static
 const KeycodeMapEntry* KeycodeConverter::GetKeycodeMapForTest() {
   return &usb_keycode_map[0];
 }
 
 // static
+size_t KeycodeConverter::NumDomCodeStringEntriesForTest() {
+  return kDomCodeStringTableEntries;
+}
+
+// static
+const char* const* KeycodeConverter::DomCodeStringTableForTest() {
+  return dom_code_string;
+}
+
+// static
+size_t KeycodeConverter::NumDomKeyStringEntriesForTest() {
+  return kDomKeyStringTableEntries;
+}
+
+// static
+const char* const* KeycodeConverter::DomKeyStringTableForTest() {
+  return dom_key_string;
+}
+
+// static
 uint16_t KeycodeConverter::InvalidNativeKeycode() {
   return usb_keycode_map[0].native_keycode;
 }
 
 // static
 const char* KeycodeConverter::InvalidKeyboardEventCode() {
-  return "Unidentified";
+  return dom_code_string[static_cast<size_t>(ui::DomCode::UNIDENTIFIED)];
+}
+
+// static
+const char* KeycodeConverter::DomCodeToCodeString(DomCode dom_code) {
+  size_t code = static_cast<size_t>(dom_code);
+  DCHECK_LT(code, kDomCodeStringTableEntries);
+  DCHECK_NE(dom_code_string[code], static_cast<const char*>(nullptr));
+  return dom_code_string[code];
+}
+
+// static
+DomCode KeycodeConverter::CodeStringToDomCode(const char* code) {
+  if (code) {
+    for (size_t i = 0; i < kDomCodeTableEntries; ++i) {
+      if (strcmp(code, dom_code_table[i].string) == 0)
+        return dom_code_table[i].enumeration;
+    }
+  }
+  return DomCode::NONE;
+}
+
+// static
+DomCode KeycodeConverter::NativeKeycodeToDomCode(uint16_t native_keycode) {
+  for (size_t i = 0; i < kKeycodeMapEntries; ++i) {
+    if (usb_keycode_map[i].native_keycode == native_keycode)
+      return usb_keycode_map[i].code;
+  }
+  return DomCode::NONE;
+}
+
+// static
+uint16_t KeycodeConverter::DomCodeToNativeKeycode(DomCode code) {
+  for (size_t i = 0; i < kKeycodeMapEntries; ++i) {
+    if (usb_keycode_map[i].code == code)
+      return usb_keycode_map[i].native_keycode;
+  }
+  return InvalidNativeKeycode();
 }
 
 // static
 const char* KeycodeConverter::NativeKeycodeToCode(uint16_t native_keycode) {
-  for (size_t i = 0; i < kKeycodeMapEntries; ++i) {
-    if (usb_keycode_map[i].native_keycode == native_keycode) {
-      if (usb_keycode_map[i].code != NULL)
-        return usb_keycode_map[i].code;
-      break;
-    }
-  }
-  return InvalidKeyboardEventCode();
+  return DomCodeToCodeString(NativeKeycodeToDomCode(native_keycode));
 }
 
 // static
-uint16_t KeycodeConverter::CodeToNativeKeycode(const char* code) {
-  if (!code ||
-      strcmp(code, InvalidKeyboardEventCode()) == 0) {
-    return InvalidNativeKeycode();
-  }
-
-  for (size_t i = 0; i < kKeycodeMapEntries; ++i) {
-    if (usb_keycode_map[i].code &&
-        strcmp(usb_keycode_map[i].code, code) == 0) {
-      return usb_keycode_map[i].native_keycode;
-    }
-  }
-  return InvalidNativeKeycode();
+uint16_t KeycodeConverter::CodeToNativeKeycode(const char* code_string) {
+  return DomCodeToNativeKeycode(CodeStringToDomCode(code_string));
 }
 
 // USB keycodes
 // Note that USB keycodes are not part of any web standard.
 // Please don't use USB keycodes in new code.
 
 // static
 uint16_t KeycodeConverter::InvalidUsbKeycode() {
   return static_cast<uint16_t>(usb_keycode_map[0].usb_keycode);
 }
@@ skipping 21 matching lines @@
     if (usb_keycode_map[i].native_keycode == native_keycode)
       return usb_keycode_map[i].usb_keycode;
   }
   return InvalidUsbKeycode();
 }
 
 // static
 const char* KeycodeConverter::UsbKeycodeToCode(uint32_t usb_keycode) {
   for (size_t i = 0; i < kKeycodeMapEntries; ++i) {
     if (usb_keycode_map[i].usb_keycode == usb_keycode)
-      return usb_keycode_map[i].code;
+      return DomCodeToCodeString(usb_keycode_map[i].code);
   }
   return InvalidKeyboardEventCode();
 }
 
 // static
-uint32_t KeycodeConverter::CodeToUsbKeycode(const char* code) {
-  if (!code ||
-      strcmp(code, InvalidKeyboardEventCode()) == 0) {
-    return InvalidUsbKeycode();
-  }
-
+uint32_t KeycodeConverter::CodeToUsbKeycode(const char* code_string) {
+  DomCode code = CodeStringToDomCode(code_string);
   for (size_t i = 0; i < kKeycodeMapEntries; ++i) {
-    if (usb_keycode_map[i].code &&
-        strcmp(usb_keycode_map[i].code, code) == 0) {
+    if (usb_keycode_map[i].code == code) {
       return usb_keycode_map[i].usb_keycode;
     }
   }
   return InvalidUsbKeycode();
 }
 
+// static
+const char* KeycodeConverter::DomKeyToKeyString(DomKey dom_key) {
+  size_t key = static_cast<size_t>(dom_key);
+  DCHECK_LT(key, kDomKeyStringTableEntries);
+  DCHECK_NE(dom_key_string[key], static_cast<const char*>(nullptr));
+  return dom_key_string[key];
+}
+
+// static
+DomKey KeycodeConverter::KeyStringToDomKey(const char* key) {
+  if (key) {
+    for (size_t i = 0; i < kDomKeyTableEntries; ++i) {
+      if (strcmp(key, dom_key_table[i].string) == 0)
+        return dom_key_table[i].enumeration;
+    }
+  }
+  return DomKey::NONE;
+}
+
 }  // namespace ui