Remove duplicated keyboard code

atom/browser/ui/accelerator_util.cc

@@ -18,13 +18,12 @@
 
 namespace accelerator_util {
 
-bool StringToAccelerator(const std::string& description,
+bool StringToAccelerator(const std::string& shortcut,
                          ui::Accelerator* accelerator) {
-  if (!base::IsStringASCII(description)) {
+  if (!base::IsStringASCII(shortcut)) {
     LOG(ERROR) << "The accelerator string can only contain ASCII characters";
     return false;
   }
-  std::string shortcut(base::ToLowerASCII(description));
 
   std::vector<std::string> tokens = base::SplitString(
      shortcut, "+", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
@@ -33,95 +32,35 @@ bool StringToAccelerator(const std::string& description,
   int modifiers = ui::EF_NONE;
   ui::KeyboardCode key = ui::VKEY_UNKNOWN;
   for (size_t i = 0; i < tokens.size(); i++) {
-    // We use straight comparing instead of map because the accelerator tends
-    // to be correct and usually only uses few special tokens.
-    if (tokens[i].size() == 1) {
-      bool shifted = false;
-      key = atom::KeyboardCodeFromCharCode(tokens[i][0], &shifted);
-      if (shifted)
-        modifiers |= ui::EF_SHIFT_DOWN;
-    } else if (tokens[i] == "ctrl" || tokens[i] == "control") {
-      modifiers |= ui::EF_CONTROL_DOWN;
-    } else if (tokens[i] == "super") {
-      modifiers |= ui::EF_COMMAND_DOWN;
-#if defined(OS_MACOSX)
-    } else if (tokens[i] == "cmd" || tokens[i] == "command") {
-      modifiers |= ui::EF_COMMAND_DOWN;
-#endif
-    } else if (tokens[i] == "commandorcontrol" || tokens[i] == "cmdorctrl") {
-#if defined(OS_MACOSX)
-      modifiers |= ui::EF_COMMAND_DOWN;
-#else
-      modifiers |= ui::EF_CONTROL_DOWN;
-#endif
-    } else if (tokens[i] == "alt") {
-      modifiers |= ui::EF_ALT_DOWN;
-    } else if (tokens[i] == "shift") {
-      modifiers |= ui::EF_SHIFT_DOWN;
-    } else if (tokens[i] == "plus") {
+    bool shifted = false;
+    ui::KeyboardCode code = atom::KeyboardCodeFromStr(tokens[i], &shifted);
+    if (shifted)
       modifiers |= ui::EF_SHIFT_DOWN;
-      key = ui::VKEY_OEM_PLUS;
-    } else if (tokens[i] == "tab") {
-      key = ui::VKEY_TAB;
-    } else if (tokens[i] == "space") {
-      key = ui::VKEY_SPACE;
-    } else if (tokens[i] == "backspace") {
-      key = ui::VKEY_BACK;
-    } else if (tokens[i] == "delete") {
-      key = ui::VKEY_DELETE;
-    } else if (tokens[i] == "insert") {
-      key = ui::VKEY_INSERT;
-    } else if (tokens[i] == "enter" || tokens[i] == "return") {
-      key = ui::VKEY_RETURN;
-    } else if (tokens[i] == "up") {
-      key = ui::VKEY_UP;
-    } else if (tokens[i] == "down") {
-      key = ui::VKEY_DOWN;
-    } else if (tokens[i] == "left") {
-      key = ui::VKEY_LEFT;
-    } else if (tokens[i] == "right") {
-      key = ui::VKEY_RIGHT;
-    } else if (tokens[i] == "home") {
-      key = ui::VKEY_HOME;
-    } else if (tokens[i] == "end") {
-      key = ui::VKEY_END;
-    } else if (tokens[i] == "pageup") {
-      key = ui::VKEY_PRIOR;
-    } else if (tokens[i] == "pagedown") {
-      key = ui::VKEY_NEXT;
-    } else if (tokens[i] == "esc" || tokens[i] == "escape") {
-      key = ui::VKEY_ESCAPE;
-    } else if (tokens[i] == "volumemute") {
-      key = ui::VKEY_VOLUME_MUTE;
-    } else if (tokens[i] == "volumeup") {
-      key = ui::VKEY_VOLUME_UP;
-    } else if (tokens[i] == "volumedown") {
-      key = ui::VKEY_VOLUME_DOWN;
-    } else if (tokens[i] == "medianexttrack") {
-      key = ui::VKEY_MEDIA_NEXT_TRACK;
-    } else if (tokens[i] == "mediaprevioustrack") {
-      key = ui::VKEY_MEDIA_PREV_TRACK;
-    } else if (tokens[i] == "mediastop") {
-      key = ui::VKEY_MEDIA_STOP;
-    } else if (tokens[i] == "mediaplaypause") {
-      key = ui::VKEY_MEDIA_PLAY_PAUSE;
-    } else if (tokens[i].size() > 1 && tokens[i][0] == 'f') {
-      // F1 - F24.
-      int n;
-      if (base::StringToInt(tokens[i].c_str() + 1, &n) && n > 0 && n < 25) {
-        key = static_cast<ui::KeyboardCode>(ui::VKEY_F1 + n - 1);
-      } else {
-        LOG(WARNING) << tokens[i] << "is not available on keyboard";
-        return false;
-      }
-    } else {
-      LOG(WARNING) << "Invalid accelerator token: " << tokens[i];
-      return false;
+    switch (code) {
+      // The token can be a modifier.
+      case ui::VKEY_SHIFT:
+        modifiers |= ui::EF_SHIFT_DOWN;
+        break;
+      case ui::VKEY_CONTROL:
+        modifiers |= ui::EF_CONTROL_DOWN;
+        break;
+      case ui::VKEY_MENU:
+        modifiers |= ui::EF_ALT_DOWN;
+        break;
+      case ui::VKEY_COMMAND:
+        modifiers |= ui::EF_COMMAND_DOWN;
+        break;
+      case ui::VKEY_ALTGR:
+        modifiers |= ui::EF_ALTGR_DOWN;
+        break;
+      // Or it is a normal key.
+      default:
+        key = code;
     }
   }
 
   if (key == ui::VKEY_UNKNOWN) {
-    LOG(WARNING) << "The accelerator doesn't contain a valid key";
+    LOG(WARNING) << shortcut << " doesn't contain a valid key";
     return false;
   }
 

atom/common/keyboard_util.cc

@@ -3,12 +3,19 @@
 // found in the LICENSE file.
 
 #include <string>
+
 #include "atom/common/keyboard_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
 
 namespace atom {
 
-// Return key code of the char.
+namespace {
+
+// Return key code of the char, and also determine whether the SHIFT key is
+// pressed.
 ui::KeyboardCode KeyboardCodeFromCharCode(base::char16 c, bool* shifted) {
+  c = base::ToLowerASCII(c);
   *shifted = false;
   switch (c) {
     case 0x08: return ui::VKEY_BACK;
@@ -72,38 +79,98 @@ ui::KeyboardCode KeyboardCodeFromCharCode(base::char16 c, bool* shifted) {
   }
 }
 
-// Return key code of the char.
-ui::KeyboardCode KeyboardCodeFromKeyIdentifier(const std::string& chr) {
-  if (chr == "enter")        return ui::VKEY_RETURN;
-  if (chr == "backspace")    return ui::VKEY_BACK;
-  if (chr == "delete")       return ui::VKEY_DELETE;
-  if (chr == "tab")          return ui::VKEY_TAB;
-  if (chr == "escape")       return ui::VKEY_ESCAPE;
-  if (chr == "control")      return ui::VKEY_CONTROL;
+// Return key code represented by |str|.
+ui::KeyboardCode KeyboardCodeFromKeyIdentifier(const std::string& s,
+                                               bool* shifted) {
+  std::string str = base::ToLowerASCII(s);
+  if (str == "ctrl" || str == "control") {
+    return ui::VKEY_CONTROL;
+  } else if (str == "super" || str == "cmd" || str == "command" ||
+             str == "meta") {
+    return ui::VKEY_COMMAND;
+  } else if (str == "commandorcontrol" || str == "cmdorctrl") {
 #if defined(OS_MACOSX)
-  if (chr == "command"
-    || chr == "cmd"
-    || chr == "meta")        return ui::VKEY_COMMAND;
-  if (chr == "option")       return ui::VKEY_MENU;
-#endif
-#if defined(OS_WIN)
-  if (chr == "meta")         return ui::VKEY_LWIN;
-  if (chr == "altgr")        return ui::VKEY_ALTGR;
+    return ui::VKEY_COMMAND;
+#else
+    return ui::VKEY_CONTROL;
 #endif
-  if (chr == "alt")          return ui::VKEY_MENU;
-  if (chr == "shift")        return ui::VKEY_SHIFT;
-  if (chr == "end")          return ui::VKEY_END;
-  if (chr == "home")         return ui::VKEY_HOME;
-  if (chr == "insert")       return ui::VKEY_INSERT;
-  if (chr == "left")         return ui::VKEY_LEFT;
-  if (chr == "up")           return ui::VKEY_UP;
-  if (chr == "right")        return ui::VKEY_RIGHT;
-  if (chr == "down")         return ui::VKEY_DOWN;
-  if (chr == "pageup")       return ui::VKEY_PRIOR;
-  if (chr == "pagedown")     return ui::VKEY_NEXT;
-  if (chr == "printscreen")  return ui::VKEY_SNAPSHOT;
+  } else if (str == "alt" || str == "option") {
+    return ui::VKEY_MENU;
+  } else if (str == "shift") {
+    return ui::VKEY_SHIFT;
+  } else if (str == "altgr") {
+    return ui::VKEY_ALTGR;
+  } else if (str == "plus") {
+    *shifted = true;
+    return ui::VKEY_OEM_PLUS;
+  } else if (str == "tab") {
+    return ui::VKEY_TAB;
+  } else if (str == "space") {
+    return ui::VKEY_SPACE;
+  } else if (str == "backspace") {
+    return ui::VKEY_BACK;
+  } else if (str == "delete") {
+    return ui::VKEY_DELETE;
+  } else if (str == "insert") {
+    return ui::VKEY_INSERT;
+  } else if (str == "enter" || str == "return") {
+    return ui::VKEY_RETURN;
+  } else if (str == "up") {
+    return ui::VKEY_UP;
+  } else if (str == "down") {
+    return ui::VKEY_DOWN;
+  } else if (str == "left") {
+    return ui::VKEY_LEFT;
+  } else if (str == "right") {
+    return ui::VKEY_RIGHT;
+  } else if (str == "home") {
+    return ui::VKEY_HOME;
+  } else if (str == "end") {
+    return ui::VKEY_END;
+  } else if (str == "pageup") {
+    return ui::VKEY_PRIOR;
+  } else if (str == "pagedown") {
+    return ui::VKEY_NEXT;
+  } else if (str == "esc" || str == "escape") {
+    return ui::VKEY_ESCAPE;
+  } else if (str == "volumemute") {
+    return ui::VKEY_VOLUME_MUTE;
+  } else if (str == "volumeup") {
+    return ui::VKEY_VOLUME_UP;
+  } else if (str == "volumedown") {
+    return ui::VKEY_VOLUME_DOWN;
+  } else if (str == "medianexttrack") {
+    return ui::VKEY_MEDIA_NEXT_TRACK;
+  } else if (str == "mediaprevioustrack") {
+    return ui::VKEY_MEDIA_PREV_TRACK;
+  } else if (str == "mediastop") {
+    return ui::VKEY_MEDIA_STOP;
+  } else if (str == "mediaplaypause") {
+    return ui::VKEY_MEDIA_PLAY_PAUSE;
+  } else if (str == "printscreen") {
+    return ui::VKEY_SNAPSHOT;
+  } else if (str.size() > 1 && str[0] == 'f') {
+    // F1 - F24.
+    int n;
+    if (base::StringToInt(str.c_str() + 1, &n) && n > 0 && n < 25) {
+      return static_cast<ui::KeyboardCode>(ui::VKEY_F1 + n - 1);
+    } else {
+      LOG(WARNING) << str << "is not available on keyboard";
+      return ui::VKEY_UNKNOWN;
+    }
+  } else {
+    LOG(WARNING) << "Invalid accelerator token: " << str;
+    return ui::VKEY_UNKNOWN;
+  }
+}
+
+}  // namespace
 
-  return ui::VKEY_UNKNOWN;
+ui::KeyboardCode KeyboardCodeFromStr(const std::string& str, bool* shifted) {
+  if (str.size() == 1)
+    return KeyboardCodeFromCharCode(str[0], shifted);
+  else
+    return KeyboardCodeFromKeyIdentifier(str, shifted);
 }
 
 }  // namespace atom

atom/common/keyboard_util.h

@@ -6,17 +6,14 @@
 #define ATOM_COMMON_KEYBOARD_UTIL_H_
 
 #include <string>
+
 #include "ui/events/keycodes/keyboard_codes.h"
-#include "base/strings/string_util.h"
 
 namespace atom {
 
-// Return key code of the char, and also determine whether the SHIFT key is
+// Return key code of the |str|, and also determine whether the SHIFT key is
 // pressed.
-ui::KeyboardCode KeyboardCodeFromCharCode(base::char16 c, bool* shifted);
-
-// Return key code of the char from a string representation of the char
-ui::KeyboardCode KeyboardCodeFromKeyIdentifier(const std::string& chr);
+ui::KeyboardCode KeyboardCodeFromStr(const std::string& str, bool* shifted);
 
 }  // namespace atom
 

atom/common/native_mate_converters/blink_converter.cc

@@ -159,25 +159,22 @@ bool Converter<blink::WebKeyboardEvent>::FromV8(
     return false;
   if (!ConvertFromV8(isolate, val, static_cast<blink::WebInputEvent*>(out)))
     return false;
-  base::char16 code;
-  std::string identifier;
-  bool shifted = false;
 
-  if (dict.Get("keyCode", &code))
-    out->windowsKeyCode = atom::KeyboardCodeFromCharCode(code, &shifted);
-  else if (dict.Get("keyCode", &identifier))
-    out->windowsKeyCode = atom::KeyboardCodeFromKeyIdentifier(
-      base::ToLowerASCII(identifier));
+  std::string str;
+  bool shifted = false;
+  if (dict.Get("keyCode", &str))
+    out->windowsKeyCode = atom::KeyboardCodeFromStr(str, &shifted);
   else
     return false;
 
   if (shifted)
     out->modifiers |= blink::WebInputEvent::ShiftKey;
   out->setKeyIdentifierFromWindowsKeyCode();
-  if (out->type == blink::WebInputEvent::Char ||
-      out->type == blink::WebInputEvent::RawKeyDown) {
-    out->text[0] = code;
-    out->unmodifiedText[0] = code;
+  if ((out->type == blink::WebInputEvent::Char ||
+       out->type == blink::WebInputEvent::RawKeyDown) &&
+      str.size() == 1) {
+    out->text[0] = str[0];
+    out->unmodifiedText[0] = str[0];
   }
   return true;
 }