// Copyright 2010-2015, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include "win32/base/keyevent_handler.h"

#include <ime.h>
#include <string.h>
#include <windows.h>

#include <set>

#include "base/logging.h"
#include "base/util.h"
#include "client/client_interface.h"
#include "config/config_handler.h"
#include "session/commands.pb.h"
#include "session/key_info_util.h"
#include "win32/base/conversion_mode_util.h"
#include "win32/base/input_state.h"
#include "win32/base/keyboard.h"

namespace mozc {
namespace win32 {
using commands::KeyEvent;
using commands::Output;

namespace {

// The Mozc protocol has expected the client to send a key event with
// |KeyEvent::HANKAKU| special key as if there was single Hankaku/Zenkaku
// key.  This is why we map both VK_DBE_SBCSCHAR and VK_DBE_DBCSCHAR into
// KeyEvent::HANKAKU.
const KeyEvent::SpecialKey kSpecialKeyMap[] = {
  KeyEvent::NO_SPECIALKEY,        // 0x00:
  KeyEvent::NO_SPECIALKEY,        // 0x01: VK_LBUTTON
  KeyEvent::NO_SPECIALKEY,        // 0x02: VK_RBUTTON
  KeyEvent::NO_SPECIALKEY,        // 0x03: VK_CANCEL
  KeyEvent::NO_SPECIALKEY,        // 0x04: VK_MBUTTON
  KeyEvent::NO_SPECIALKEY,        // 0x05: VK_XBUTTON1
  KeyEvent::NO_SPECIALKEY,        // 0x06: VK_XBUTTON2
  KeyEvent::NO_SPECIALKEY,        // 0x07:
  KeyEvent::BACKSPACE,            // 0x08: VK_BACK
  KeyEvent::TAB,                  // 0x09: VK_TAB
  KeyEvent::NO_SPECIALKEY,        // 0x0A:
  KeyEvent::NO_SPECIALKEY,        // 0x0B:
  KeyEvent::CLEAR,                // 0x0C: VK_CLEAR
  KeyEvent::ENTER,                // 0x0D: VK_RETURN
  KeyEvent::NO_SPECIALKEY,        // 0x0E:
  KeyEvent::NO_SPECIALKEY,        // 0x0F:
  KeyEvent::NO_SPECIALKEY,        // 0x10: VK_SHIFT
  KeyEvent::NO_SPECIALKEY,        // 0x11: VK_CONTROL
  KeyEvent::NO_SPECIALKEY,        // 0x12: VK_MENU
  KeyEvent::NO_SPECIALKEY,        // 0x13: VK_PAUSE
  KeyEvent::CAPS_LOCK,            // 0x14: VK_CAPITAL
  KeyEvent::NO_SPECIALKEY,        // 0x15: VK_HANGUL, VK_KANA
  KeyEvent::NO_SPECIALKEY,        // 0x16:
  KeyEvent::NO_SPECIALKEY,        // 0x17: VK_JUNJA
  KeyEvent::NO_SPECIALKEY,        // 0x18: VK_FINAL
  // VK_KANJI is very special in IMM32 mode. It activates IME in OS-side
  // regardless of the actual key binding in an IME. On the other hand,
  // this automatic activation does not happen in TSF mode. To work around
  // this anomaly, we map VK_KANJI to KeyEvent::NO_SPECIALKEY instead of
  // KeyEvent::KANJI in IMM32 mode and map VK_KANJI to KeyEvent::HANKAKU
  // via VK_DBE_DBCSCHAR in TSF mode. See b/7970379 for the background.
  KeyEvent::NO_SPECIALKEY,        // 0x19: VK_HANJA, VK_KANJI
  KeyEvent::NO_SPECIALKEY,        // 0x1A:
  KeyEvent::ESCAPE,               // 0x1B: VK_ESCAPE
  KeyEvent::HENKAN,               // 0x1C: VK_CONVERT
  KeyEvent::MUHENKAN,             // 0x1D: VK_NONCONVERT
  KeyEvent::NO_SPECIALKEY,        // 0x1E: VK_ACCEPT
  KeyEvent::NO_SPECIALKEY,        // 0x1F: VK_MODECHANGE
  KeyEvent::SPACE,                // 0x20: VK_SPACE
  KeyEvent::PAGE_UP,              // 0x21: VK_PRIOR
  KeyEvent::PAGE_DOWN,            // 0x22: VK_NEXT
  KeyEvent::END,                  // 0x23: VK_END
  KeyEvent::HOME,                 // 0x24: VK_HOME
  KeyEvent::LEFT,                 // 0x25: VK_LEFT
  KeyEvent::UP,                   // 0x26: VK_UP
  KeyEvent::RIGHT,                // 0x27: VK_RIGHT
  KeyEvent::DOWN,                 // 0x28: VK_DOWN
  KeyEvent::NO_SPECIALKEY,        // 0x29: VK_SELECT
  KeyEvent::NO_SPECIALKEY,        // 0x2A: VK_PRINT
  KeyEvent::NO_SPECIALKEY,        // 0x2B: VK_EXECUTE
  KeyEvent::NO_SPECIALKEY,        // 0x2C: VK_SNAPSHOT
  KeyEvent::INSERT,               // 0x2D: VK_INSERT
  KeyEvent::DEL,                  // 0x2E: VK_DELETE
  KeyEvent::NO_SPECIALKEY,        // 0x2F: VK_HELP
  KeyEvent::NO_SPECIALKEY,        // 0x30: VK_0
  KeyEvent::NO_SPECIALKEY,        // 0x31: VK_1
  KeyEvent::NO_SPECIALKEY,        // 0x32: VK_2
  KeyEvent::NO_SPECIALKEY,        // 0x33: VK_3
  KeyEvent::NO_SPECIALKEY,        // 0x34: VK_4
  KeyEvent::NO_SPECIALKEY,        // 0x35: VK_5
  KeyEvent::NO_SPECIALKEY,        // 0x36: VK_6
  KeyEvent::NO_SPECIALKEY,        // 0x37: VK_7
  KeyEvent::NO_SPECIALKEY,        // 0x38: VK_8
  KeyEvent::NO_SPECIALKEY,        // 0x39: VK_9
  KeyEvent::NO_SPECIALKEY,        // 0x3A:
  KeyEvent::NO_SPECIALKEY,        // 0x3B:
  KeyEvent::NO_SPECIALKEY,        // 0x3C:
  KeyEvent::NO_SPECIALKEY,        // 0x3D:
  KeyEvent::NO_SPECIALKEY,        // 0x3E:
  KeyEvent::NO_SPECIALKEY,        // 0x3F:
  KeyEvent::NO_SPECIALKEY,        // 0x40:
  KeyEvent::NO_SPECIALKEY,        // 0x41: VK_A
  KeyEvent::NO_SPECIALKEY,        // 0x42: VK_B
  KeyEvent::NO_SPECIALKEY,        // 0x43: VK_C
  KeyEvent::NO_SPECIALKEY,        // 0x44: VK_D
  KeyEvent::NO_SPECIALKEY,        // 0x45: VK_E
  KeyEvent::NO_SPECIALKEY,        // 0x46: VK_F
  KeyEvent::NO_SPECIALKEY,        // 0x47: VK_G
  KeyEvent::NO_SPECIALKEY,        // 0x48: VK_H
  KeyEvent::NO_SPECIALKEY,        // 0x49: VK_I
  KeyEvent::NO_SPECIALKEY,        // 0x4A: VK_J
  KeyEvent::NO_SPECIALKEY,        // 0x4B: VK_K
  KeyEvent::NO_SPECIALKEY,        // 0x4C: VK_L
  KeyEvent::NO_SPECIALKEY,        // 0x4D: VK_M
  KeyEvent::NO_SPECIALKEY,        // 0x4E: VK_N
  KeyEvent::NO_SPECIALKEY,        // 0x4F: VK_O
  KeyEvent::NO_SPECIALKEY,        // 0x50: VK_P
  KeyEvent::NO_SPECIALKEY,        // 0x51: VK_Q
  KeyEvent::NO_SPECIALKEY,        // 0x52: VK_R
  KeyEvent::NO_SPECIALKEY,        // 0x53: VK_S
  KeyEvent::NO_SPECIALKEY,        // 0x54: VK_T
  KeyEvent::NO_SPECIALKEY,        // 0x55: VK_U
  KeyEvent::NO_SPECIALKEY,        // 0x56: VK_V
  KeyEvent::NO_SPECIALKEY,        // 0x57: VK_W
  KeyEvent::NO_SPECIALKEY,        // 0x58: VK_X
  KeyEvent::NO_SPECIALKEY,        // 0x59: VK_Y
  KeyEvent::NO_SPECIALKEY,        // 0x5A: VK_Z
  KeyEvent::NO_SPECIALKEY,        // 0x5B: VK_LWIN
  KeyEvent::NO_SPECIALKEY,        // 0x5C: VK_RWIN
  KeyEvent::NO_SPECIALKEY,        // 0x5D: VK_APPS
  KeyEvent::NO_SPECIALKEY,        // 0x5E:
  KeyEvent::NO_SPECIALKEY,        // 0x5F: VK_SLEEP
  KeyEvent::NUMPAD0,              // 0x60: VK_NUMPAD0
  KeyEvent::NUMPAD1,              // 0x61: VK_NUMPAD1
  KeyEvent::NUMPAD2,              // 0x62: VK_NUMPAD2
  KeyEvent::NUMPAD3,              // 0x63: VK_NUMPAD3
  KeyEvent::NUMPAD4,              // 0x64: VK_NUMPAD4
  KeyEvent::NUMPAD5,              // 0x65: VK_NUMPAD5
  KeyEvent::NUMPAD6,              // 0x66: VK_NUMPAD6
  KeyEvent::NUMPAD7,              // 0x67: VK_NUMPAD7
  KeyEvent::NUMPAD8,              // 0x68: VK_NUMPAD8
  KeyEvent::NUMPAD9,              // 0x69: VK_NUMPAD9
  KeyEvent::MULTIPLY,             // 0x6A: VK_MULTIPLY
  KeyEvent::ADD,                  // 0x6B: VK_ADD
  KeyEvent::SEPARATOR,            // 0x6C: VK_SEPARATOR
  KeyEvent::SUBTRACT,             // 0x6D: VK_SUBTRACT
  KeyEvent::DECIMAL,              // 0x6E: VK_DECIMAL
  KeyEvent::DIVIDE,               // 0x6F: VK_DIVIDE
  KeyEvent::F1,                   // 0x70: VK_F1
  KeyEvent::F2,                   // 0x71: VK_F2
  KeyEvent::F3,                   // 0x72: VK_F3
  KeyEvent::F4,                   // 0x73: VK_F4
  KeyEvent::F5,                   // 0x74: VK_F5
  KeyEvent::F6,                   // 0x75: VK_F6
  KeyEvent::F7,                   // 0x76: VK_F7
  KeyEvent::F8,                   // 0x77: VK_F8
  KeyEvent::F9,                   // 0x78: VK_F9
  KeyEvent::F10,                  // 0x79: VK_F10
  KeyEvent::F11,                  // 0x7A: VK_F11
  KeyEvent::F12,                  // 0x7B: VK_F12
  KeyEvent::F13,                  // 0x7C: VK_F13
  KeyEvent::F14,                  // 0x7D: VK_F14
  KeyEvent::F15,                  // 0x7E: VK_F15
  KeyEvent::F16,                  // 0x7F: VK_F16
  KeyEvent::F17,                  // 0x80: VK_F17
  KeyEvent::F18,                  // 0x81: VK_F18
  KeyEvent::F19,                  // 0x82: VK_F19
  KeyEvent::F20,                  // 0x83: VK_F20
  KeyEvent::F21,                  // 0x84: VK_F21
  KeyEvent::F22,                  // 0x85: VK_F22
  KeyEvent::F23,                  // 0x86: VK_F23
  KeyEvent::F24,                  // 0x87: VK_F24
  KeyEvent::NO_SPECIALKEY,        // 0x88:
  KeyEvent::NO_SPECIALKEY,        // 0x89:
  KeyEvent::NO_SPECIALKEY,        // 0x8A:
  KeyEvent::NO_SPECIALKEY,        // 0x8B:
  KeyEvent::NO_SPECIALKEY,        // 0x8C:
  KeyEvent::NO_SPECIALKEY,        // 0x8D:
  KeyEvent::NO_SPECIALKEY,        // 0x8E:
  KeyEvent::NO_SPECIALKEY,        // 0x8F:
  KeyEvent::NO_SPECIALKEY,        // 0x90: VK_NUMLOCK
  KeyEvent::NO_SPECIALKEY,        // 0x91: VK_SCROLL
  KeyEvent::NO_SPECIALKEY,        // 0x92: VK_OEM_FJ_JISHO, VK_OEM_NEC_EQUAL
  KeyEvent::NO_SPECIALKEY,        // 0x93: VK_OEM_FJ_MASSHOU
  KeyEvent::NO_SPECIALKEY,        // 0x94: VK_OEM_FJ_TOUROKU
  KeyEvent::NO_SPECIALKEY,        // 0x95: VK_OEM_FJ_LOYA
  KeyEvent::NO_SPECIALKEY,        // 0x96: VK_OEM_FJ_ROYA
  KeyEvent::NO_SPECIALKEY,        // 0x97:
  KeyEvent::NO_SPECIALKEY,        // 0x98:
  KeyEvent::NO_SPECIALKEY,        // 0x99:
  KeyEvent::NO_SPECIALKEY,        // 0x9A:
  KeyEvent::NO_SPECIALKEY,        // 0x9B:
  KeyEvent::NO_SPECIALKEY,        // 0x9C:
  KeyEvent::NO_SPECIALKEY,        // 0x9D:
  KeyEvent::NO_SPECIALKEY,        // 0x9E:
  KeyEvent::NO_SPECIALKEY,        // 0x9F:
  KeyEvent::NO_SPECIALKEY,        // 0xA0: VK_LSHIFT
  KeyEvent::NO_SPECIALKEY,        // 0xA1: VK_RSHIFT
  KeyEvent::NO_SPECIALKEY,        // 0xA2: VK_LCONTROL
  KeyEvent::NO_SPECIALKEY,        // 0xA3: VK_RCONTROL
  KeyEvent::NO_SPECIALKEY,        // 0xA4: VK_LMENU
  KeyEvent::NO_SPECIALKEY,        // 0xA5: VK_RMENU
  KeyEvent::NO_SPECIALKEY,        // 0xA6: VK_BROWSER_BACK
  KeyEvent::NO_SPECIALKEY,        // 0xA7: VK_BROWSER_FORWARD
  KeyEvent::NO_SPECIALKEY,        // 0xA8: VK_BROWSER_REFRESH
  KeyEvent::NO_SPECIALKEY,        // 0xA9: VK_BROWSER_STOP
  KeyEvent::NO_SPECIALKEY,        // 0xAA: VK_BROWSER_SEARCH
  KeyEvent::NO_SPECIALKEY,        // 0xAB: VK_BROWSER_FAVORITES
  KeyEvent::NO_SPECIALKEY,        // 0xAC: VK_BROWSER_HOME
  KeyEvent::NO_SPECIALKEY,        // 0xAD: VK_VOLUME_MUTE
  KeyEvent::NO_SPECIALKEY,        // 0xAE: VK_VOLUME_DOWN
  KeyEvent::NO_SPECIALKEY,        // 0xAF: VK_VOLUME_UP
  KeyEvent::NO_SPECIALKEY,        // 0xB0: VK_MEDIA_NEXT_TRACK
  KeyEvent::NO_SPECIALKEY,        // 0xB1: VK_MEDIA_PREV_TRACK
  KeyEvent::NO_SPECIALKEY,        // 0xB2: VK_MEDIA_STOP
  KeyEvent::NO_SPECIALKEY,        // 0xB3: VK_MEDIA_PLAY_PAUSE
  KeyEvent::NO_SPECIALKEY,        // 0xB4: VK_LAUNCH_MAIL
  KeyEvent::NO_SPECIALKEY,        // 0xB5: VK_LAUNCH_MEDIA_SELECT
  KeyEvent::NO_SPECIALKEY,        // 0xB6: VK_LAUNCH_APP1
  KeyEvent::NO_SPECIALKEY,        // 0xB7: VK_LAUNCH_APP2
  KeyEvent::NO_SPECIALKEY,        // 0xB8:
  KeyEvent::NO_SPECIALKEY,        // 0xB9:
  KeyEvent::NO_SPECIALKEY,        // 0xBA: VK_OEM_1
  KeyEvent::NO_SPECIALKEY,        // 0xBB: VK_OEM_PLUS
  KeyEvent::NO_SPECIALKEY,        // 0xBC: VK_OEM_COMMA
  KeyEvent::NO_SPECIALKEY,        // 0xBD: VK_OEM_MINUS
  KeyEvent::NO_SPECIALKEY,        // 0xBE: VK_OEM_PERIOD
  KeyEvent::NO_SPECIALKEY,        // 0xBF: VK_OEM_2
  KeyEvent::NO_SPECIALKEY,        // 0xC0: VK_OEM_3
  KeyEvent::NO_SPECIALKEY,        // 0xC1: VK_ABNT_C1
  // The numpad comma on the Apple Japanese 109 keyboard is somehow mapped into
  // VK_ABNT_C2, which is only defined in kbd.h.
  // See also http://blogs.msdn.com/b/michkap/archive/2006/10/07/799605.aspx
  // See also b/6639635.
  KeyEvent::COMMA,                // 0xC2: VK_ABNT_C2
  KeyEvent::NO_SPECIALKEY,        // 0xC3:
  KeyEvent::NO_SPECIALKEY,        // 0xC4:
  KeyEvent::NO_SPECIALKEY,        // 0xC5:
  KeyEvent::NO_SPECIALKEY,        // 0xC6:
  KeyEvent::NO_SPECIALKEY,        // 0xC7:
  KeyEvent::NO_SPECIALKEY,        // 0xC8:
  KeyEvent::NO_SPECIALKEY,        // 0xC9:
  KeyEvent::NO_SPECIALKEY,        // 0xCA:
  KeyEvent::NO_SPECIALKEY,        // 0xCB:
  KeyEvent::NO_SPECIALKEY,        // 0xCC:
  KeyEvent::NO_SPECIALKEY,        // 0xCD:
  KeyEvent::NO_SPECIALKEY,        // 0xCE:
  KeyEvent::NO_SPECIALKEY,        // 0xCF:
  KeyEvent::NO_SPECIALKEY,        // 0xD0:
  KeyEvent::NO_SPECIALKEY,        // 0xD1:
  KeyEvent::NO_SPECIALKEY,        // 0xD2:
  KeyEvent::NO_SPECIALKEY,        // 0xD3:
  KeyEvent::NO_SPECIALKEY,        // 0xD4:
  KeyEvent::NO_SPECIALKEY,        // 0xD5:
  KeyEvent::NO_SPECIALKEY,        // 0xD6:
  KeyEvent::NO_SPECIALKEY,        // 0xD7:
  KeyEvent::NO_SPECIALKEY,        // 0xD8:
  KeyEvent::NO_SPECIALKEY,        // 0xD9:
  KeyEvent::NO_SPECIALKEY,        // 0xDA:
  KeyEvent::NO_SPECIALKEY,        // 0xDB: VK_OEM_4
  KeyEvent::NO_SPECIALKEY,        // 0xDC: VK_OEM_5
  KeyEvent::NO_SPECIALKEY,        // 0xDD: VK_OEM_6
  KeyEvent::NO_SPECIALKEY,        // 0xDE: VK_OEM_7
  KeyEvent::NO_SPECIALKEY,        // 0xDF: VK_OEM_8
  KeyEvent::NO_SPECIALKEY,        // 0xE0:
  KeyEvent::NO_SPECIALKEY,        // 0xE1: VK_OEM_AX
  KeyEvent::NO_SPECIALKEY,        // 0xE2: VK_OEM_102
  KeyEvent::NO_SPECIALKEY,        // 0xE3: VK_ICO_HELP
  KeyEvent::NO_SPECIALKEY,        // 0xE4: VK_ICO_00
  KeyEvent::NO_SPECIALKEY,        // 0xE5: VK_PROCESSKEY
  KeyEvent::NO_SPECIALKEY,        // 0xE6: VK_ICO_CLEAR
  KeyEvent::NO_SPECIALKEY,        // 0xE7: VK_PACKET
  KeyEvent::NO_SPECIALKEY,        // 0xE8:
  KeyEvent::NO_SPECIALKEY,        // 0xE9:
  KeyEvent::NO_SPECIALKEY,        // 0xEA:
  KeyEvent::NO_SPECIALKEY,        // 0xEB:
  KeyEvent::NO_SPECIALKEY,        // 0xEC:
  KeyEvent::NO_SPECIALKEY,        // 0xED:
  KeyEvent::NO_SPECIALKEY,        // 0xEE:
  KeyEvent::NO_SPECIALKEY,        // 0xEF:
  KeyEvent::EISU,                 // 0xF0: VK_DBE_ALPHANUMERIC
  KeyEvent::KATAKANA,             // 0xF1: VK_DBE_KATAKANA
  KeyEvent::KANA,                 // 0xF2: VK_DBE_HIRAGANA
  KeyEvent::HANKAKU,              // 0xF3: VK_DBE_SBCSCHAR
  KeyEvent::HANKAKU,              // 0xF4: VK_DBE_DBCSCHAR
  KeyEvent::NO_SPECIALKEY,        // 0xF5: VK_DBE_ROMAN
  KeyEvent::NO_SPECIALKEY,        // 0xF6: VK_DBE_NOROMAN
  KeyEvent::NO_SPECIALKEY,        // 0xF7: VK_DBE_ENTERWORDREGISTERMODE
  KeyEvent::NO_SPECIALKEY,        // 0xF8: VK_DBE_ENTERIMECONFIGMODE
  KeyEvent::NO_SPECIALKEY,        // 0xF9: VK_DBE_FLUSHSTRING
  KeyEvent::NO_SPECIALKEY,        // 0xFA: VK_DBE_CODEINPUT
  KeyEvent::NO_SPECIALKEY,        // 0xFB: VK_DBE_NOCODEINPUT
  KeyEvent::NO_SPECIALKEY,        // 0xFC: VK_DBE_DETERMINESTRING
  KeyEvent::NO_SPECIALKEY,        // 0xFD: VK_DBE_ENTERDLGCONVERSIONMODE
  KeyEvent::NO_SPECIALKEY,        // 0xFE:
  KeyEvent::NO_SPECIALKEY,        // 0xFF:
};

void ClearModifyerKeyIfNeeded(
    const KeyEvent *key, set<KeyEvent::ModifierKey> *modifiers) {
  if (key == nullptr) {
    return;
  }
  if (modifiers == nullptr) {
    return;
  }
  if (key->has_special_key()) {
    switch (key->special_key()) {
      // Clear modifier keys when the key is filtered in
      // KeyBindingFilter::Encode in gui/config_dialog/keybinding_editor.cc
      case KeyEvent::EISU:      // VK_DBE_ALPHANUMERIC
      case KeyEvent::HANKAKU:   // VK_DBE_SBCSCHAR or VK_DBE_DBCSCHAR
      case KeyEvent::KANA:      // VK_DBE_HIRAGANA
      case KeyEvent::KATAKANA:  // VK_DBE_KATAKANA
        modifiers->clear();
        break;
      default:
        // Do nothing.
        break;
    }
  }
}

// See b/2576120 for details.
bool IsNotimplementedKey(const VirtualKey &virtual_key) {
  switch (virtual_key.virtual_key()) {
    case VK_DBE_ROMAN:    // Changes the mode to Roman characters.
    case VK_DBE_NOROMAN:  // Changes the mode to non-Roman characters.
      // Cuurently these keys are handled by the client, NOT the server.
      // See b/3118905
      // TODO(yukawa, komatsu): Handle these keys in the server.
      return true;
    case VK_DBE_ENTERWORDREGISTERMODE:
      // Activates the word registration dialog box.
      // Ctrl+Alt+Muhenkan on 106 Japanese Keyboard.
      return true;
    case VK_DBE_ENTERIMECONFIGMODE:
      // Activates a dialog box for setting up an IME environment.
      // Ctrl+Alt+Hankaku/Zenkaku on 106 Japanese Keyboard.
      return true;
    case VK_DBE_FLUSHSTRING:
      // Deletes the undetermined string without determining it.
      return true;
    case VK_DBE_CODEINPUT:
      // Changes the mode to code input.
      return true;
    case VK_DBE_NOCODEINPUT:
      // Changes the mode to no-code input.
      return true;
    case VK_DBE_DETERMINESTRING:
      return true;
    case VK_DBE_ENTERDLGCONVERSIONMODE:
      return true;
    default:
      return false;
  }
}

bool ConvertToKeyEventMain(const VirtualKey &virtual_key,
                           BYTE scan_code,
                           bool is_key_down,
                           bool is_menu_active,
                           const InputBehavior &behavior,
                           const InputState &ime_state,
                           const KeyboardStatus &keyboard_status,
                           Win32KeyboardInterface *keyboard,
                           commands::KeyEvent *key,
                           set<KeyEvent::ModifierKey> *modifer_keys) {
  if (key == nullptr) {
    return false;
  }
  key->Clear();

  if (modifer_keys == nullptr) {
    return false;
  }
  modifer_keys->clear();

  // Support VK_PACKET.
  if (virtual_key.virtual_key() == VK_PACKET) {
    const char32 character = virtual_key.unicode_char();
    string utf8_characters;
    Util::UCS4ToUTF8(character, &utf8_characters);
    if (utf8_characters.empty()) {
      return false;
    }
    // Setting |key_string| only to pass an arbitrary character to the
    // converter.
    key->set_key_string(utf8_characters);
    return true;
  }

  // TODO(yukawa): Distinguish left key from right key to fix b/2674446.
  if (keyboard_status.IsPressed(VK_SHIFT)) {
    modifer_keys->insert(KeyEvent::SHIFT);
  }
  if (keyboard_status.IsPressed(VK_CONTROL)) {
    modifer_keys->insert(KeyEvent::CTRL);
  }
  if (keyboard_status.IsPressed(VK_MENU)) {
    modifer_keys->insert(KeyEvent::ALT);
  }
  if (keyboard_status.IsPressed(VK_CAPITAL)) {
    modifer_keys->insert(KeyEvent::CAPS);
  }

  const KeyEvent::SpecialKey special_key =
      kSpecialKeyMap[virtual_key.virtual_key()];
  if (special_key != KeyEvent::NO_SPECIALKEY) {
    key->set_special_key(special_key);

    // Currently the Mozc server expects that the modifier keys are always
    // empty for some special keys.  So we have to clear the modifier keys if
    // needed.
    ClearModifyerKeyIfNeeded(key, modifer_keys);
    return true;
  }

  // Modifier keys should be handled.
  // Due to the anomaly of Mozc protocol, |modifer_keys| should be set even
  // when this is the key-up message of the modifier key.
  switch (virtual_key.virtual_key()) {
    case VK_SHIFT:
      modifer_keys->insert(KeyEvent::SHIFT);
      return true;
    case VK_CONTROL:
      modifer_keys->insert(KeyEvent::CTRL);
      return true;
    case VK_MENU:
      modifer_keys->insert(KeyEvent::ALT);
      return true;
    case VK_CAPITAL:
      modifer_keys->insert(KeyEvent::CAPS);
      return true;
  }

  // The high-order bit of this value is set if the key is up.
  // http://msdn.microsoft.com/en-us/library/ms646322.aspx
  const UINT to_unicode_scancode =
      static_cast<UINT>(scan_code) | (is_key_down ? 0 : 0x8000);

  const DWORD to_unicode_flag = (is_menu_active ? 1 : 0);

  KeyboardStatus keyboard_status_wo_kana_lock = keyboard_status;
  keyboard_status_wo_kana_lock.SetState(VK_KANA, 0);

  bool has_valid_key_string = false;

  // Instead of using the actual toggle state of Kana-lock key, an expected
  // toggle state of the Kana-lock is emulated based on the IME open/close
  // state and conversion mode.  See b/3046717 for details.
  // Note that we never set |key_string| when Ctrl key is pressed because
  // no valid Kana character will be generated with Ctrl key. See b/9684668.
  const bool use_kana_input =
      behavior.prefer_kana_input && ime_state.open &&
      !keyboard_status_wo_kana_lock.IsPressed(VK_CONTROL) &&
      ((ime_state.logical_conversion_mode & IME_CMODE_NATIVE) ==
       IME_CMODE_NATIVE);

  if (use_kana_input) {
    // Make a snapshot of keyboard state, then update it so that the
    // Kana-lock state is 'locked'.
    KeyboardStatus keyboard_status_w_kana_lock = keyboard_status;
    const BYTE kKeyPressed = 0x80;
    const BYTE kKeyToggled = 0x1;
    keyboard_status_w_kana_lock.SetState(VK_KANA, kKeyPressed | kKeyToggled);

    WCHAR kana_codes[16] = {};
    const int kana_locked_length = keyboard->ToUnicode(
        virtual_key.virtual_key(), to_unicode_scancode,
        keyboard_status_w_kana_lock.status(), &kana_codes[0],
        arraysize(kana_codes),
        to_unicode_flag);
    if (kana_locked_length != 1) {
      return false;
    }
    const wchar_t kana_code = kana_codes[0];

    // TODO(yukawa): Move the following character conversion logic into
    //   mozc::Util as HalfWidthKatakanaToHiragana.
    const wchar_t whalf_katakana[] = {static_cast<wchar_t>(kana_code), L'\0' };
    string half_katakana, full_katakana, full_hiragana;
    mozc::Util::WideToUTF8(whalf_katakana, &half_katakana);
    mozc::Util::HalfWidthKatakanaToFullWidthKatakana(
        half_katakana.c_str(),
        &full_katakana);
    mozc::Util::KatakanaToHiragana(full_katakana.c_str(),
                                   &full_hiragana);
    key->set_key_string(full_hiragana);
    has_valid_key_string = true;
  }

  // To conform to Mozc protocol, we need special hack for VK_A, VK_B, ...,
  // VK_Z.  For these keys, currently we cannot support the current keyboard
  // layout.   For example, imagine a keyboard layout which generates
  // characters as follows.
  //    VK_A         -> 'a'
  //    VK_A + SHIFT -> '('
  // Unfortunately, the current Mozc protocol cannot handle these cases because
  // there is serious ambiguity betwen 'Key' and 'Character' in Mozc key
  // bindings.
  const bool is_vk_alpha =
      ('A' <= virtual_key.virtual_key() && virtual_key.virtual_key() <= 'Z');
  if (is_vk_alpha) {
    const char keycode = static_cast<char>(virtual_key.virtual_key());
    const size_t index = (keycode - 'A');
    if (keyboard_status_wo_kana_lock.IsToggled(VK_CAPITAL)) {
      // CapsLock is enabled.
      modifer_keys->insert(KeyEvent::CAPS);
      if (keyboard_status_wo_kana_lock.IsPressed(VK_SHIFT)) {
        if (!keyboard_status_wo_kana_lock.IsPressed(VK_CONTROL)) {
          modifer_keys->erase(KeyEvent::SHIFT);
        }
        key->set_key_code('a' + index);
      } else {
        key->set_key_code('A' + index);
      }
      if (keyboard_status_wo_kana_lock.IsPressed(VK_CONTROL)) {
        modifer_keys->insert(KeyEvent::CTRL);
        return true;
      }
      return true;
    }

    // CapsLock is not enabled.
    DCHECK(!keyboard_status_wo_kana_lock.IsPressed(VK_CAPITAL));
    if (keyboard_status_wo_kana_lock.IsPressed(VK_CONTROL)) {
      modifer_keys->insert(KeyEvent::CTRL);
      key->set_key_code('a' + index);
      return true;
    }
    if (keyboard_status_wo_kana_lock.IsPressed(VK_SHIFT)) {
      // In this cases, SHIFT modifier should be removed.
      modifer_keys->erase(KeyEvent::SHIFT);
      key->set_key_code('A' + index);
      return true;
    }

    key->set_key_code('a' + index);
    return true;
  }

  // Mozc key binding tool does not allow to use a key combination
  // |KeyEvent::CTRL| + |KeyEvent::Shift| + X except that X is VK_A, ..., or,
  // VK_Z, or other special keys defined in Mozc protocol such as backspace
  // or space.
  if (keyboard_status_wo_kana_lock.IsPressed(VK_SHIFT) &&
      keyboard_status_wo_kana_lock.IsPressed(VK_CONTROL)) {
    // Assume the server does not support this key combination.
    DCHECK(!is_vk_alpha);
    return false;
  }

  // To conform to Mozc protocol, we have to clear control modifier before
  // obtaining the unicode text.  For example, the mozc server expects Ctrl+^
  // to be sent as '^' + |KeyEvent::CTRL|.
  if (keyboard_status_wo_kana_lock.IsPressed(VK_CONTROL)) {
    // We can assume the shiftkey is not pressed here.
    DCHECK(!keyboard_status_wo_kana_lock.IsPressed(VK_SHIFT));

    keyboard_status_wo_kana_lock.SetState(VK_CONTROL, 0);
    keyboard_status_wo_kana_lock.SetState(VK_LCONTROL, 0);
    keyboard_status_wo_kana_lock.SetState(VK_RCONTROL, 0);
  }

  WCHAR codes[16] = {};
  int kana_unlocked_length = keyboard->ToUnicode(
      virtual_key.virtual_key(), to_unicode_scancode,
      keyboard_status_wo_kana_lock.status(), &codes[0],
      arraysize(codes), to_unicode_flag);

  // A workaround for b/3029665.
  // Keyboard drivers of the JIS keyboard do not produce a key code for
  // some key combinations such as SHIFT + '0' but the mozc server requires
  // the client to set a key code if it is in the kana mode.
  // So change the keycode for SHIFT + X to the one without SHIFT.
  // TODO(komatsu): Clarify the expected algorithm for the client.
  if ((kana_unlocked_length == 0) &&
      keyboard_status_wo_kana_lock.IsPressed(VK_SHIFT) &&
      has_valid_key_string) {
    // Remove shift key.
    keyboard_status_wo_kana_lock.SetState(VK_SHIFT, 0);
    keyboard_status_wo_kana_lock.SetState(VK_LSHIFT, 0);
    keyboard_status_wo_kana_lock.SetState(VK_RSHIFT, 0);

    kana_unlocked_length = keyboard->ToUnicode(
        virtual_key.virtual_key(), to_unicode_scancode,
        keyboard_status_wo_kana_lock.status(), &codes[0],
        arraysize(codes), to_unicode_flag);
  }

  if (kana_unlocked_length != 1) {
    return false;
  }

  // Remove the SHIFT modifier if CapsLock is not locked.
  if (modifer_keys->find(KeyEvent::CAPS) == modifer_keys->end()) {
    modifer_keys->erase(KeyEvent::SHIFT);
  }

  key->set_key_code(codes[0]);

  return true;
}

}  // namespace

KeyEventHandlerResult::KeyEventHandlerResult()
    : should_be_eaten(false),
      should_be_sent_to_server(false),
      succeeded(false) {
}

KeyEventHandlerResult KeyEventHandler::HandleKey(
    const VirtualKey &virtual_key,
    BYTE scan_code,
    bool is_key_down,
    const KeyboardStatus &keyboard_status,
    const InputBehavior &behavior,
    const InputState &ime_state,
    Win32KeyboardInterface *keyboard,
    mozc::commands::KeyEvent *key) {
  KeyEventHandlerResult result;

  if (key == nullptr) {
    result.succeeded = false;
    result.should_be_eaten = false;
    result.should_be_sent_to_server = false;
    return result;
  }

  if (behavior.disabled) {
    result.succeeded = true;
    result.should_be_eaten = false;
    result.should_be_sent_to_server = false;
    return result;
  }

  // There exist some keys which are ideally handled but the server has not
  // supported them yet.  In order not to pass these key events to the
  // application, we will trap them but do not send them to the server.
  if (IsNotimplementedKey(virtual_key)) {
    result.succeeded = true;
    result.should_be_eaten = true;
    result.should_be_sent_to_server = false;
    return result;
  }

  if (!ConvertToKeyEvent(virtual_key, scan_code, is_key_down, false,
                         behavior, ime_state, keyboard_status, keyboard, key)) {
    result.succeeded = true;
    result.should_be_eaten = false;
    result.should_be_sent_to_server = false;
    return result;
  }

  // We do not handle key message unless the key is one of force activation
  // keys.
  if (!ime_state.open) {
    // TODO(yukawa): Treat VK_PACKET as a direct mode key.
    const bool is_direct_mode_command =
        is_key_down &&
        KeyInfoUtil::ContainsKey(behavior.direct_mode_keys, *key);
    if (!is_direct_mode_command) {
      result.succeeded = true;
      result.should_be_eaten = false;
      result.should_be_sent_to_server = false;
      return result;
    }

    // For historical reasons, pass the visible conversion mode to the
    // converter.
    const DWORD repotring_mode = ime_state.visible_conversion_mode;
    commands::CompositionMode mozc_mode = commands::DIRECT;
    if (!ConversionModeUtil::GetMozcModeFromNativeMode(
            repotring_mode, &mozc_mode)) {
      result.succeeded = false;
      result.should_be_eaten = false;
      result.should_be_sent_to_server = false;
      return result;
    }
    key->set_activated(ime_state.open);
    key->set_mode(mozc_mode);
    result.succeeded = true;
    result.should_be_eaten = true;
    result.should_be_sent_to_server = true;
    return result;
  }

  DCHECK(ime_state.open);

  // For historical reasons, pass the visible conversion mode to the converter.
  const DWORD repotring_mode = ime_state.visible_conversion_mode;

  commands::CompositionMode mozc_mode = commands::HIRAGANA;
  if (!ConversionModeUtil::GetMozcModeFromNativeMode(
          repotring_mode, &mozc_mode)) {
    result.succeeded = false;
    result.should_be_eaten = false;
    result.should_be_sent_to_server = false;
    return result;
  }

  key->set_activated(ime_state.open);
  key->set_mode(mozc_mode);

  switch (virtual_key.virtual_key()) {
    case VK_SHIFT:
    case VK_CONTROL:
    case VK_MENU:
      if (is_key_down) {
        // Will not eat this message.
        result.succeeded = true;
        result.should_be_eaten = false;
        result.should_be_sent_to_server = false;
        return result;
      }
      if (ime_state.last_down_key.virtual_key() !=
          virtual_key.virtual_key()) {
        // Will not eat this message.
        result.succeeded = true;
        result.should_be_eaten = false;
        result.should_be_sent_to_server = false;
        return result;
      }
      // We will send this message to the server.
      result.succeeded = true;
      result.should_be_eaten = true;
      result.should_be_sent_to_server = true;
      return result;
      break;
  }

  // As commented above, we do not send key-up messages in general. Few
  // exceptional cases have already been examined.
  if (!is_key_down) {
    result.succeeded = true;
    result.should_be_eaten = false;
    result.should_be_sent_to_server = false;
    return result;
  }

  // We will send this message to the server.
  result.succeeded = true;
  result.should_be_eaten = true;
  result.should_be_sent_to_server = true;
  return result;
}

KeyEventHandlerResult KeyEventHandler::ImeProcessKey(
    const VirtualKey &virtual_key,
    BYTE scan_code,
    bool is_key_down,
    const KeyboardStatus &keyboard_status,
    const InputBehavior &behavior,
    const InputState &initial_state,
    const commands::Context &context,
    client::ClientInterface *client,
    Win32KeyboardInterface *keyboard,
    InputState *next_state,
    commands::Output *output) {
  // We will update kana-lock state even if the IME is disabled, including
  // safe-mode.
  KeyboardStatus new_keyboard_status;
  UnlockKanaLock(keyboard_status, keyboard, &new_keyboard_status);

  InputState dummy_state;
  if (next_state == nullptr) {
    next_state = &dummy_state;
  }
  *next_state = initial_state;

  Output dummy_output;
  if (output == nullptr) {
    output = &dummy_output;
  }
  output->Clear();

  // Although Mozc has not explicitly supported any key-up message, there exist
  // some situations where the client has to send key message when it receives
  // a key-up message.  Currently we have following exceptions.
  // - Shift/Control/Alt keys
  //    The Mozc protocol had originally allowed the client to ignore key-up
  //    events of these modifier keys but later has changed to expect the
  //    client to send a key message which contains only modifiers field and
  //    mode field to support b/2269058 and b/1995170.
  if (is_key_down) {
    // This is an ugly workaround to determine which key-up message for a
    // modifier key should be sent to the server.  Currently, the Mozc server
    // expects the client to send such a key-up message only when a modifier
    // key is released just after the same key is pressed, that is, any other
    // key is not pressed between the key-down and key-up of a modifier key.
    // Here are some examples, where [D] and [U] mean 'key down' and 'key up'.
    //   (1) [D]Shift -> [D]A -> [U]Shift -> [U]A
    //      In this case, only 'A' will be sent to the server
    //   (2) [D]Shift -> [U]Shift -> [D]A -> [U]A
    //      In this case, 'Shift' and 'A' will be sent to the server.
    //   (3) [D]Shift -> [D]Control -> [U]Shift -> [U]Control
    //      In this case, no key message will be sent to the server.
    //   (4) [D]Shift -> [D]Control -> [U]Control -> [U]Shift
    //      In this case, 'Control+Shift' will be sent to the server.  Note
    //      that |KeyEvent::modifier_keys| will contain all the modifier keys
    //      when the client receives '[U]Control'.
    // Unfortunately, it is currently client's responsibility to remember the
    // key sequence to generate appropriate key messages as expected by the
    // server.  Strictly speaking, the Mozc client is actually stateful in
    // this sense.
    next_state->last_down_key = virtual_key;
  }

  KeyEvent key;
  KeyEventHandlerResult result = HandleKey(
      virtual_key, scan_code, is_key_down, keyboard_status,
      behavior, initial_state, keyboard, &key);

  if (!result.succeeded) {
    return result;
  }

  if (!result.should_be_sent_to_server) {
    return result;
  }

  if (!client->TestSendKeyWithContext(key, context, output)) {
    result.succeeded = false;
    return result;
  }

  if (!output->has_consumed()) {
    result.succeeded = false;
    return result;
  }

  if (output->has_status()) {
    if (!mozc::win32::ConversionModeUtil::ConvertStatusFromMozcToNative(
            output->status(), behavior.prefer_kana_input,
            &next_state->open,
            &next_state->logical_conversion_mode,
            &next_state->visible_conversion_mode)) {
      result.succeeded = false;
      return result;
    }
  }

  result.should_be_eaten = output->consumed();
  return result;
}

KeyEventHandlerResult KeyEventHandler::ImeToAsciiEx(
    const VirtualKey &virtual_key,
    BYTE scan_code,
    bool is_key_down,
    const KeyboardStatus &keyboard_status,
    const InputBehavior &behavior,
    const InputState &initial_state,
    const commands::Context &context,
    client::ClientInterface *client,
    Win32KeyboardInterface *keyboard,
    InputState *next_state,
    commands::Output *output) {
  KeyboardStatus new_keyboard_status;
  UnlockKanaLock(keyboard_status, keyboard, &new_keyboard_status);

  InputState dummy_state;
  if (next_state == nullptr) {
    next_state = &dummy_state;
  }
  *next_state = initial_state;

  Output dummy_output;
  if (output == nullptr) {
    output = &dummy_output;
  }
  output->Clear();

  KeyEvent key;
  KeyEventHandlerResult result = HandleKey(
      virtual_key, scan_code, is_key_down, keyboard_status, behavior,
      initial_state, keyboard, &key);

  if (!result.succeeded) {
    return result;
  }

  if (!result.should_be_sent_to_server) {
    return result;
  }

  if (!client->SendKeyWithContext(key, context, output)) {
    result.succeeded = false;
    return result;
  }

  // Launch tool if required.
  MaybeSpawnTool(client, output);

  if (!output->has_consumed()) {
    result.succeeded = false;
    return result;
  }

  if (output->has_status()) {
    if (!mozc::win32::ConversionModeUtil::ConvertStatusFromMozcToNative(
            output->status(), behavior.prefer_kana_input,
            &next_state->open,
            &next_state->logical_conversion_mode,
            &next_state->visible_conversion_mode)) {
      result.succeeded = false;
      return result;
    }
  }

  result.should_be_eaten = output->consumed();
  return result;
}

bool KeyEventHandler::ConvertToKeyEvent(
    const VirtualKey &virtual_key,
    BYTE scan_code,
    bool is_key_down,
    bool is_menu_active,
    const InputBehavior &behavior,
    const InputState &ime_state,
    const KeyboardStatus &keyboard_status,
    Win32KeyboardInterface *keyboard,
    mozc::commands::KeyEvent *key) {
  // Since Mozc protocol requires tricky conditions for modifiers, using set
  // container makes the the main part of key event conversion simple rather
  // than using vector-like container.
  set<KeyEvent::ModifierKey> modifiers;
  const bool result = ConvertToKeyEventMain(
      virtual_key,
      scan_code,
      is_key_down,
      is_menu_active,
      behavior,
      ime_state,
      keyboard_status,
      keyboard,
      key,
      &modifiers);
  if (!result) {
    return false;
  }

  // Updates |modifier_keys| field based on the returned set of modifier keys.
  for (set<KeyEvent::ModifierKey>::const_iterator i = modifiers.begin();
       i != modifiers.end(); ++i) {
    key->add_modifier_keys(*i);
  }
  return true;
}

void KeyEventHandler::UnlockKanaLock(
    const KeyboardStatus &keyboard_status,
    Win32KeyboardInterface *keyboard,
    KeyboardStatus *new_keyboard_status) {
  KeyboardStatus dummy_status;
  if (new_keyboard_status == nullptr) {
    new_keyboard_status = &dummy_status;
  }

  *new_keyboard_status = keyboard_status;

  if (keyboard->IsKanaLocked(keyboard_status)) {
    new_keyboard_status->SetState(VK_KANA, 0);
    keyboard->SetKeyboardState(*new_keyboard_status);
  }
}

void KeyEventHandler::MaybeSpawnTool(mozc::client::ClientInterface *client,
                                     commands::Output *output) {
  // URL handling:
  // When Output::url is set, MozcTool is supposed to be launched by client.
  // At this moment, we disable this feature as it may cause security hole.
  // if (output->has_url()) {
  //   client->OpenBrowser(output->url());
  //   output->clear_url();
  // }

  // launch_tool_mode handling:
  // When Output::launch_tool_mode is set, MozcTool is supposed to be launched
  // by client with specified mode.
  // TODO(team):  move it to better place.
  if (output->has_launch_tool_mode()) {
    string mode;
    switch (output->launch_tool_mode()) {
      case commands::Output::CONFIG_DIALOG:
        mode = "config_dialog";
        break;
      case commands::Output::WORD_REGISTER_DIALOG:
        mode = "word_register_dialog";
        break;
      case commands::Output::DICTIONARY_TOOL:
        mode = "dictionary_tool";
        break;
      case commands::Output::NO_TOOL:
      default:
        // Do nothing.
        break;
    }
    output->clear_launch_tool_mode();
    if (!mode.empty()) {
      client->LaunchTool(mode, "");
    }
  }
}

void KeyEventHandler::UpdateBehaviorInImeProcessKey(
    const VirtualKey &virtual_key,
    bool is_key_down,
    const InputState &initial_state,
    InputBehavior *behavior) {
  if (behavior == nullptr) {
    return;
  }

  if (!initial_state.open) {
    return;
  }

  if (!behavior->use_romaji_key_to_toggle_input_style) {
    return;
  }

  switch (virtual_key.virtual_key()) {
    // Do not discriminate between VK_DBE_ROMAN and VK_DBE_NOROMAN because
    // these key states are not per-thread nor per-process but system-wide
    // or session-wide, which means that any key stroke in another
    // thread/process may change the global toggle state at any time.
    case VK_DBE_ROMAN:
    case VK_DBE_NOROMAN:
      if (is_key_down) {
        // Flip the input style if this is key down event.
        behavior->prefer_kana_input = !behavior->prefer_kana_input;
      }
      break;
    default:
      // Otherwise, do nothing.
      break;
  }
}
}  // namespace win32
}  // namespace mozc