The Tor Browser: widget/cocoa/TextInputHandler.mm@ac0c01689b40 (annotated)

widget/cocoa/TextInputHandler.mm@ac0c01689b40 (annotated)

widget/cocoa/TextInputHandler.mm

Thu, 15 Jan 2015 15:59:08 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 15:59:08 +0100
branch: TOR_BUG_9701
changeset 10: ac0c01689b40
permissions: -rw-r--r--

Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 sw=2 et tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "mozilla/ArrayUtils.h"
 #include "TextInputHandler.h"
 #ifdef MOZ_LOGGING
 #define FORCE_PR_LOG /* Allow logging in the release build */
 #endif // MOZ_LOGGING
 #include "prlog.h"
 #include "mozilla/MiscEvents.h"
 #include "mozilla/MouseEvents.h"
 #include "mozilla/TextEvents.h"
 #include "nsChildView.h"
 #include "nsObjCExceptions.h"
 #include "nsBidiUtils.h"
 #include "nsToolkit.h"
 #include "nsCocoaUtils.h"
 #include "WidgetUtils.h"
 #include "nsPrintfCString.h"
 #ifdef __LP64__
 #include "ComplexTextInputPanel.h"
 #include <objc/runtime.h>
 #endif // __LP64__
 #ifdef MOZ_LOGGING
 #define FORCE_PR_LOG
 #endif
 #include "prlog.h"
 #ifndef __LP64__
 enum {
   // Currently focused ChildView (while this TSM document is active).
   // Transient (only set while TSMProcessRawKeyEvent() is processing a key
   // event), and the ChildView will be retained and released around the call
   // to TSMProcessRawKeyEvent() -- so it can be weak.
   kFocusedChildViewTSMDocPropertyTag  = 'GKFV', // type ChildView* [WEAK]
 };
 // Undocumented HIToolbox function used by WebKit to allow Carbon-based IME
 // to work in a Cocoa-based browser (like Safari or Cocoa-widgets Firefox).
 // (Recent WebKit versions actually use a thin wrapper around this function
 // called WKSendKeyEventToTSM().)
 //
 // Calling TSMProcessRawKeyEvent() from ChildView's keyDown: and keyUp:
 // methods (when the ChildView is a plugin view) bypasses Cocoa's IME
 // infrastructure and (instead) causes Carbon TSM events to be sent on each
 // NSKeyDown event.  We install a Carbon event handler
 // (PluginKeyEventsHandler()) to catch these events and pass them to Gecko
 // (which in turn passes them to the plugin).
 extern "C" long TSMProcessRawKeyEvent(EventRef carbonEvent);
 #endif // __LP64__
 using namespace mozilla;
 using namespace mozilla::widget;
 #ifdef PR_LOGGING
 PRLogModuleInfo* gLog = nullptr;
 static const char*
 OnOrOff(bool aBool)
 {
   return aBool ? "ON" : "off";
 }
 static const char*
 TrueOrFalse(bool aBool)
 {
   return aBool ? "TRUE" : "FALSE";
 }
 static const char*
 GetKeyNameForNativeKeyCode(unsigned short aNativeKeyCode)
 {
   switch (aNativeKeyCode) {
     case kVK_Escape:              return "Escape";
     case kVK_RightCommand:        return "Right-Command";
     case kVK_Command:             return "Command";
     case kVK_Shift:               return "Shift";
     case kVK_CapsLock:            return "CapsLock";
     case kVK_Option:              return "Option";
     case kVK_Control:             return "Control";
     case kVK_RightShift:          return "Right-Shift";
     case kVK_RightOption:         return "Right-Option";
     case kVK_RightControl:        return "Right-Control";
     case kVK_ANSI_KeypadClear:    return "Clear";
     case kVK_F1:                  return "F1";
     case kVK_F2:                  return "F2";
     case kVK_F3:                  return "F3";
     case kVK_F4:                  return "F4";
     case kVK_F5:                  return "F5";
     case kVK_F6:                  return "F6";
     case kVK_F7:                  return "F7";
     case kVK_F8:                  return "F8";
     case kVK_F9:                  return "F9";
     case kVK_F10:                 return "F10";
     case kVK_F11:                 return "F11";
     case kVK_F12:                 return "F12";
     case kVK_F13:                 return "F13/PrintScreen";
     case kVK_F14:                 return "F14/ScrollLock";
     case kVK_F15:                 return "F15/Pause";
     case kVK_ANSI_Keypad0:        return "NumPad-0";
     case kVK_ANSI_Keypad1:        return "NumPad-1";
     case kVK_ANSI_Keypad2:        return "NumPad-2";
     case kVK_ANSI_Keypad3:        return "NumPad-3";
     case kVK_ANSI_Keypad4:        return "NumPad-4";
     case kVK_ANSI_Keypad5:        return "NumPad-5";
     case kVK_ANSI_Keypad6:        return "NumPad-6";
     case kVK_ANSI_Keypad7:        return "NumPad-7";
     case kVK_ANSI_Keypad8:        return "NumPad-8";
     case kVK_ANSI_Keypad9:        return "NumPad-9";
     case kVK_ANSI_KeypadMultiply: return "NumPad-*";
     case kVK_ANSI_KeypadPlus:     return "NumPad-+";
     case kVK_ANSI_KeypadMinus:    return "NumPad--";
     case kVK_ANSI_KeypadDecimal:  return "NumPad-.";
     case kVK_ANSI_KeypadDivide:   return "NumPad-/";
     case kVK_ANSI_KeypadEquals:   return "NumPad-=";
     case kVK_ANSI_KeypadEnter:    return "NumPad-Enter";
     case kVK_Return:              return "Return";
     case kVK_Powerbook_KeypadEnter: return "NumPad-EnterOnPowerBook";
     case kVK_PC_Insert:           return "Insert/Help";
     case kVK_PC_Delete:           return "Delete";
     case kVK_Tab:                 return "Tab";
     case kVK_PC_Backspace:        return "Backspace";
     case kVK_Home:                return "Home";
     case kVK_End:                 return "End";
     case kVK_PageUp:              return "PageUp";
     case kVK_PageDown:            return "PageDown";
     case kVK_LeftArrow:           return "LeftArrow";
     case kVK_RightArrow:          return "RightArrow";
     case kVK_UpArrow:             return "UpArrow";
     case kVK_DownArrow:           return "DownArrow";
     case kVK_PC_ContextMenu:      return "ContextMenu";
     case kVK_Function:            return "Function";
     case kVK_VolumeUp:            return "VolumeUp";
     case kVK_VolumeDown:          return "VolumeDown";
     case kVK_Mute:                return "Mute";
     case kVK_ISO_Section:         return "ISO_Section";
     case kVK_JIS_Yen:             return "JIS_Yen";
     case kVK_JIS_Underscore:      return "JIS_Underscore";
     case kVK_JIS_KeypadComma:     return "JIS_KeypadComma";
     case kVK_JIS_Eisu:            return "JIS_Eisu";
     case kVK_JIS_Kana:            return "JIS_Kana";
     case kVK_ANSI_A:              return "A";
     case kVK_ANSI_B:              return "B";
     case kVK_ANSI_C:              return "C";
     case kVK_ANSI_D:              return "D";
     case kVK_ANSI_E:              return "E";
     case kVK_ANSI_F:              return "F";
     case kVK_ANSI_G:              return "G";
     case kVK_ANSI_H:              return "H";
     case kVK_ANSI_I:              return "I";
     case kVK_ANSI_J:              return "J";
     case kVK_ANSI_K:              return "K";
     case kVK_ANSI_L:              return "L";
     case kVK_ANSI_M:              return "M";
     case kVK_ANSI_N:              return "N";
     case kVK_ANSI_O:              return "O";
     case kVK_ANSI_P:              return "P";
     case kVK_ANSI_Q:              return "Q";
     case kVK_ANSI_R:              return "R";
     case kVK_ANSI_S:              return "S";
     case kVK_ANSI_T:              return "T";
     case kVK_ANSI_U:              return "U";
     case kVK_ANSI_V:              return "V";
     case kVK_ANSI_W:              return "W";
     case kVK_ANSI_X:              return "X";
     case kVK_ANSI_Y:              return "Y";
     case kVK_ANSI_Z:              return "Z";
     case kVK_ANSI_1:              return "1";
     case kVK_ANSI_2:              return "2";
     case kVK_ANSI_3:              return "3";
     case kVK_ANSI_4:              return "4";
     case kVK_ANSI_5:              return "5";
     case kVK_ANSI_6:              return "6";
     case kVK_ANSI_7:              return "7";
     case kVK_ANSI_8:              return "8";
     case kVK_ANSI_9:              return "9";
     case kVK_ANSI_0:              return "0";
     case kVK_ANSI_Equal:          return "Equal";
     case kVK_ANSI_Minus:          return "Minus";
     case kVK_ANSI_RightBracket:   return "RightBracket";
     case kVK_ANSI_LeftBracket:    return "LeftBracket";
     case kVK_ANSI_Quote:          return "Quote";
     case kVK_ANSI_Semicolon:      return "Semicolon";
     case kVK_ANSI_Backslash:      return "Backslash";
     case kVK_ANSI_Comma:          return "Comma";
     case kVK_ANSI_Slash:          return "Slash";
     case kVK_ANSI_Period:         return "Period";
     case kVK_ANSI_Grave:          return "Grave";
     default:                      return "undefined";
   }
 }
 static const char*
 GetCharacters(const NSString* aString)
 {
   nsAutoString str;
   nsCocoaUtils::GetStringForNSString(aString, str);
   if (str.IsEmpty()) {
     return "";
   }
   nsAutoString escapedStr;
   for (uint32_t i = 0; i < str.Length(); i++) {
     char16_t ch = str[i];
     if (ch < 0x20) {
       nsPrintfCString utf8str("(U+%04X)", ch);
       escapedStr += NS_ConvertUTF8toUTF16(utf8str);
     } else if (ch <= 0x7E) {
       escapedStr += ch;
     } else {
       nsPrintfCString utf8str("(U+%04X)", ch);
       escapedStr += ch;
       escapedStr += NS_ConvertUTF8toUTF16(utf8str);
     }
   }
   // the result will be freed automatically by cocoa.
   NSString* result = nsCocoaUtils::ToNSString(escapedStr);
   return [result UTF8String];
 }
 static const char*
 GetCharacters(const CFStringRef aString)
 {
   const NSString* str = reinterpret_cast<const NSString*>(aString);
   return GetCharacters(str);
 }
 static const char*
 GetNativeKeyEventType(NSEvent* aNativeEvent)
 {
   switch ([aNativeEvent type]) {
     case NSKeyDown:      return "NSKeyDown";
     case NSKeyUp:        return "NSKeyUp";
     case NSFlagsChanged: return "NSFlagsChanged";
     default:             return "not key event";
   }
 }
 static const char*
 GetGeckoKeyEventType(const WidgetEvent& aEvent)
 {
   switch (aEvent.message) {
     case NS_KEY_DOWN:    return "NS_KEY_DOWN";
     case NS_KEY_UP:      return "NS_KEY_UP";
     case NS_KEY_PRESS:   return "NS_KEY_PRESS";
     default:             return "not key event";
   }
 }
 static const char*
 GetRangeTypeName(uint32_t aRangeType)
 {
   switch (aRangeType) {
     case NS_TEXTRANGE_RAWINPUT:
       return "NS_TEXTRANGE_RAWINPUT";
     case NS_TEXTRANGE_CONVERTEDTEXT:
       return "NS_TEXTRANGE_CONVERTEDTEXT";
     case NS_TEXTRANGE_SELECTEDRAWTEXT:
       return "NS_TEXTRANGE_SELECTEDRAWTEXT";
     case NS_TEXTRANGE_SELECTEDCONVERTEDTEXT:
       return "NS_TEXTRANGE_SELECTEDCONVERTEDTEXT";
     case NS_TEXTRANGE_CARETPOSITION:
       return "NS_TEXTRANGE_CARETPOSITION";
     default:
       return "invalid range type";
   }
 }
 static const char*
 GetWindowLevelName(NSInteger aWindowLevel)
 {
   switch (aWindowLevel) {
     case kCGBaseWindowLevelKey:
       return "kCGBaseWindowLevelKey (NSNormalWindowLevel)";
     case kCGMinimumWindowLevelKey:
       return "kCGMinimumWindowLevelKey";
     case kCGDesktopWindowLevelKey:
       return "kCGDesktopWindowLevelKey";
     case kCGBackstopMenuLevelKey:
       return "kCGBackstopMenuLevelKey";
     case kCGNormalWindowLevelKey:
       return "kCGNormalWindowLevelKey";
     case kCGFloatingWindowLevelKey:
       return "kCGFloatingWindowLevelKey (NSFloatingWindowLevel)";
     case kCGTornOffMenuWindowLevelKey:
       return "kCGTornOffMenuWindowLevelKey (NSSubmenuWindowLevel, NSTornOffMenuWindowLevel)";
     case kCGDockWindowLevelKey:
       return "kCGDockWindowLevelKey (NSDockWindowLevel)";
     case kCGMainMenuWindowLevelKey:
       return "kCGMainMenuWindowLevelKey (NSMainMenuWindowLevel)";
     case kCGStatusWindowLevelKey:
       return "kCGStatusWindowLevelKey (NSStatusWindowLevel)";
     case kCGModalPanelWindowLevelKey:
       return "kCGModalPanelWindowLevelKey (NSModalPanelWindowLevel)";
     case kCGPopUpMenuWindowLevelKey:
       return "kCGPopUpMenuWindowLevelKey (NSPopUpMenuWindowLevel)";
     case kCGDraggingWindowLevelKey:
       return "kCGDraggingWindowLevelKey";
     case kCGScreenSaverWindowLevelKey:
       return "kCGScreenSaverWindowLevelKey (NSScreenSaverWindowLevel)";
     case kCGMaximumWindowLevelKey:
       return "kCGMaximumWindowLevelKey";
     case kCGOverlayWindowLevelKey:
       return "kCGOverlayWindowLevelKey";
     case kCGHelpWindowLevelKey:
       return "kCGHelpWindowLevelKey";
     case kCGUtilityWindowLevelKey:
       return "kCGUtilityWindowLevelKey";
     case kCGDesktopIconWindowLevelKey:
       return "kCGDesktopIconWindowLevelKey";
     case kCGCursorWindowLevelKey:
       return "kCGCursorWindowLevelKey";
     case kCGNumberOfWindowLevelKeys:
       return "kCGNumberOfWindowLevelKeys";
     default:
       return "unknown window level";
   }
 }
 #endif // #ifdef PR_LOGGING
 static bool
 IsControlChar(uint32_t aCharCode)
 {
   return aCharCode < ' ' || aCharCode == 0x7F;
 }
 static uint32_t gHandlerInstanceCount = 0;
 static TISInputSourceWrapper gCurrentInputSource;
 static void
 InitLogModule()
 {
 #ifdef PR_LOGGING
   // Clear() is always called when TISInputSourceWrappper is created.
   if (!gLog) {
     gLog = PR_NewLogModule("TextInputHandlerWidgets");
     TextInputHandler::DebugPrintAllKeyboardLayouts();
     IMEInputHandler::DebugPrintAllIMEModes();
   }
 #endif
 }
 static void
 InitCurrentInputSource()
 {
   if (gHandlerInstanceCount > 0 &&
       !gCurrentInputSource.IsInitializedByCurrentInputSource()) {
     gCurrentInputSource.InitByCurrentInputSource();
   }
 }
 static void
 FinalizeCurrentInputSource()
 {
   gCurrentInputSource.Clear();
 }
 #pragma mark -
 /******************************************************************************
  *
  *  TISInputSourceWrapper implementation
  *
  ******************************************************************************/
 // static
 TISInputSourceWrapper&
 TISInputSourceWrapper::CurrentInputSource()
 {
   InitCurrentInputSource();
   return gCurrentInputSource;
 }
 bool
 TISInputSourceWrapper::TranslateToString(UInt32 aKeyCode, UInt32 aModifiers,
                                          UInt32 aKbType, nsAString &aStr)
 {
   aStr.Truncate();
   const UCKeyboardLayout* UCKey = GetUCKeyboardLayout();
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TISInputSourceWrapper::TranslateToString, aKeyCode=0x%X, "
      "aModifiers=0x%X, aKbType=0x%X UCKey=%p\n    "
      "Shift: %s, Ctrl: %s, Opt: %s, Cmd: %s, CapsLock: %s, NumLock: %s",
      this, aKeyCode, aModifiers, aKbType, UCKey,
      OnOrOff(aModifiers & shiftKey), OnOrOff(aModifiers & controlKey),
      OnOrOff(aModifiers & optionKey), OnOrOff(aModifiers & cmdKey),
      OnOrOff(aModifiers & alphaLock),
      OnOrOff(aModifiers & kEventKeyModifierNumLockMask)));
   NS_ENSURE_TRUE(UCKey, false);
   UInt32 deadKeyState = 0;
   UniCharCount len;
   UniChar chars[5];
   OSStatus err = ::UCKeyTranslate(UCKey, aKeyCode,
                                   kUCKeyActionDown, aModifiers >> 8,
                                   aKbType, kUCKeyTranslateNoDeadKeysMask,
                                   &deadKeyState, 5, &len, chars);
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TISInputSourceWrapper::TranslateToString, err=0x%X, len=%llu",
      this, err, len));
   NS_ENSURE_TRUE(err == noErr, false);
   if (len == 0) {
     return true;
   }
   NS_ENSURE_TRUE(EnsureStringLength(aStr, len), false);
   NS_ASSERTION(sizeof(char16_t) == sizeof(UniChar),
                "size of char16_t and size of UniChar are different");
   memcpy(aStr.BeginWriting(), chars, len * sizeof(char16_t));
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TISInputSourceWrapper::TranslateToString, aStr=\"%s\"",
      this, NS_ConvertUTF16toUTF8(aStr).get()));
   return true;
 }
 uint32_t
 TISInputSourceWrapper::TranslateToChar(UInt32 aKeyCode, UInt32 aModifiers,
                                        UInt32 aKbType)
 {
   nsAutoString str;
   if (!TranslateToString(aKeyCode, aModifiers, aKbType, str) ||
       str.Length() != 1) {
     return 0;
   }
   return static_cast<uint32_t>(str.CharAt(0));
 }
 void
 TISInputSourceWrapper::InitByInputSourceID(const char* aID)
 {
   Clear();
   if (!aID)
     return;
   CFStringRef idstr = ::CFStringCreateWithCString(kCFAllocatorDefault, aID,
                                                   kCFStringEncodingASCII);
   InitByInputSourceID(idstr);
   ::CFRelease(idstr);
 }
 void
 TISInputSourceWrapper::InitByInputSourceID(const nsAFlatString &aID)
 {
   Clear();
   if (aID.IsEmpty())
     return;
   CFStringRef idstr = ::CFStringCreateWithCharacters(kCFAllocatorDefault,
                                                      reinterpret_cast<const UniChar*>(aID.get()),
                                                      aID.Length());
   InitByInputSourceID(idstr);
   ::CFRelease(idstr);
 }
 void
 TISInputSourceWrapper::InitByInputSourceID(const CFStringRef aID)
 {
   Clear();
   if (!aID)
     return;
   const void* keys[] = { kTISPropertyInputSourceID };
   const void* values[] = { aID };
   CFDictionaryRef filter =
   ::CFDictionaryCreate(kCFAllocatorDefault, keys, values, 1, NULL, NULL);
   NS_ASSERTION(filter, "failed to create the filter");
   mInputSourceList = ::TISCreateInputSourceList(filter, true);
   ::CFRelease(filter);
   if (::CFArrayGetCount(mInputSourceList) > 0) {
     mInputSource = static_cast<TISInputSourceRef>(
       const_cast<void *>(::CFArrayGetValueAtIndex(mInputSourceList, 0)));
     if (IsKeyboardLayout()) {
       mKeyboardLayout = mInputSource;
     }
   }
 }
 void
 TISInputSourceWrapper::InitByLayoutID(SInt32 aLayoutID,
                                       bool aOverrideKeyboard)
 {
   // NOTE: Doument new layout IDs in TextInputHandler.h when you add ones.
   switch (aLayoutID) {
     case 0:
       InitByInputSourceID("com.apple.keylayout.US");
       break;
     case 1:
       InitByInputSourceID("com.apple.keylayout.Greek");
       break;
     case 2:
       InitByInputSourceID("com.apple.keylayout.German");
       break;
     case 3:
       InitByInputSourceID("com.apple.keylayout.Swedish-Pro");
       break;
     case 4:
       InitByInputSourceID("com.apple.keylayout.DVORAK-QWERTYCMD");
       break;
     case 5:
       InitByInputSourceID("com.apple.keylayout.Thai");
       break;
     case 6:
       InitByInputSourceID("com.apple.keylayout.Arabic");
       break;
     case 7:
       InitByInputSourceID("com.apple.keylayout.French");
       break;
     case 8:
       InitByInputSourceID("com.apple.keylayout.Hebrew");
       break;
     case 9:
       InitByInputSourceID("com.apple.keylayout.Lithuanian");
       break;
     case 10:
       InitByInputSourceID("com.apple.keylayout.Norwegian");
       break;
     case 11:
       InitByInputSourceID("com.apple.keylayout.Spanish");
       break;
     default:
       Clear();
       break;
   }
   mOverrideKeyboard = aOverrideKeyboard;
 }
 void
 TISInputSourceWrapper::InitByCurrentInputSource()
 {
   Clear();
   mInputSource = ::TISCopyCurrentKeyboardInputSource();
   mKeyboardLayout = ::TISCopyInputMethodKeyboardLayoutOverride();
   if (!mKeyboardLayout) {
     mKeyboardLayout = ::TISCopyCurrentKeyboardLayoutInputSource();
   }
   // If this causes composition, the current keyboard layout may input non-ASCII
   // characters such as Japanese Kana characters or Hangul characters.
   // However, we need to set ASCII characters to DOM key events for consistency
   // with other platforms.
   if (IsOpenedIMEMode()) {
     TISInputSourceWrapper tis(mKeyboardLayout);
     if (!tis.IsASCIICapable()) {
       mKeyboardLayout =
         ::TISCopyCurrentASCIICapableKeyboardLayoutInputSource();
     }
   }
 }
 void
 TISInputSourceWrapper::InitByCurrentKeyboardLayout()
 {
   Clear();
   mInputSource = ::TISCopyCurrentKeyboardLayoutInputSource();
   mKeyboardLayout = mInputSource;
 }
 void
 TISInputSourceWrapper::InitByCurrentASCIICapableInputSource()
 {
   Clear();
   mInputSource = ::TISCopyCurrentASCIICapableKeyboardInputSource();
   mKeyboardLayout = ::TISCopyInputMethodKeyboardLayoutOverride();
   if (mKeyboardLayout) {
     TISInputSourceWrapper tis(mKeyboardLayout);
     if (!tis.IsASCIICapable()) {
       mKeyboardLayout = nullptr;
     }
   }
   if (!mKeyboardLayout) {
     mKeyboardLayout =
       ::TISCopyCurrentASCIICapableKeyboardLayoutInputSource();
   }
 }
 void
 TISInputSourceWrapper::InitByCurrentASCIICapableKeyboardLayout()
 {
   Clear();
   mInputSource = ::TISCopyCurrentASCIICapableKeyboardLayoutInputSource();
   mKeyboardLayout = mInputSource;
 }
 void
 TISInputSourceWrapper::InitByCurrentInputMethodKeyboardLayoutOverride()
 {
   Clear();
   mInputSource = ::TISCopyInputMethodKeyboardLayoutOverride();
   mKeyboardLayout = mInputSource;
 }
 void
 TISInputSourceWrapper::InitByTISInputSourceRef(TISInputSourceRef aInputSource)
 {
   Clear();
   mInputSource = aInputSource;
   if (IsKeyboardLayout()) {
     mKeyboardLayout = mInputSource;
   }
 }
 void
 TISInputSourceWrapper::InitByLanguage(CFStringRef aLanguage)
 {
   Clear();
   mInputSource = ::TISCopyInputSourceForLanguage(aLanguage);
   if (IsKeyboardLayout()) {
     mKeyboardLayout = mInputSource;
   }
 }
 const UCKeyboardLayout*
 TISInputSourceWrapper::GetUCKeyboardLayout()
 {
   NS_ENSURE_TRUE(mKeyboardLayout, nullptr);
   if (mUCKeyboardLayout) {
     return mUCKeyboardLayout;
   }
   CFDataRef uchr = static_cast<CFDataRef>(
     ::TISGetInputSourceProperty(mKeyboardLayout,
                                 kTISPropertyUnicodeKeyLayoutData));
   // We should be always able to get the layout here.
   NS_ENSURE_TRUE(uchr, nullptr);
   mUCKeyboardLayout =
     reinterpret_cast<const UCKeyboardLayout*>(CFDataGetBytePtr(uchr));
   return mUCKeyboardLayout;
 }
 bool
 TISInputSourceWrapper::GetBoolProperty(const CFStringRef aKey)
 {
   CFBooleanRef ret = static_cast<CFBooleanRef>(
     ::TISGetInputSourceProperty(mInputSource, aKey));
   return ::CFBooleanGetValue(ret);
 }
 bool
 TISInputSourceWrapper::GetStringProperty(const CFStringRef aKey,
                                          CFStringRef &aStr)
 {
   aStr = static_cast<CFStringRef>(
     ::TISGetInputSourceProperty(mInputSource, aKey));
   return aStr != nullptr;
 }
 bool
 TISInputSourceWrapper::GetStringProperty(const CFStringRef aKey,
                                          nsAString &aStr)
 {
   CFStringRef str;
   GetStringProperty(aKey, str);
   nsCocoaUtils::GetStringForNSString((const NSString*)str, aStr);
   return !aStr.IsEmpty();
 }
 bool
 TISInputSourceWrapper::IsOpenedIMEMode()
 {
   NS_ENSURE_TRUE(mInputSource, false);
   if (!IsIMEMode())
     return false;
   return !IsASCIICapable();
 }
 bool
 TISInputSourceWrapper::IsIMEMode()
 {
   NS_ENSURE_TRUE(mInputSource, false);
   CFStringRef str;
   GetInputSourceType(str);
   NS_ENSURE_TRUE(str, false);
   return ::CFStringCompare(kTISTypeKeyboardInputMode,
                            str, 0) == kCFCompareEqualTo;
 }
 bool
 TISInputSourceWrapper::IsKeyboardLayout()
 {
   NS_ENSURE_TRUE(mInputSource, false);
   CFStringRef str;
   GetInputSourceType(str);
   NS_ENSURE_TRUE(str, false);
   return ::CFStringCompare(kTISTypeKeyboardLayout,
                            str, 0) == kCFCompareEqualTo;
 }
 bool
 TISInputSourceWrapper::GetLanguageList(CFArrayRef &aLanguageList)
 {
   NS_ENSURE_TRUE(mInputSource, false);
   aLanguageList = static_cast<CFArrayRef>(
     ::TISGetInputSourceProperty(mInputSource,
                                 kTISPropertyInputSourceLanguages));
   return aLanguageList != nullptr;
 }
 bool
 TISInputSourceWrapper::GetPrimaryLanguage(CFStringRef &aPrimaryLanguage)
 {
   NS_ENSURE_TRUE(mInputSource, false);
   CFArrayRef langList;
   NS_ENSURE_TRUE(GetLanguageList(langList), false);
   if (::CFArrayGetCount(langList) == 0)
     return false;
   aPrimaryLanguage =
     static_cast<CFStringRef>(::CFArrayGetValueAtIndex(langList, 0));
   return aPrimaryLanguage != nullptr;
 }
 bool
 TISInputSourceWrapper::GetPrimaryLanguage(nsAString &aPrimaryLanguage)
 {
   NS_ENSURE_TRUE(mInputSource, false);
   CFStringRef primaryLanguage;
   NS_ENSURE_TRUE(GetPrimaryLanguage(primaryLanguage), false);
   nsCocoaUtils::GetStringForNSString((const NSString*)primaryLanguage,
                                      aPrimaryLanguage);
   return !aPrimaryLanguage.IsEmpty();
 }
 bool
 TISInputSourceWrapper::IsForRTLLanguage()
 {
   if (mIsRTL < 0) {
     // Get the input character of the 'A' key of ANSI keyboard layout.
     nsAutoString str;
     bool ret = TranslateToString(kVK_ANSI_A, 0, eKbdType_ANSI, str);
     NS_ENSURE_TRUE(ret, ret);
     char16_t ch = str.IsEmpty() ? char16_t(0) : str.CharAt(0);
     mIsRTL = UCS2_CHAR_IS_BIDI(ch) || ch == 0xD802 || ch == 0xD803;
   }
   return mIsRTL != 0;
 }
 bool
 TISInputSourceWrapper::IsInitializedByCurrentInputSource()
 {
   return mInputSource == ::TISCopyCurrentKeyboardInputSource();
 }
 void
 TISInputSourceWrapper::Select()
 {
   if (!mInputSource)
     return;
   ::TISSelectInputSource(mInputSource);
 }
 void
 TISInputSourceWrapper::Clear()
 {
   // Clear() is always called when TISInputSourceWrappper is created.
   InitLogModule();
   if (mInputSourceList) {
     ::CFRelease(mInputSourceList);
   }
   mInputSourceList = nullptr;
   mInputSource = nullptr;
   mKeyboardLayout = nullptr;
   mIsRTL = -1;
   mUCKeyboardLayout = nullptr;
   mOverrideKeyboard = false;
 }
 void
 TISInputSourceWrapper::InitKeyEvent(NSEvent *aNativeKeyEvent,
                                     WidgetKeyboardEvent& aKeyEvent,
                                     const nsAString *aInsertString)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TISInputSourceWrapper::InitKeyEvent, aNativeKeyEvent=%p, "
      "aKeyEvent.message=%s, aInsertString=%p, IsOpenedIMEMode()=%s",
      this, aNativeKeyEvent, GetGeckoKeyEventType(aKeyEvent), aInsertString,
      TrueOrFalse(IsOpenedIMEMode())));
   NS_ENSURE_TRUE(aNativeKeyEvent, );
   nsCocoaUtils::InitInputEvent(aKeyEvent, aNativeKeyEvent);
   // This is used only while dispatching the event (which is a synchronous
   // call), so there is no need to retain and release this data.
   aKeyEvent.mNativeKeyEvent = aNativeKeyEvent;
   aKeyEvent.refPoint = LayoutDeviceIntPoint(0, 0);
   // If a keyboard layout override is set, we also need to force the keyboard
   // type to something ANSI to avoid test failures on machines with JIS
   // keyboards (since the pair of keyboard layout and physical keyboard type
   // form the actual key layout).  This assumes that the test setting the
   // override was written assuming an ANSI keyboard.
   UInt32 kbType = mOverrideKeyboard ? eKbdType_ANSI : ::LMGetKbdType();
   UInt32 nativeKeyCode = [aNativeKeyEvent keyCode];
   bool isPrintableKey = !TextInputHandler::IsSpecialGeckoKey(nativeKeyCode);
   if (isPrintableKey &&
       [aNativeKeyEvent type] != NSKeyDown &&
       [aNativeKeyEvent type] != NSKeyUp) {
     NS_WARNING("Why the printable key doesn't cause NSKeyDown or NSKeyUp?");
     isPrintableKey = false;
   }
   // Decide what string will be input.
   nsAutoString insertString;
   if (aInsertString) {
     // If the caller expects that the aInsertString will be input, we shouldn't
     // change it.
     insertString = *aInsertString;
   } else if (isPrintableKey) {
     // If IME is open, [aNativeKeyEvent characters] may be a character
     // which will be appended to the composition string.  However, especially,
     // while IME is disabled, most users and developers expect the key event
     // works as IME closed.  So, we should compute the insertString with
     // the ASCII capable keyboard layout.
     // NOTE: Such keyboard layouts typically change the layout to its ASCII
     //       capable layout when Command key is pressed.  And we don't worry
     //       when Control key is pressed too because it causes inputting
     //       control characters.
     if (!aKeyEvent.IsMeta() && !aKeyEvent.IsControl() && IsOpenedIMEMode()) {
       UInt32 state =
         nsCocoaUtils::ConvertToCarbonModifier([aNativeKeyEvent modifierFlags]);
       uint32_t ch = TranslateToChar(nativeKeyCode, state, kbType);
       if (ch) {
         insertString = ch;
       }
     } else {
       // If the caller isn't sure what string will be input, let's use
       // characters of NSEvent.
       nsCocoaUtils::GetStringForNSString([aNativeKeyEvent characters],
                                          insertString);
     }
     // If control key is pressed and the eventChars is a non-printable control
     // character, we should convert it to ASCII alphabet.
     if (aKeyEvent.IsControl() &&
         !insertString.IsEmpty() && insertString[0] <= char16_t(26)) {
       insertString = (aKeyEvent.IsShift() ^ aKeyEvent.IsCapsLocked()) ?
         static_cast<char16_t>(insertString[0] + ('A' - 1)) :
         static_cast<char16_t>(insertString[0] + ('a' - 1));
     }
     // If Meta key is pressed, it may cause to switch the keyboard layout like
     // Arabic, Russian, Hebrew, Greek and Dvorak-QWERTY.
     else if (aKeyEvent.IsMeta() &&
              !(aKeyEvent.IsControl() || aKeyEvent.IsAlt())) {
       UInt32 numLockState =
         aKeyEvent.IsNumLocked() ? kEventKeyModifierNumLockMask : 0;
       UInt32 capsLockState = aKeyEvent.IsCapsLocked() ? alphaLock : 0;
       UInt32 shiftState = aKeyEvent.IsShift() ? shiftKey : 0;
       uint32_t uncmdedChar =
         TranslateToChar(nativeKeyCode, numLockState, kbType);
       uint32_t cmdedChar =
         TranslateToChar(nativeKeyCode, cmdKey | numLockState, kbType);
       // If we can make a good guess at the characters that the user would
       // expect this key combination to produce (with and without Shift) then
       // use those characters.  This also corrects for CapsLock.
       uint32_t ch = 0;
       if (uncmdedChar == cmdedChar) {
         // The characters produced with Command seem similar to those without
         // Command.
         ch = TranslateToChar(nativeKeyCode,
                              shiftState | capsLockState | numLockState, kbType);
       } else {
         TISInputSourceWrapper USLayout("com.apple.keylayout.US");
         uint32_t uncmdedUSChar =
           USLayout.TranslateToChar(nativeKeyCode, numLockState, kbType);
         // If it looks like characters from US keyboard layout when Command key
         // is pressed, we should compute a character in the layout.
         if (uncmdedUSChar == cmdedChar) {
           ch = USLayout.TranslateToChar(nativeKeyCode,
                           shiftState | capsLockState | numLockState, kbType);
         }
       }
       // If there is a more preferred character for the commanded key event,
       // we should use it.
       if (ch) {
         insertString = ch;
       }
     }
   }
   // Remove control characters which shouldn't be inputted on editor.
   // XXX Currently, we don't find any cases inserting control characters with
   //     printable character.  So, just checking first character is enough.
   if (!insertString.IsEmpty() && IsControlChar(insertString[0])) {
     insertString.Truncate();
   }
   aKeyEvent.keyCode =
     ComputeGeckoKeyCode(nativeKeyCode, kbType, aKeyEvent.IsMeta());
   switch (nativeKeyCode) {
     case kVK_Command:
     case kVK_Shift:
     case kVK_Option:
     case kVK_Control:
       aKeyEvent.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_LEFT;
       break;
     case kVK_RightCommand:
     case kVK_RightShift:
     case kVK_RightOption:
     case kVK_RightControl:
       aKeyEvent.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_RIGHT;
       break;
     case kVK_ANSI_Keypad0:
     case kVK_ANSI_Keypad1:
     case kVK_ANSI_Keypad2:
     case kVK_ANSI_Keypad3:
     case kVK_ANSI_Keypad4:
     case kVK_ANSI_Keypad5:
     case kVK_ANSI_Keypad6:
     case kVK_ANSI_Keypad7:
     case kVK_ANSI_Keypad8:
     case kVK_ANSI_Keypad9:
     case kVK_ANSI_KeypadMultiply:
     case kVK_ANSI_KeypadPlus:
     case kVK_ANSI_KeypadMinus:
     case kVK_ANSI_KeypadDecimal:
     case kVK_ANSI_KeypadDivide:
     case kVK_ANSI_KeypadEquals:
     case kVK_ANSI_KeypadEnter:
     case kVK_JIS_KeypadComma:
     case kVK_Powerbook_KeypadEnter:
       aKeyEvent.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_NUMPAD;
       break;
     default:
       aKeyEvent.location = nsIDOMKeyEvent::DOM_KEY_LOCATION_STANDARD;
       break;
   }
   aKeyEvent.mIsRepeat =
     ([aNativeKeyEvent type] == NSKeyDown) ? [aNativeKeyEvent isARepeat] : false;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TISInputSourceWrapper::InitKeyEvent, "
      "shift=%s, ctrl=%s, alt=%s, meta=%s",
      this, OnOrOff(aKeyEvent.IsShift()), OnOrOff(aKeyEvent.IsControl()),
      OnOrOff(aKeyEvent.IsAlt()), OnOrOff(aKeyEvent.IsMeta())));
   if (aKeyEvent.message == NS_KEY_PRESS &&
       (isPrintableKey || !insertString.IsEmpty())) {
     InitKeyPressEvent(aNativeKeyEvent,
                       insertString.IsEmpty() ? 0 : insertString[0],
                       aKeyEvent, kbType);
     MOZ_ASSERT(!aKeyEvent.charCode || !IsControlChar(aKeyEvent.charCode),
                "charCode must not be a control character");
   } else {
     aKeyEvent.charCode = 0;
     aKeyEvent.isChar = false; // XXX not used in XP level
     PR_LOG(gLog, PR_LOG_ALWAYS,
       ("%p TISInputSourceWrapper::InitKeyEvent, keyCode=0x%X charCode=0x0",
        this, aKeyEvent.keyCode));
   }
   if (isPrintableKey) {
     aKeyEvent.mKeyNameIndex = KEY_NAME_INDEX_USE_STRING;
     // If insertText calls this method, let's use the string.
     if (aInsertString && !aInsertString->IsEmpty() &&
         !IsControlChar((*aInsertString)[0])) {
       aKeyEvent.mKeyValue = *aInsertString;
     }
     // If meta key is pressed, the printable key layout may be switched from
     // non-ASCII capable layout to ASCII capable, or from Dvorak to QWERTY.
     // KeyboardEvent.key value should be the switched layout's character.
     else if (aKeyEvent.IsMeta()) {
       nsCocoaUtils::GetStringForNSString([aNativeKeyEvent characters],
                                          aKeyEvent.mKeyValue);
     }
     // If control key is pressed, some keys may produce printable character via
     // [aNativeKeyEvent characters].  Otherwise, translate input character of
     // the key without control key.
     else if (aKeyEvent.IsControl()) {
       nsCocoaUtils::GetStringForNSString([aNativeKeyEvent characters],
                                          aKeyEvent.mKeyValue);
       if (aKeyEvent.mKeyValue.IsEmpty() ||
           IsControlChar(aKeyEvent.mKeyValue[0])) {
         NSUInteger cocoaState =
           [aNativeKeyEvent modifierFlags] & ~NSControlKeyMask;
         UInt32 carbonState = nsCocoaUtils::ConvertToCarbonModifier(cocoaState);
         aKeyEvent.mKeyValue =
           TranslateToChar(nativeKeyCode, carbonState, kbType);
       }
     }
     // Otherwise, KeyboardEvent.key expose
     // [aNativeKeyEvent characters] value.  However, if IME is open and the
     // keyboard layout isn't ASCII capable, exposing the non-ASCII character
     // doesn't match with other platform's behavior.  For the compatibility
     // with other platform's Gecko, we need to set a translated character.
     else if (IsOpenedIMEMode()) {
       UInt32 state =
         nsCocoaUtils::ConvertToCarbonModifier([aNativeKeyEvent modifierFlags]);
       aKeyEvent.mKeyValue = TranslateToChar(nativeKeyCode, state, kbType);
     } else {
       nsCocoaUtils::GetStringForNSString([aNativeKeyEvent characters],
                                          aKeyEvent.mKeyValue);
     }
     // Last resort.  If .key value becomes empty string, we should use
     // charactersIgnoringModifiers, if it's available.
     if (aKeyEvent.mKeyValue.IsEmpty() ||
         IsControlChar(aKeyEvent.mKeyValue[0])) {
       nsCocoaUtils::GetStringForNSString(
         [aNativeKeyEvent charactersIgnoringModifiers], aKeyEvent.mKeyValue);
       // But don't expose it if it's a control character.
       if (!aKeyEvent.mKeyValue.IsEmpty() &&
           IsControlChar(aKeyEvent.mKeyValue[0])) {
         aKeyEvent.mKeyValue.Truncate();
       }
     }
   } else {
     // Compute the key for non-printable keys and some special printable keys.
     aKeyEvent.mKeyNameIndex = ComputeGeckoKeyNameIndex(nativeKeyCode);
   }
   NS_OBJC_END_TRY_ABORT_BLOCK
 }
 void
 TISInputSourceWrapper::InitKeyPressEvent(NSEvent *aNativeKeyEvent,
                                          char16_t aInsertChar,
                                          WidgetKeyboardEvent& aKeyEvent,
                                          UInt32 aKbType)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   NS_ASSERTION(aKeyEvent.message == NS_KEY_PRESS,
                "aKeyEvent must be NS_KEY_PRESS event");
 #ifdef PR_LOGGING
   if (PR_LOG_TEST(gLog, PR_LOG_ALWAYS)) {
     nsAutoString chars;
     nsCocoaUtils::GetStringForNSString([aNativeKeyEvent characters], chars);
     NS_ConvertUTF16toUTF8 utf8Chars(chars);
     char16_t expectedChar = static_cast<char16_t>(aInsertChar);
     NS_ConvertUTF16toUTF8 utf8ExpectedChar(&expectedChar, 1);
     PR_LOG(gLog, PR_LOG_ALWAYS,
       ("%p TISInputSourceWrapper::InitKeyPressEvent, aNativeKeyEvent=%p, "
        "[aNativeKeyEvent characters]=\"%s\", aInsertChar=0x%X(%s), "
        "aKeyEvent.message=%s, aKbType=0x%X, IsOpenedIMEMode()=%s",
        this, aNativeKeyEvent, utf8Chars.get(), aInsertChar,
        utf8ExpectedChar.get(), GetGeckoKeyEventType(aKeyEvent), aKbType,
        TrueOrFalse(IsOpenedIMEMode())));
   }
 #endif // #ifdef PR_LOGGING
   aKeyEvent.isChar = true; // this is not a special key  XXX not used in XP
   aKeyEvent.charCode = aInsertChar;
   if (aKeyEvent.charCode != 0) {
     aKeyEvent.keyCode = 0;
   }
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TISInputSourceWrapper::InitKeyPressEvent, "
      "aKeyEvent.keyCode=0x%X, aKeyEvent.charCode=0x%X",
      this, aKeyEvent.keyCode, aKeyEvent.charCode));
   if (!aKeyEvent.IsControl() && !aKeyEvent.IsMeta() && !aKeyEvent.IsAlt()) {
     return;
   }
   TISInputSourceWrapper USLayout("com.apple.keylayout.US");
   bool isRomanKeyboardLayout = IsASCIICapable();
   UInt32 key = [aNativeKeyEvent keyCode];
   // Caps lock and num lock modifier state:
   UInt32 lockState = 0;
   if ([aNativeKeyEvent modifierFlags] & NSAlphaShiftKeyMask) {
     lockState |= alphaLock;
   }
   if ([aNativeKeyEvent modifierFlags] & NSNumericPadKeyMask) {
     lockState |= kEventKeyModifierNumLockMask;
   }
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TISInputSourceWrapper::InitKeyPressEvent, "
      "isRomanKeyboardLayout=%s, key=0x%X",
      this, TrueOrFalse(isRomanKeyboardLayout), aKbType, key));
   nsString str;
   // normal chars
   uint32_t unshiftedChar = TranslateToChar(key, lockState, aKbType);
   UInt32 shiftLockMod = shiftKey | lockState;
   uint32_t shiftedChar = TranslateToChar(key, shiftLockMod, aKbType);
   // characters generated with Cmd key
   // XXX we should remove CapsLock state, which changes characters from
   //     Latin to Cyrillic with Russian layout on 10.4 only when Cmd key
   //     is pressed.
   UInt32 numState = (lockState & ~alphaLock); // only num lock state
   uint32_t uncmdedChar = TranslateToChar(key, numState, aKbType);
   UInt32 shiftNumMod = numState | shiftKey;
   uint32_t uncmdedShiftChar = TranslateToChar(key, shiftNumMod, aKbType);
   uint32_t uncmdedUSChar = USLayout.TranslateToChar(key, numState, aKbType);
   UInt32 cmdNumMod = cmdKey | numState;
   uint32_t cmdedChar = TranslateToChar(key, cmdNumMod, aKbType);
   UInt32 cmdShiftNumMod = shiftKey | cmdNumMod;
   uint32_t cmdedShiftChar = TranslateToChar(key, cmdShiftNumMod, aKbType);
   // Is the keyboard layout changed by Cmd key?
   // E.g., Arabic, Russian, Hebrew, Greek and Dvorak-QWERTY.
   bool isCmdSwitchLayout = uncmdedChar != cmdedChar;
   // Is the keyboard layout for Latin, but Cmd key switches the layout?
   // I.e., Dvorak-QWERTY
   bool isDvorakQWERTY = isCmdSwitchLayout && isRomanKeyboardLayout;
   // If the current keyboard is not Dvorak-QWERTY or Cmd is not pressed,
   // we should append unshiftedChar and shiftedChar for handling the
   // normal characters.  These are the characters that the user is most
   // likely to associate with this key.
   if ((unshiftedChar || shiftedChar) &&
       (!aKeyEvent.IsMeta() || !isDvorakQWERTY)) {
     AlternativeCharCode altCharCodes(unshiftedChar, shiftedChar);
     aKeyEvent.alternativeCharCodes.AppendElement(altCharCodes);
   }
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TISInputSourceWrapper::InitKeyPressEvent, "
      "aKeyEvent.isMeta=%s, isDvorakQWERTY=%s, "
      "unshiftedChar=U+%X, shiftedChar=U+%X",
      this, OnOrOff(aKeyEvent.IsMeta()), TrueOrFalse(isDvorakQWERTY),
      unshiftedChar, shiftedChar));
   // Most keyboard layouts provide the same characters in the NSEvents
   // with Command+Shift as with Command.  However, with Command+Shift we
   // want the character on the second level.  e.g. With a US QWERTY
   // layout, we want "?" when the "/","?" key is pressed with
   // Command+Shift.
   // On a German layout, the OS gives us '/' with Cmd+Shift+SS(eszett)
   // even though Cmd+SS is 'SS' and Shift+'SS' is '?'.  This '/' seems
   // like a hack to make the Cmd+"?" event look the same as the Cmd+"?"
   // event on a US keyboard.  The user thinks they are typing Cmd+"?", so
   // we'll prefer the "?" character, replacing charCode with shiftedChar
   // when Shift is pressed.  However, in case there is a layout where the
   // character unique to Cmd+Shift is the character that the user expects,
   // we'll send it as an alternative char.
   bool hasCmdShiftOnlyChar =
     cmdedChar != cmdedShiftChar && uncmdedShiftChar != cmdedShiftChar;
   uint32_t originalCmdedShiftChar = cmdedShiftChar;
   // If we can make a good guess at the characters that the user would
   // expect this key combination to produce (with and without Shift) then
   // use those characters.  This also corrects for CapsLock, which was
   // ignored above.
   if (!isCmdSwitchLayout) {
     // The characters produced with Command seem similar to those without
     // Command.
     if (unshiftedChar) {
       cmdedChar = unshiftedChar;
     }
     if (shiftedChar) {
       cmdedShiftChar = shiftedChar;
     }
   } else if (uncmdedUSChar == cmdedChar) {
     // It looks like characters from a US layout are provided when Command
     // is down.
     uint32_t ch = USLayout.TranslateToChar(key, lockState, aKbType);
     if (ch) {
       cmdedChar = ch;
     }
     ch = USLayout.TranslateToChar(key, shiftLockMod, aKbType);
     if (ch) {
       cmdedShiftChar = ch;
     }
   }
   // If the current keyboard layout is switched by the Cmd key,
   // we should append cmdedChar and shiftedCmdChar that are
   // Latin char for the key.
   // If the keyboard layout is Dvorak-QWERTY, we should append them only when
   // command key is pressed because when command key isn't pressed, uncmded
   // chars have been appended already.
   if ((cmdedChar || cmdedShiftChar) && isCmdSwitchLayout &&
       (aKeyEvent.IsMeta() || !isDvorakQWERTY)) {
     AlternativeCharCode altCharCodes(cmdedChar, cmdedShiftChar);
     aKeyEvent.alternativeCharCodes.AppendElement(altCharCodes);
   }
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TISInputSourceWrapper::InitKeyPressEvent, "
      "hasCmdShiftOnlyChar=%s, isCmdSwitchLayout=%s, isDvorakQWERTY=%s, "
      "cmdedChar=U+%X, cmdedShiftChar=U+%X",
      this, TrueOrFalse(hasCmdShiftOnlyChar), TrueOrFalse(isDvorakQWERTY),
      TrueOrFalse(isDvorakQWERTY), cmdedChar, cmdedShiftChar));
   // Special case for 'SS' key of German layout. See the comment of
   // hasCmdShiftOnlyChar definition for the detail.
   if (hasCmdShiftOnlyChar && originalCmdedShiftChar) {
     AlternativeCharCode altCharCodes(0, originalCmdedShiftChar);
     aKeyEvent.alternativeCharCodes.AppendElement(altCharCodes);
   }
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TISInputSourceWrapper::InitKeyPressEvent, "
      "hasCmdShiftOnlyChar=%s, originalCmdedShiftChar=U+%X",
      this, TrueOrFalse(hasCmdShiftOnlyChar), originalCmdedShiftChar));
   NS_OBJC_END_TRY_ABORT_BLOCK
 }
 uint32_t
 TISInputSourceWrapper::ComputeGeckoKeyCode(UInt32 aNativeKeyCode,
                                            UInt32 aKbType,
                                            bool aCmdIsPressed)
 {
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TISInputSourceWrapper::ComputeGeckoKeyCode, aNativeKeyCode=0x%X, "
      "aKbType=0x%X, aCmdIsPressed=%s, IsOpenedIMEMode()=%s, "
      "IsASCIICapable()=%s",
      this, aNativeKeyCode, aKbType, TrueOrFalse(aCmdIsPressed),
      TrueOrFalse(IsOpenedIMEMode()), TrueOrFalse(IsASCIICapable())));
   switch (aNativeKeyCode) {
     case kVK_Space:             return NS_VK_SPACE;
     case kVK_Escape:            return NS_VK_ESCAPE;
     // modifiers
     case kVK_RightCommand:
     case kVK_Command:           return NS_VK_META;
     case kVK_RightShift:
     case kVK_Shift:             return NS_VK_SHIFT;
     case kVK_CapsLock:          return NS_VK_CAPS_LOCK;
     case kVK_RightControl:
     case kVK_Control:           return NS_VK_CONTROL;
     case kVK_RightOption:
     case kVK_Option:            return NS_VK_ALT;
     case kVK_ANSI_KeypadClear:  return NS_VK_CLEAR;
     // function keys
     case kVK_F1:                return NS_VK_F1;
     case kVK_F2:                return NS_VK_F2;
     case kVK_F3:                return NS_VK_F3;
     case kVK_F4:                return NS_VK_F4;
     case kVK_F5:                return NS_VK_F5;
     case kVK_F6:                return NS_VK_F6;
     case kVK_F7:                return NS_VK_F7;
     case kVK_F8:                return NS_VK_F8;
     case kVK_F9:                return NS_VK_F9;
     case kVK_F10:               return NS_VK_F10;
     case kVK_F11:               return NS_VK_F11;
     case kVK_F12:               return NS_VK_F12;
     // case kVK_F13:               return NS_VK_F13;  // clash with the 3 below
     // case kVK_F14:               return NS_VK_F14;
     // case kVK_F15:               return NS_VK_F15;
     case kVK_F16:               return NS_VK_F16;
     case kVK_F17:               return NS_VK_F17;
     case kVK_F18:               return NS_VK_F18;
     case kVK_F19:               return NS_VK_F19;
     case kVK_PC_Pause:          return NS_VK_PAUSE;
     case kVK_PC_ScrollLock:     return NS_VK_SCROLL_LOCK;
     case kVK_PC_PrintScreen:    return NS_VK_PRINTSCREEN;
     // keypad
     case kVK_ANSI_Keypad0:      return NS_VK_NUMPAD0;
     case kVK_ANSI_Keypad1:      return NS_VK_NUMPAD1;
     case kVK_ANSI_Keypad2:      return NS_VK_NUMPAD2;
     case kVK_ANSI_Keypad3:      return NS_VK_NUMPAD3;
     case kVK_ANSI_Keypad4:      return NS_VK_NUMPAD4;
     case kVK_ANSI_Keypad5:      return NS_VK_NUMPAD5;
     case kVK_ANSI_Keypad6:      return NS_VK_NUMPAD6;
     case kVK_ANSI_Keypad7:      return NS_VK_NUMPAD7;
     case kVK_ANSI_Keypad8:      return NS_VK_NUMPAD8;
     case kVK_ANSI_Keypad9:      return NS_VK_NUMPAD9;
     case kVK_ANSI_KeypadMultiply: return NS_VK_MULTIPLY;
     case kVK_ANSI_KeypadPlus:     return NS_VK_ADD;
     case kVK_ANSI_KeypadMinus:    return NS_VK_SUBTRACT;
     case kVK_ANSI_KeypadDecimal:  return NS_VK_DECIMAL;
     case kVK_ANSI_KeypadDivide:   return NS_VK_DIVIDE;
     case kVK_JIS_KeypadComma:   return NS_VK_SEPARATOR;
     // IME keys
     case kVK_JIS_Eisu:          return NS_VK_EISU;
     case kVK_JIS_Kana:          return NS_VK_KANA;
     // these may clash with forward delete and help
     case kVK_PC_Insert:         return NS_VK_INSERT;
     case kVK_PC_Delete:         return NS_VK_DELETE;
     case kVK_PC_Backspace:      return NS_VK_BACK;
     case kVK_Tab:               return NS_VK_TAB;
     case kVK_Home:              return NS_VK_HOME;
     case kVK_End:               return NS_VK_END;
     case kVK_PageUp:            return NS_VK_PAGE_UP;
     case kVK_PageDown:          return NS_VK_PAGE_DOWN;
     case kVK_LeftArrow:         return NS_VK_LEFT;
     case kVK_RightArrow:        return NS_VK_RIGHT;
     case kVK_UpArrow:           return NS_VK_UP;
     case kVK_DownArrow:         return NS_VK_DOWN;
     case kVK_PC_ContextMenu:    return NS_VK_CONTEXT_MENU;
     case kVK_ANSI_1:            return NS_VK_1;
     case kVK_ANSI_2:            return NS_VK_2;
     case kVK_ANSI_3:            return NS_VK_3;
     case kVK_ANSI_4:            return NS_VK_4;
     case kVK_ANSI_5:            return NS_VK_5;
     case kVK_ANSI_6:            return NS_VK_6;
     case kVK_ANSI_7:            return NS_VK_7;
     case kVK_ANSI_8:            return NS_VK_8;
     case kVK_ANSI_9:            return NS_VK_9;
     case kVK_ANSI_0:            return NS_VK_0;
     case kVK_ANSI_KeypadEnter:
     case kVK_Return:
     case kVK_Powerbook_KeypadEnter: return NS_VK_RETURN;
   }
   // If Cmd key is pressed, that causes switching keyboard layout temporarily.
   // E.g., Dvorak-QWERTY.  Therefore, if Cmd key is pressed, we should honor it.
   UInt32 modifiers = aCmdIsPressed ? cmdKey : 0;
   uint32_t charCode = TranslateToChar(aNativeKeyCode, modifiers, aKbType);
   // Special case for Mac.  Mac inputs Yen sign (U+00A5) directly instead of
   // Back slash (U+005C).  We should return NS_VK_BACK_SLASH for compatibility
   // with other platforms.
   // XXX How about Won sign (U+20A9) which has same problem as Yen sign?
   if (charCode == 0x00A5) {
     return NS_VK_BACK_SLASH;
   }
   uint32_t keyCode = WidgetUtils::ComputeKeyCodeFromChar(charCode);
   if (keyCode) {
     return keyCode;
   }
   // If the unshifed char isn't an ASCII character, use shifted char.
   charCode = TranslateToChar(aNativeKeyCode, modifiers | shiftKey, aKbType);
   keyCode = WidgetUtils::ComputeKeyCodeFromChar(charCode);
   if (keyCode) {
     return keyCode;
   }
   // If this is ASCII capable, give up to compute it.
   if (IsASCIICapable()) {
     return 0;
   }
   // Retry with ASCII capable keyboard layout.
   TISInputSourceWrapper currentKeyboardLayout;
   currentKeyboardLayout.InitByCurrentASCIICapableKeyboardLayout();
   NS_ENSURE_TRUE(mInputSource != currentKeyboardLayout.mInputSource, 0);
   keyCode = currentKeyboardLayout.ComputeGeckoKeyCode(aNativeKeyCode, aKbType,
                                                       aCmdIsPressed);
   // However, if keyCode isn't for an alphabet keys or a numeric key, we should
   // ignore it.  For example, comma key of Thai layout is same as close-square-
   // bracket key of US layout and an unicode character key of Thai layout is
   // same as comma key of US layout.  If we return NS_VK_COMMA for latter key,
   // web application developers cannot distinguish with the former key.
   return ((keyCode >= NS_VK_A && keyCode <= NS_VK_Z) ||
           (keyCode >= NS_VK_0 && keyCode <= NS_VK_9)) ? keyCode : 0;
 }
 // static
 KeyNameIndex
 TISInputSourceWrapper::ComputeGeckoKeyNameIndex(UInt32 aNativeKeyCode)
 {
   switch (aNativeKeyCode) {
 #define NS_NATIVE_KEY_TO_DOM_KEY_NAME_INDEX(aNativeKey, aKeyNameIndex) \
     case aNativeKey: return aKeyNameIndex;
 #include "NativeKeyToDOMKeyName.h"
 #undef NS_NATIVE_KEY_TO_DOM_KEY_NAME_INDEX
     default:
       return KEY_NAME_INDEX_Unidentified;
   }
 }
 #pragma mark -
 /******************************************************************************
  *
  *  TextInputHandler implementation (static methods)
  *
  ******************************************************************************/
 NSUInteger TextInputHandler::sLastModifierState = 0;
 // static
 CFArrayRef
 TextInputHandler::CreateAllKeyboardLayoutList()
 {
   const void* keys[] = { kTISPropertyInputSourceType };
   const void* values[] = { kTISTypeKeyboardLayout };
   CFDictionaryRef filter =
     ::CFDictionaryCreate(kCFAllocatorDefault, keys, values, 1, NULL, NULL);
   NS_ASSERTION(filter, "failed to create the filter");
   CFArrayRef list = ::TISCreateInputSourceList(filter, true);
   ::CFRelease(filter);
   return list;
 }
 // static
 void
 TextInputHandler::DebugPrintAllKeyboardLayouts()
 {
 #ifdef PR_LOGGING
   if (PR_LOG_TEST(gLog, PR_LOG_ALWAYS)) {
     CFArrayRef list = CreateAllKeyboardLayoutList();
     PR_LOG(gLog, PR_LOG_ALWAYS, ("Keyboard layout configuration:"));
     CFIndex idx = ::CFArrayGetCount(list);
     TISInputSourceWrapper tis;
     for (CFIndex i = 0; i < idx; ++i) {
       TISInputSourceRef inputSource = static_cast<TISInputSourceRef>(
         const_cast<void *>(::CFArrayGetValueAtIndex(list, i)));
       tis.InitByTISInputSourceRef(inputSource);
       nsAutoString name, isid;
       tis.GetLocalizedName(name);
       tis.GetInputSourceID(isid);
       PR_LOG(gLog, PR_LOG_ALWAYS,
              ("  %s\t<%s>%s%s\n",
               NS_ConvertUTF16toUTF8(name).get(),
               NS_ConvertUTF16toUTF8(isid).get(),
               tis.IsASCIICapable() ? "" : "\t(Isn't ASCII capable)",
               tis.IsKeyboardLayout() && tis.GetUCKeyboardLayout() ?
                 "" : "\t(uchr is NOT AVAILABLE)"));
     }
     ::CFRelease(list);
   }
 #endif // #ifdef PR_LOGGING
 }
 #pragma mark -
 /******************************************************************************
  *
  *  TextInputHandler implementation
  *
  ******************************************************************************/
 TextInputHandler::TextInputHandler(nsChildView* aWidget,
                                    NSView<mozView> *aNativeView) :
   IMEInputHandler(aWidget, aNativeView)
 {
   InitLogModule();
   [mView installTextInputHandler:this];
 }
 TextInputHandler::~TextInputHandler()
 {
   [mView uninstallTextInputHandler];
 }
 bool
 TextInputHandler::HandleKeyDownEvent(NSEvent* aNativeEvent)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
   if (Destroyed()) {
     PR_LOG(gLog, PR_LOG_ALWAYS,
       ("%p TextInputHandler::HandleKeyDownEvent, "
        "widget has been already destroyed", this));
     return false;
   }
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TextInputHandler::HandleKeyDownEvent, aNativeEvent=%p, "
      "type=%s, keyCode=%lld (0x%X), modifierFlags=0x%X, characters=\"%s\", "
      "charactersIgnoringModifiers=\"%s\"",
      this, aNativeEvent, GetNativeKeyEventType(aNativeEvent),
      [aNativeEvent keyCode], [aNativeEvent keyCode],
      [aNativeEvent modifierFlags], GetCharacters([aNativeEvent characters]),
      GetCharacters([aNativeEvent charactersIgnoringModifiers])));
   nsRefPtr<nsChildView> kungFuDeathGrip(mWidget);
   KeyEventState* currentKeyEvent = PushKeyEvent(aNativeEvent);
   AutoKeyEventStateCleaner remover(this);
   if (!IsIMEComposing()) {
     NSResponder* firstResponder = [[mView window] firstResponder];
     WidgetKeyboardEvent keydownEvent(true, NS_KEY_DOWN, mWidget);
     InitKeyEvent(aNativeEvent, keydownEvent);
     currentKeyEvent->mKeyDownHandled = DispatchEvent(keydownEvent);
     if (Destroyed()) {
       PR_LOG(gLog, PR_LOG_ALWAYS,
         ("%p TextInputHandler::HandleKeyDownEvent, "
          "widget was destroyed by keydown event", this));
       return currentKeyEvent->IsDefaultPrevented();
     }
     // The key down event may have shifted the focus, in which
     // case we should not fire the key press.
     // XXX This is a special code only on Cocoa widget, why is this needed?
     if (firstResponder != [[mView window] firstResponder]) {
       PR_LOG(gLog, PR_LOG_ALWAYS,
         ("%p TextInputHandler::HandleKeyDownEvent, "
          "view lost focus by keydown event", this));
       return currentKeyEvent->IsDefaultPrevented();
     }
     if (currentKeyEvent->IsDefaultPrevented()) {
       PR_LOG(gLog, PR_LOG_ALWAYS,
         ("%p TextInputHandler::HandleKeyDownEvent, "
          "keydown event's default is prevented", this));
       return true;
     }
   }
   // Let Cocoa interpret the key events, caching IsIMEComposing first.
   bool wasComposing = IsIMEComposing();
   bool interpretKeyEventsCalled = false;
   if (IsIMEEnabled() || IsASCIICapableOnly()) {
     PR_LOG(gLog, PR_LOG_ALWAYS,
       ("%p TextInputHandler::HandleKeyDownEvent, calling interpretKeyEvents",
        this));
     [mView interpretKeyEvents:[NSArray arrayWithObject:aNativeEvent]];
     interpretKeyEventsCalled = true;
     PR_LOG(gLog, PR_LOG_ALWAYS,
       ("%p TextInputHandler::HandleKeyDownEvent, called interpretKeyEvents",
        this));
   }
   if (Destroyed()) {
     PR_LOG(gLog, PR_LOG_ALWAYS,
       ("%p TextInputHandler::HandleKeyDownEvent, widget was destroyed",
        this));
     return currentKeyEvent->IsDefaultPrevented();
   }
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TextInputHandler::HandleKeyDownEvent, wasComposing=%s, "
      "IsIMEComposing()=%s",
      this, TrueOrFalse(wasComposing), TrueOrFalse(IsIMEComposing())));
   if (currentKeyEvent->CanDispatchKeyPressEvent() &&
       !wasComposing && !IsIMEComposing()) {
     WidgetKeyboardEvent keypressEvent(true, NS_KEY_PRESS, mWidget);
     InitKeyEvent(aNativeEvent, keypressEvent);
     // If we called interpretKeyEvents and this isn't normal character input
     // then IME probably ate the event for some reason. We do not want to
     // send a key press event in that case.
     // TODO:
     // There are some other cases which IME eats the current event.
     // 1. If key events were nested during calling interpretKeyEvents, it means
     //    that IME did something.  Then, we should do nothing.
     // 2. If one or more commands are called like "deleteBackward", we should
     //    dispatch keypress event at that time.  Note that the command may have
     //    been a converted or generated action by IME.  Then, we shouldn't do
     //    our default action for this key.
     if (!(interpretKeyEventsCalled &&
           IsNormalCharInputtingEvent(keypressEvent))) {
       currentKeyEvent->mKeyPressHandled = DispatchEvent(keypressEvent);
       currentKeyEvent->mKeyPressDispatched = true;
       PR_LOG(gLog, PR_LOG_ALWAYS,
         ("%p TextInputHandler::HandleKeyDownEvent, keypress event dispatched",
          this));
     }
   }
   // Note: mWidget might have become null here. Don't count on it from here on.
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TextInputHandler::HandleKeyDownEvent, "
      "keydown handled=%s, keypress handled=%s, causedOtherKeyEvents=%s",
      this, TrueOrFalse(currentKeyEvent->mKeyDownHandled),
      TrueOrFalse(currentKeyEvent->mKeyPressHandled),
      TrueOrFalse(currentKeyEvent->mCausedOtherKeyEvents)));
   return currentKeyEvent->IsDefaultPrevented();
   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(false);
 }
 void
 TextInputHandler::HandleKeyUpEvent(NSEvent* aNativeEvent)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TextInputHandler::HandleKeyUpEvent, aNativeEvent=%p, "
      "type=%s, keyCode=%lld (0x%X), modifierFlags=0x%X, characters=\"%s\", "
      "charactersIgnoringModifiers=\"%s\", "
      "mIgnoreNextKeyUpEvent=%s, IsIMEComposing()=%s",
      this, aNativeEvent, GetNativeKeyEventType(aNativeEvent),
      [aNativeEvent keyCode], [aNativeEvent keyCode],
      [aNativeEvent modifierFlags], GetCharacters([aNativeEvent characters]),
      GetCharacters([aNativeEvent charactersIgnoringModifiers]),
      TrueOrFalse(mIgnoreNextKeyUpEvent), TrueOrFalse(IsIMEComposing())));
   if (mIgnoreNextKeyUpEvent) {
     mIgnoreNextKeyUpEvent = false;
     return;
   }
   if (Destroyed()) {
     PR_LOG(gLog, PR_LOG_ALWAYS,
       ("%p TextInputHandler::HandleKeyUpEvent, "
        "widget has been already destroyed", this));
     return;
   }
   // if we don't have any characters we can't generate a keyUp event
   if (IsIMEComposing()) {
     return;
   }
   WidgetKeyboardEvent keyupEvent(true, NS_KEY_UP, mWidget);
   InitKeyEvent(aNativeEvent, keyupEvent);
   DispatchEvent(keyupEvent);
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 void
 TextInputHandler::HandleFlagsChanged(NSEvent* aNativeEvent)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   if (Destroyed()) {
     PR_LOG(gLog, PR_LOG_ALWAYS,
       ("%p TextInputHandler::HandleFlagsChanged, "
        "widget has been already destroyed", this));
     return;
   }
   nsRefPtr<nsChildView> kungFuDeathGrip(mWidget);
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TextInputHandler::HandleFlagsChanged, aNativeEvent=%p, "
      "type=%s, keyCode=%s (0x%X), modifierFlags=0x%08X, "
      "sLastModifierState=0x%08X, IsIMEComposing()=%s",
      this, aNativeEvent, GetNativeKeyEventType(aNativeEvent),
      GetKeyNameForNativeKeyCode([aNativeEvent keyCode]), [aNativeEvent keyCode],
      [aNativeEvent modifierFlags], sLastModifierState,
      TrueOrFalse(IsIMEComposing())));
   MOZ_ASSERT([aNativeEvent type] == NSFlagsChanged);
   NSUInteger diff = [aNativeEvent modifierFlags] ^ sLastModifierState;
   // Device dependent flags for left-control key, both shift keys, both command
   // keys and both option keys have been defined in Next's SDK.  But we
   // shouldn't use it directly as far as possible since Cocoa SDK doesn't
   // define them.  Fortunately, we need them only when we dispatch keyup
   // events.  So, we can usually know the actual relation between keyCode and
   // device dependent flags.  However, we need to remove following flags first
   // since the differences don't indicate modifier key state.
   // NX_STYLUSPROXIMITYMASK: Probably used for pen like device.
   // kCGEventFlagMaskNonCoalesced (= NX_NONCOALSESCEDMASK): See the document for
   // Quartz Event Services.
   diff &= ~(NX_STYLUSPROXIMITYMASK | kCGEventFlagMaskNonCoalesced);
   switch ([aNativeEvent keyCode]) {
     // CapsLock state and other modifier states are different:
     // CapsLock state does not revert when the CapsLock key goes up, as the
     // modifier state does for other modifier keys on key up.
     case kVK_CapsLock: {
       // Fire key down event for caps lock.
       DispatchKeyEventForFlagsChanged(aNativeEvent, true);
       // XXX should we fire keyup event too? The keyup event for CapsLock key
       // is never dispatched on Gecko.
       // XXX WebKit dispatches keydown event when CapsLock is locked, otherwise,
       // keyup event.  If we do so, we cannot keep the consistency with other
       // platform's behavior...
       break;
     }
     // If the event is caused by pressing or releasing a modifier key, just
     // dispatch the key's event.
     case kVK_Shift:
     case kVK_RightShift:
     case kVK_Command:
     case kVK_RightCommand:
     case kVK_Control:
     case kVK_RightControl:
     case kVK_Option:
     case kVK_RightOption:
     case kVK_Help: {
       // We assume that at most one modifier is changed per event if the event
       // is caused by pressing or releasing a modifier key.
       bool isKeyDown = ([aNativeEvent modifierFlags] & diff) != 0;
       DispatchKeyEventForFlagsChanged(aNativeEvent, isKeyDown);
       // XXX Some applications might send the event with incorrect device-
       //     dependent flags.
       if (isKeyDown && ((diff & ~NSDeviceIndependentModifierFlagsMask) != 0)) {
         unsigned short keyCode = [aNativeEvent keyCode];
         const ModifierKey* modifierKey =
           GetModifierKeyForDeviceDependentFlags(diff);
         if (modifierKey && modifierKey->keyCode != keyCode) {
           // Although, we're not sure the actual cause of this case, the stored
           // modifier information and the latest key event information may be
           // mismatched. Then, let's reset the stored information.
           // NOTE: If this happens, it may fail to handle NSFlagsChanged event
           // in the default case (below). However, it's the rare case handler
           // and this case occurs rarely. So, we can ignore the edge case bug.
           NS_WARNING("Resetting stored modifier key information");
           mModifierKeys.Clear();
           modifierKey = nullptr;
         }
         if (!modifierKey) {
           mModifierKeys.AppendElement(ModifierKey(diff, keyCode));
         }
       }
       break;
     }
     // Currently we don't support Fn key since other browsers don't dispatch
     // events for it and we don't have keyCode for this key.
     // It should be supported when we implement .key and .char.
     case kVK_Function:
       break;
     // If the event is caused by something else than pressing or releasing a
     // single modifier key (for example by the app having been deactivated
     // using command-tab), use the modifiers themselves to determine which
     // key's event to dispatch, and whether it's a keyup or keydown event.
     // In all cases we assume one or more modifiers are being deactivated
     // (never activated) -- otherwise we'd have received one or more events
     // corresponding to a single modifier key being pressed.
     default: {
       NSUInteger modifiers = sLastModifierState;
       for (int32_t bit = 0; bit < 32; ++bit) {
         NSUInteger flag = 1 << bit;
         if (!(diff & flag)) {
           continue;
         }
         // Given correct information from the application, a flag change here
         // will normally be a deactivation (except for some lockable modifiers
         // such as CapsLock).  But some applications (like VNC) can send an
         // activating event with a zero keyCode.  So we need to check for that
         // here.
         bool dispatchKeyDown = ((flag & [aNativeEvent modifierFlags]) != 0);
         unsigned short keyCode = 0;
         if (flag & NSDeviceIndependentModifierFlagsMask) {
           switch (flag) {
             case NSAlphaShiftKeyMask:
               keyCode = kVK_CapsLock;
               dispatchKeyDown = true;
               break;
             case NSNumericPadKeyMask:
               // NSNumericPadKeyMask is fired by VNC a lot. But not all of
               // these events can really be Clear key events, so we just ignore
               // them.
               continue;
             case NSHelpKeyMask:
               keyCode = kVK_Help;
               break;
             case NSFunctionKeyMask:
               // An NSFunctionKeyMask change here will normally be a
               // deactivation.  But sometimes it will be an activation send (by
               // VNC for example) with a zero keyCode.
               continue;
             // These cases (NSShiftKeyMask, NSControlKeyMask, NSAlternateKeyMask
             // and NSCommandKeyMask) should be handled by the other branch of
             // the if statement, below (which handles device dependent flags).
             // However, some applications (like VNC) can send key events without
             // any device dependent flags, so we handle them here instead.
             case NSShiftKeyMask:
               keyCode = (modifiers & 0x0004) ? kVK_RightShift : kVK_Shift;
               break;
             case NSControlKeyMask:
               keyCode = (modifiers & 0x2000) ? kVK_RightControl : kVK_Control;
               break;
             case NSAlternateKeyMask:
               keyCode = (modifiers & 0x0040) ? kVK_RightOption : kVK_Option;
               break;
             case NSCommandKeyMask:
               keyCode = (modifiers & 0x0010) ? kVK_RightCommand : kVK_Command;
               break;
             default:
               continue;
           }
         } else {
           const ModifierKey* modifierKey =
             GetModifierKeyForDeviceDependentFlags(flag);
           if (!modifierKey) {
             // See the note above (in the other branch of the if statement)
             // about the NSShiftKeyMask, NSControlKeyMask, NSAlternateKeyMask
             // and NSCommandKeyMask cases.
             continue;
           }
           keyCode = modifierKey->keyCode;
         }
         // Remove flags
         modifiers &= ~flag;
         switch (keyCode) {
           case kVK_Shift: {
             const ModifierKey* modifierKey =
               GetModifierKeyForNativeKeyCode(kVK_RightShift);
             if (!modifierKey ||
                 !(modifiers & modifierKey->GetDeviceDependentFlags())) {
               modifiers &= ~NSShiftKeyMask;
             }
             break;
           }
           case kVK_RightShift: {
             const ModifierKey* modifierKey =
               GetModifierKeyForNativeKeyCode(kVK_Shift);
             if (!modifierKey ||
                 !(modifiers & modifierKey->GetDeviceDependentFlags())) {
               modifiers &= ~NSShiftKeyMask;
             }
             break;
           }
           case kVK_Command: {
             const ModifierKey* modifierKey =
               GetModifierKeyForNativeKeyCode(kVK_RightCommand);
             if (!modifierKey ||
                 !(modifiers & modifierKey->GetDeviceDependentFlags())) {
               modifiers &= ~NSCommandKeyMask;
             }
             break;
           }
           case kVK_RightCommand: {
             const ModifierKey* modifierKey =
               GetModifierKeyForNativeKeyCode(kVK_Command);
             if (!modifierKey ||
                 !(modifiers & modifierKey->GetDeviceDependentFlags())) {
               modifiers &= ~NSCommandKeyMask;
             }
             break;
           }
           case kVK_Control: {
             const ModifierKey* modifierKey =
               GetModifierKeyForNativeKeyCode(kVK_RightControl);
             if (!modifierKey ||
                 !(modifiers & modifierKey->GetDeviceDependentFlags())) {
               modifiers &= ~NSControlKeyMask;
             }
             break;
           }
           case kVK_RightControl: {
             const ModifierKey* modifierKey =
               GetModifierKeyForNativeKeyCode(kVK_Control);
             if (!modifierKey ||
                 !(modifiers & modifierKey->GetDeviceDependentFlags())) {
               modifiers &= ~NSControlKeyMask;
             }
             break;
           }
           case kVK_Option: {
             const ModifierKey* modifierKey =
               GetModifierKeyForNativeKeyCode(kVK_RightOption);
             if (!modifierKey ||
                 !(modifiers & modifierKey->GetDeviceDependentFlags())) {
               modifiers &= ~NSAlternateKeyMask;
             }
             break;
           }
           case kVK_RightOption: {
             const ModifierKey* modifierKey =
               GetModifierKeyForNativeKeyCode(kVK_Option);
             if (!modifierKey ||
                 !(modifiers & modifierKey->GetDeviceDependentFlags())) {
               modifiers &= ~NSAlternateKeyMask;
             }
             break;
           }
           case kVK_Help:
             modifiers &= ~NSHelpKeyMask;
             break;
           default:
             break;
         }
         NSEvent* event =
           [NSEvent keyEventWithType:NSFlagsChanged
                            location:[aNativeEvent locationInWindow]
                       modifierFlags:modifiers
                           timestamp:[aNativeEvent timestamp]
                        windowNumber:[aNativeEvent windowNumber]
                             context:[aNativeEvent context]
                          characters:nil
         charactersIgnoringModifiers:nil
                           isARepeat:NO
                             keyCode:keyCode];
         DispatchKeyEventForFlagsChanged(event, dispatchKeyDown);
         if (Destroyed()) {
           break;
         }
         // Stop if focus has changed.
         // Check to see if mView is still the first responder.
         if (![mView isFirstResponder]) {
           break;
         }
       }
       break;
     }
   }
   // Be aware, the widget may have been destroyed.
   sLastModifierState = [aNativeEvent modifierFlags];
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 const TextInputHandler::ModifierKey*
 TextInputHandler::GetModifierKeyForNativeKeyCode(unsigned short aKeyCode) const
 {
   for (ModifierKeyArray::index_type i = 0; i < mModifierKeys.Length(); ++i) {
     if (mModifierKeys[i].keyCode == aKeyCode) {
       return &((ModifierKey&)mModifierKeys[i]);
     }
   }
   return nullptr;
 }
 const TextInputHandler::ModifierKey*
 TextInputHandler::GetModifierKeyForDeviceDependentFlags(NSUInteger aFlags) const
 {
   for (ModifierKeyArray::index_type i = 0; i < mModifierKeys.Length(); ++i) {
     if (mModifierKeys[i].GetDeviceDependentFlags() ==
           (aFlags & ~NSDeviceIndependentModifierFlagsMask)) {
       return &((ModifierKey&)mModifierKeys[i]);
     }
   }
   return nullptr;
 }
 void
 TextInputHandler::DispatchKeyEventForFlagsChanged(NSEvent* aNativeEvent,
                                                   bool aDispatchKeyDown)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   if (Destroyed()) {
     return;
   }
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TextInputHandler::DispatchKeyEventForFlagsChanged, aNativeEvent=%p, "
      "type=%s, keyCode=%s (0x%X), aDispatchKeyDown=%s, IsIMEComposing()=%s",
      this, aNativeEvent, GetNativeKeyEventType(aNativeEvent),
      GetKeyNameForNativeKeyCode([aNativeEvent keyCode]), [aNativeEvent keyCode],
      TrueOrFalse(aDispatchKeyDown), TrueOrFalse(IsIMEComposing())));
   if ([aNativeEvent type] != NSFlagsChanged || IsIMEComposing()) {
     return;
   }
   uint32_t message = aDispatchKeyDown ? NS_KEY_DOWN : NS_KEY_UP;
   NPCocoaEvent cocoaEvent;
   // Fire a key event.
   WidgetKeyboardEvent keyEvent(true, message, mWidget);
   InitKeyEvent(aNativeEvent, keyEvent);
   // create event for use by plugins
   if ([mView isPluginView]) {
     if ([mView pluginEventModel] == NPEventModelCocoa) {
       ConvertCocoaKeyEventToNPCocoaEvent(aNativeEvent, cocoaEvent);
       keyEvent.pluginEvent = &cocoaEvent;
     }
   }
   DispatchEvent(keyEvent);
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 void
 TextInputHandler::InsertText(NSAttributedString* aAttrString,
                              NSRange* aReplacementRange)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   if (Destroyed()) {
     return;
   }
   KeyEventState* currentKeyEvent = GetCurrentKeyEvent();
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TextInputHandler::InsertText, aAttrString=\"%s\", "
      "aReplacementRange=%p { location=%llu, length=%llu }, "
      "IsIMEComposing()=%s, IgnoreIMEComposition()=%s, "
      "keyevent=%p, keydownHandled=%s, keypressDispatched=%s, "
      "causedOtherKeyEvents=%s",
      this, GetCharacters([aAttrString string]), aReplacementRange,
      aReplacementRange ? aReplacementRange->location : 0,
      aReplacementRange ? aReplacementRange->length : 0,
      TrueOrFalse(IsIMEComposing()), TrueOrFalse(IgnoreIMEComposition()),
      currentKeyEvent ? currentKeyEvent->mKeyEvent : nullptr,
      currentKeyEvent ?
        TrueOrFalse(currentKeyEvent->mKeyDownHandled) : "N/A",
      currentKeyEvent ?
        TrueOrFalse(currentKeyEvent->mKeyPressDispatched) : "N/A",
      currentKeyEvent ?
        TrueOrFalse(currentKeyEvent->mCausedOtherKeyEvents) : "N/A"));
   if (IgnoreIMEComposition()) {
     return;
   }
   InputContext context = mWidget->GetInputContext();
   bool isEditable = (context.mIMEState.mEnabled == IMEState::ENABLED ||
                      context.mIMEState.mEnabled == IMEState::PASSWORD);
   NSRange selectedRange = SelectedRange();
   nsAutoString str;
   nsCocoaUtils::GetStringForNSString([aAttrString string], str);
   if (!IsIMEComposing() && str.IsEmpty()) {
     // nothing to do if there is no content which can be removed.
     if (!isEditable) {
       return;
     }
     // If replacement range is specified, we need to remove the range.
     // Otherwise, we need to remove the selected range if it's not collapsed.
     if (aReplacementRange && aReplacementRange->location != NSNotFound) {
       // nothing to do since the range is collapsed.
       if (aReplacementRange->length == 0) {
         return;
       }
       // If the replacement range is different from current selected range,
       // select the range.
       if (!NSEqualRanges(selectedRange, *aReplacementRange)) {
         NS_ENSURE_TRUE_VOID(SetSelection(*aReplacementRange));
       }
       selectedRange = SelectedRange();
     }
     NS_ENSURE_TRUE_VOID(selectedRange.location != NSNotFound);
     if (selectedRange.length == 0) {
       return; // nothing to do
     }
     // If this is caused by a key input, the keypress event which will be
     // dispatched later should cause the delete.  Therefore, nothing to do here.
     // Although, we're not sure if such case is actually possible.
     if (!currentKeyEvent) {
       return;
     }
     // Delete the selected range.
     nsRefPtr<TextInputHandler> kungFuDeathGrip(this);
     WidgetContentCommandEvent deleteCommandEvent(true,
                                                  NS_CONTENT_COMMAND_DELETE,
                                                  mWidget);
     DispatchEvent(deleteCommandEvent);
     NS_ENSURE_TRUE_VOID(deleteCommandEvent.mSucceeded);
     // Be aware! The widget might be destroyed here.
     return;
   }
   if (str.Length() != 1 || IsIMEComposing()) {
     InsertTextAsCommittingComposition(aAttrString, aReplacementRange);
     return;
   }
   // Don't let the same event be fired twice when hitting
   // enter/return! (Bug 420502)
   if (currentKeyEvent && !currentKeyEvent->CanDispatchKeyPressEvent()) {
     return;
   }
   nsRefPtr<nsChildView> kungFuDeathGrip(mWidget);
   // If the replacement range is specified, select the range.  Then, the
   // selection will be replaced by the later keypress event.
   if (isEditable &&
       aReplacementRange && aReplacementRange->location != NSNotFound &&
       !NSEqualRanges(selectedRange, *aReplacementRange)) {
     NS_ENSURE_TRUE_VOID(SetSelection(*aReplacementRange));
   }
   // Dispatch keypress event with char instead of textEvent
   WidgetKeyboardEvent keypressEvent(true, NS_KEY_PRESS, mWidget);
   keypressEvent.isChar = IsPrintableChar(str.CharAt(0));
   // Don't set other modifiers from the current event, because here in
   // -insertText: they've already been taken into account in creating
   // the input string.
   if (currentKeyEvent) {
     NSEvent* keyEvent = currentKeyEvent->mKeyEvent;
     InitKeyEvent(keyEvent, keypressEvent, &str);
   } else {
     nsCocoaUtils::InitInputEvent(keypressEvent, static_cast<NSEvent*>(nullptr));
     if (keypressEvent.isChar) {
       keypressEvent.charCode = str.CharAt(0);
     }
     // Note that insertText is not called only at key pressing.
     if (!keypressEvent.charCode) {
       keypressEvent.keyCode =
         WidgetUtils::ComputeKeyCodeFromChar(keypressEvent.charCode);
     }
   }
   // Remove basic modifiers from keypress event because if they are included,
   // nsPlaintextEditor ignores the event.
   keypressEvent.modifiers &= ~(MODIFIER_CONTROL |
                                MODIFIER_ALT |
                                MODIFIER_META);
   // TODO:
   // If mCurrentKeyEvent.mKeyEvent is null and when we implement textInput
   // event of DOM3 Events, we should dispatch it instead of keypress event.
   bool keyPressHandled = DispatchEvent(keypressEvent);
   // Note: mWidget might have become null here. Don't count on it from here on.
   if (currentKeyEvent) {
     currentKeyEvent->mKeyPressHandled = keyPressHandled;
     currentKeyEvent->mKeyPressDispatched = true;
   }
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 bool
 TextInputHandler::DoCommandBySelector(const char* aSelector)
 {
   nsRefPtr<nsChildView> kungFuDeathGrip(mWidget);
   KeyEventState* currentKeyEvent = GetCurrentKeyEvent();
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TextInputHandler::DoCommandBySelector, aSelector=\"%s\", "
      "Destroyed()=%s, keydownHandled=%s, keypressHandled=%s, "
      "causedOtherKeyEvents=%s",
      this, aSelector ? aSelector : "", TrueOrFalse(Destroyed()),
      currentKeyEvent ?
        TrueOrFalse(currentKeyEvent->mKeyDownHandled) : "N/A",
      currentKeyEvent ?
        TrueOrFalse(currentKeyEvent->mKeyPressHandled) : "N/A",
      currentKeyEvent ?
        TrueOrFalse(currentKeyEvent->mCausedOtherKeyEvents) : "N/A"));
   if (currentKeyEvent && currentKeyEvent->CanDispatchKeyPressEvent()) {
     WidgetKeyboardEvent keypressEvent(true, NS_KEY_PRESS, mWidget);
     InitKeyEvent(currentKeyEvent->mKeyEvent, keypressEvent);
     currentKeyEvent->mKeyPressHandled = DispatchEvent(keypressEvent);
     currentKeyEvent->mKeyPressDispatched = true;
     PR_LOG(gLog, PR_LOG_ALWAYS,
       ("%p TextInputHandler::DoCommandBySelector, keypress event "
        "dispatched, Destroyed()=%s, keypressHandled=%s",
        this, TrueOrFalse(Destroyed()),
        TrueOrFalse(currentKeyEvent->mKeyPressHandled)));
   }
   return (!Destroyed() && currentKeyEvent &&
           currentKeyEvent->IsDefaultPrevented());
 }
 #pragma mark -
 /******************************************************************************
  *
  *  IMEInputHandler implementation (static methods)
  *
  ******************************************************************************/
 bool IMEInputHandler::sStaticMembersInitialized = false;
 CFStringRef IMEInputHandler::sLatestIMEOpenedModeInputSourceID = nullptr;
 IMEInputHandler* IMEInputHandler::sFocusedIMEHandler = nullptr;
 // static
 void
 IMEInputHandler::InitStaticMembers()
 {
   if (sStaticMembersInitialized)
     return;
   sStaticMembersInitialized = true;
   // We need to check the keyboard layout changes on all applications.
   CFNotificationCenterRef center = ::CFNotificationCenterGetDistributedCenter();
   // XXX Don't we need to remove the observer at shut down?
   // Mac Dev Center's document doesn't say how to remove the observer if
   // the second parameter is NULL.
   ::CFNotificationCenterAddObserver(center, NULL,
       OnCurrentTextInputSourceChange,
       kTISNotifySelectedKeyboardInputSourceChanged, NULL,
       CFNotificationSuspensionBehaviorDeliverImmediately);
   // Initiailize with the current keyboard layout
   OnCurrentTextInputSourceChange(NULL, NULL,
                                  kTISNotifySelectedKeyboardInputSourceChanged,
                                  NULL, NULL);
 }
 // static
 void
 IMEInputHandler::OnCurrentTextInputSourceChange(CFNotificationCenterRef aCenter,
                                                 void* aObserver,
                                                 CFStringRef aName,
                                                 const void* aObject,
                                                 CFDictionaryRef aUserInfo)
 {
   // Cache the latest IME opened mode to sLatestIMEOpenedModeInputSourceID.
   TISInputSourceWrapper tis;
   tis.InitByCurrentInputSource();
   if (tis.IsOpenedIMEMode()) {
     tis.GetInputSourceID(sLatestIMEOpenedModeInputSourceID);
   }
 #ifdef PR_LOGGING
   if (PR_LOG_TEST(gLog, PR_LOG_ALWAYS)) {
     static CFStringRef sLastTIS = nullptr;
     CFStringRef newTIS;
     tis.GetInputSourceID(newTIS);
     if (!sLastTIS ||
         ::CFStringCompare(sLastTIS, newTIS, 0) != kCFCompareEqualTo) {
       TISInputSourceWrapper tis1, tis2, tis3, tis4, tis5;
       tis1.InitByCurrentKeyboardLayout();
       tis2.InitByCurrentASCIICapableInputSource();
       tis3.InitByCurrentASCIICapableKeyboardLayout();
       tis4.InitByCurrentInputMethodKeyboardLayoutOverride();
       tis5.InitByTISInputSourceRef(tis.GetKeyboardLayoutInputSource());
       CFStringRef is0 = nullptr, is1 = nullptr, is2 = nullptr, is3 = nullptr,
                   is4 = nullptr, is5 = nullptr, type0 = nullptr,
                   lang0 = nullptr, bundleID0 = nullptr;
       tis.GetInputSourceID(is0);
       tis1.GetInputSourceID(is1);
       tis2.GetInputSourceID(is2);
       tis3.GetInputSourceID(is3);
       tis4.GetInputSourceID(is4);
       tis5.GetInputSourceID(is5);
       tis.GetInputSourceType(type0);
       tis.GetPrimaryLanguage(lang0);
       tis.GetBundleID(bundleID0);
       PR_LOG(gLog, PR_LOG_ALWAYS,
         ("IMEInputHandler::OnCurrentTextInputSourceChange,\n"
          "  Current Input Source is changed to:\n"
          "    currentInputContext=%p\n"
          "    %s\n"
          "      type=%s %s\n"
          "      overridden keyboard layout=%s\n"
          "      used keyboard layout for translation=%s\n"
          "    primary language=%s\n"
          "    bundle ID=%s\n"
          "    current ASCII capable Input Source=%s\n"
          "    current Keyboard Layout=%s\n"
          "    current ASCII capable Keyboard Layout=%s",
          [NSTextInputContext currentInputContext], GetCharacters(is0),
          GetCharacters(type0), tis.IsASCIICapable() ? "- ASCII capable " : "",
          GetCharacters(is4), GetCharacters(is5),
          GetCharacters(lang0), GetCharacters(bundleID0),
          GetCharacters(is2), GetCharacters(is1), GetCharacters(is3)));
     }
     sLastTIS = newTIS;
   }
 #endif // #ifdef PR_LOGGING
 }
 // static
 void
 IMEInputHandler::FlushPendingMethods(nsITimer* aTimer, void* aClosure)
 {
   NS_ASSERTION(aClosure, "aClosure is null");
   static_cast<IMEInputHandler*>(aClosure)->ExecutePendingMethods();
 }
 // static
 CFArrayRef
 IMEInputHandler::CreateAllIMEModeList()
 {
   const void* keys[] = { kTISPropertyInputSourceType };
   const void* values[] = { kTISTypeKeyboardInputMode };
   CFDictionaryRef filter =
     ::CFDictionaryCreate(kCFAllocatorDefault, keys, values, 1, NULL, NULL);
   NS_ASSERTION(filter, "failed to create the filter");
   CFArrayRef list = ::TISCreateInputSourceList(filter, true);
   ::CFRelease(filter);
   return list;
 }
 // static
 void
 IMEInputHandler::DebugPrintAllIMEModes()
 {
 #ifdef PR_LOGGING
   if (PR_LOG_TEST(gLog, PR_LOG_ALWAYS)) {
     CFArrayRef list = CreateAllIMEModeList();
     PR_LOG(gLog, PR_LOG_ALWAYS, ("IME mode configuration:"));
     CFIndex idx = ::CFArrayGetCount(list);
     TISInputSourceWrapper tis;
     for (CFIndex i = 0; i < idx; ++i) {
       TISInputSourceRef inputSource = static_cast<TISInputSourceRef>(
         const_cast<void *>(::CFArrayGetValueAtIndex(list, i)));
       tis.InitByTISInputSourceRef(inputSource);
       nsAutoString name, isid;
       tis.GetLocalizedName(name);
       tis.GetInputSourceID(isid);
       PR_LOG(gLog, PR_LOG_ALWAYS,
              ("  %s\t<%s>%s%s\n",
               NS_ConvertUTF16toUTF8(name).get(),
               NS_ConvertUTF16toUTF8(isid).get(),
               tis.IsASCIICapable() ? "" : "\t(Isn't ASCII capable)",
               tis.IsEnabled() ? "" : "\t(Isn't Enabled)"));
     }
     ::CFRelease(list);
   }
 #endif // #ifdef PR_LOGGING
 }
 //static
 TSMDocumentID
 IMEInputHandler::GetCurrentTSMDocumentID()
 {
   // At least on Mac OS X 10.6.x and 10.7.x, ::TSMGetActiveDocument() has a bug.
   // The result of ::TSMGetActiveDocument() isn't modified for new active text
   // input context until [NSTextInputContext currentInputContext] is called.
   // Therefore, we need to call it here.
   [NSTextInputContext currentInputContext];
   return ::TSMGetActiveDocument();
 }
 #pragma mark -
 /******************************************************************************
  *
  *  IMEInputHandler implementation #1
  *    The methods are releated to the pending methods.  Some jobs should be
  *    run after the stack is finished, e.g, some methods cannot run the jobs
  *    during processing the focus event.  And also some other jobs should be
  *    run at the next focus event is processed.
  *    The pending methods are recorded in mPendingMethods.  They are executed
  *    by ExecutePendingMethods via FlushPendingMethods.
  *
  ******************************************************************************/
 void
 IMEInputHandler::NotifyIMEOfFocusChangeInGecko()
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::NotifyIMEOfFocusChangeInGecko, "
      "Destroyed()=%s, IsFocused()=%s, inputContext=%p",
      this, TrueOrFalse(Destroyed()), TrueOrFalse(IsFocused()),
      mView ? [mView inputContext] : nullptr));
   if (Destroyed()) {
     return;
   }
   if (!IsFocused()) {
     // retry at next focus event
     mPendingMethods |= kNotifyIMEOfFocusChangeInGecko;
     return;
   }
   MOZ_ASSERT(mView);
   NSTextInputContext* inputContext = [mView inputContext];
   NS_ENSURE_TRUE_VOID(inputContext);
   // When an <input> element on a XUL <panel> element gets focus from an <input>
   // element on the opener window of the <panel> element, the owner window
   // still has native focus.  Therefore, IMEs may store the opener window's
   // level at this time because they don't know the actual focus is moved to
   // different window.  If IMEs try to get the newest window level after the
   // focus change, we return the window level of the XUL <panel>'s widget.
   // Therefore, let's emulate the native focus change.  Then, IMEs can refresh
   // the stored window level.
   [inputContext deactivate];
   [inputContext activate];
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 void
 IMEInputHandler::DiscardIMEComposition()
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::DiscardIMEComposition, "
      "Destroyed()=%s, IsFocused()=%s, mView=%p, inputContext=%p",
      this, TrueOrFalse(Destroyed()), TrueOrFalse(IsFocused()),
      mView, mView ? [mView inputContext] : nullptr));
   if (Destroyed()) {
     return;
   }
   if (!IsFocused()) {
     // retry at next focus event
     mPendingMethods |= kDiscardIMEComposition;
     return;
   }
   NS_ENSURE_TRUE_VOID(mView);
   NSTextInputContext* inputContext = [mView inputContext];
   NS_ENSURE_TRUE_VOID(inputContext);
   mIgnoreIMECommit = true;
   [inputContext discardMarkedText];
   mIgnoreIMECommit = false;
   NS_OBJC_END_TRY_ABORT_BLOCK
 }
 void
 IMEInputHandler::SyncASCIICapableOnly()
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::SyncASCIICapableOnly, "
      "Destroyed()=%s, IsFocused()=%s, mIsASCIICapableOnly=%s, "
      "GetCurrentTSMDocumentID()=%p",
      this, TrueOrFalse(Destroyed()), TrueOrFalse(IsFocused()),
      TrueOrFalse(mIsASCIICapableOnly), GetCurrentTSMDocumentID()));
   if (Destroyed()) {
     return;
   }
   if (!IsFocused()) {
     // retry at next focus event
     mPendingMethods |= kSyncASCIICapableOnly;
     return;
   }
   TSMDocumentID doc = GetCurrentTSMDocumentID();
   if (!doc) {
     // retry
     mPendingMethods |= kSyncASCIICapableOnly;
     NS_WARNING("Application is active but there is no active document");
     ResetTimer();
     return;
   }
   if (mIsASCIICapableOnly) {
     CFArrayRef ASCIICapableTISList = ::TISCreateASCIICapableInputSourceList();
     ::TSMSetDocumentProperty(doc,
                              kTSMDocumentEnabledInputSourcesPropertyTag,
                              sizeof(CFArrayRef),
                              &ASCIICapableTISList);
     ::CFRelease(ASCIICapableTISList);
   } else {
     ::TSMRemoveDocumentProperty(doc,
                                 kTSMDocumentEnabledInputSourcesPropertyTag);
   }
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 void
 IMEInputHandler::ResetTimer()
 {
   NS_ASSERTION(mPendingMethods != 0,
                "There are not pending methods, why this is called?");
   if (mTimer) {
     mTimer->Cancel();
   } else {
     mTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
     NS_ENSURE_TRUE(mTimer, );
   }
   mTimer->InitWithFuncCallback(FlushPendingMethods, this, 0,
                                nsITimer::TYPE_ONE_SHOT);
 }
 void
 IMEInputHandler::ExecutePendingMethods()
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   if (mTimer) {
     mTimer->Cancel();
     mTimer = nullptr;
   }
   if (![[NSApplication sharedApplication] isActive]) {
     mIsInFocusProcessing = false;
     // If we're not active, we should retry at focus event
     return;
   }
   uint32_t pendingMethods = mPendingMethods;
   // First, reset the pending method flags because if each methods cannot
   // run now, they can reentry to the pending flags by theirselves.
   mPendingMethods = 0;
   if (pendingMethods & kDiscardIMEComposition)
     DiscardIMEComposition();
   if (pendingMethods & kSyncASCIICapableOnly)
     SyncASCIICapableOnly();
   if (pendingMethods & kNotifyIMEOfFocusChangeInGecko) {
     NotifyIMEOfFocusChangeInGecko();
   }
   mIsInFocusProcessing = false;
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 #pragma mark -
 /******************************************************************************
  *
  * IMEInputHandler implementation (native event handlers)
  *
  ******************************************************************************/
 uint32_t
 IMEInputHandler::ConvertToTextRangeType(uint32_t aUnderlineStyle,
                                         NSRange& aSelectedRange)
 {
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::ConvertToTextRangeType, "
      "aUnderlineStyle=%llu, aSelectedRange.length=%llu,",
      this, aUnderlineStyle, aSelectedRange.length));
   // We assume that aUnderlineStyle is NSUnderlineStyleSingle or
   // NSUnderlineStyleThick.  NSUnderlineStyleThick should indicate a selected
   // clause.  Otherwise, should indicate non-selected clause.
   if (aSelectedRange.length == 0) {
     switch (aUnderlineStyle) {
       case NSUnderlineStyleSingle:
         return NS_TEXTRANGE_RAWINPUT;
       case NSUnderlineStyleThick:
         return NS_TEXTRANGE_SELECTEDRAWTEXT;
       default:
         NS_WARNING("Unexpected line style");
         return NS_TEXTRANGE_SELECTEDRAWTEXT;
     }
   }
   switch (aUnderlineStyle) {
     case NSUnderlineStyleSingle:
       return NS_TEXTRANGE_CONVERTEDTEXT;
     case NSUnderlineStyleThick:
       return NS_TEXTRANGE_SELECTEDCONVERTEDTEXT;
     default:
       NS_WARNING("Unexpected line style");
       return NS_TEXTRANGE_SELECTEDCONVERTEDTEXT;
   }
 }
 uint32_t
 IMEInputHandler::GetRangeCount(NSAttributedString *aAttrString)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
   // Iterate through aAttrString for the NSUnderlineStyleAttributeName and
   // count the different segments adjusting limitRange as we go.
   uint32_t count = 0;
   NSRange effectiveRange;
   NSRange limitRange = NSMakeRange(0, [aAttrString length]);
   while (limitRange.length > 0) {
     [aAttrString  attribute:NSUnderlineStyleAttributeName
                     atIndex:limitRange.location
       longestEffectiveRange:&effectiveRange
                     inRange:limitRange];
     limitRange =
       NSMakeRange(NSMaxRange(effectiveRange),
                   NSMaxRange(limitRange) - NSMaxRange(effectiveRange));
     count++;
   }
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::GetRangeCount, aAttrString=\"%s\", count=%llu",
      this, GetCharacters([aAttrString string]), count));
   return count;
   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(0);
 }
 already_AddRefed<mozilla::TextRangeArray>
 IMEInputHandler::CreateTextRangeArray(NSAttributedString *aAttrString,
                                       NSRange& aSelectedRange)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
   // Convert the Cocoa range into the TextRange Array used in Gecko.
   // Iterate through the attributed string and map the underline attribute to
   // Gecko IME textrange attributes.  We may need to change the code here if
   // we change the implementation of validAttributesForMarkedText.
   NSRange limitRange = NSMakeRange(0, [aAttrString length]);
   uint32_t rangeCount = GetRangeCount(aAttrString);
   nsRefPtr<mozilla::TextRangeArray> textRangeArray =
                                       new mozilla::TextRangeArray();
   for (uint32_t i = 0; i < rangeCount && limitRange.length > 0; i++) {
     NSRange effectiveRange;
     id attributeValue = [aAttrString attribute:NSUnderlineStyleAttributeName
                                        atIndex:limitRange.location
                          longestEffectiveRange:&effectiveRange
                                        inRange:limitRange];
     TextRange range;
     range.mStartOffset = effectiveRange.location;
     range.mEndOffset = NSMaxRange(effectiveRange);
     range.mRangeType =
       ConvertToTextRangeType([attributeValue intValue], aSelectedRange);
     textRangeArray->AppendElement(range);
     PR_LOG(gLog, PR_LOG_ALWAYS,
       ("%p IMEInputHandler::CreateTextRangeArray, "
        "range={ mStartOffset=%llu, mEndOffset=%llu, mRangeType=%s }",
        this, range.mStartOffset, range.mEndOffset,
        GetRangeTypeName(range.mRangeType)));
     limitRange =
       NSMakeRange(NSMaxRange(effectiveRange),
                   NSMaxRange(limitRange) - NSMaxRange(effectiveRange));
   }
   // Get current caret position.
   TextRange range;
   range.mStartOffset = aSelectedRange.location + aSelectedRange.length;
   range.mEndOffset = range.mStartOffset;
   range.mRangeType = NS_TEXTRANGE_CARETPOSITION;
   textRangeArray->AppendElement(range);
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::CreateTextRangeArray, "
      "range={ mStartOffset=%llu, mEndOffset=%llu, mRangeType=%s }",
      this, range.mStartOffset, range.mEndOffset,
      GetRangeTypeName(range.mRangeType)));
   return textRangeArray.forget();
   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 }
 bool
 IMEInputHandler::DispatchTextEvent(const nsString& aText,
                                    NSAttributedString* aAttrString,
                                    NSRange& aSelectedRange,
                                    bool aDoCommit)
 {
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::DispatchTextEvent, "
      "aText=\"%s\", aAttrString=\"%s\", "
      "aSelectedRange={ location=%llu, length=%llu }, "
      "aDoCommit=%s, Destroyed()=%s",
      this, NS_ConvertUTF16toUTF8(aText).get(),
      GetCharacters([aAttrString string]),
      aSelectedRange.location, aSelectedRange.length,
      TrueOrFalse(aDoCommit), TrueOrFalse(Destroyed())));
   NS_ENSURE_TRUE(!Destroyed(), false);
   nsRefPtr<IMEInputHandler> kungFuDeathGrip(this);
   WidgetTextEvent textEvent(true, NS_TEXT_TEXT, mWidget);
   textEvent.time = PR_IntervalNow();
   textEvent.theText = aText;
   if (!aDoCommit) {
     textEvent.mRanges = CreateTextRangeArray(aAttrString, aSelectedRange);
   }
   if (textEvent.theText != mLastDispatchedCompositionString) {
     WidgetCompositionEvent compositionUpdate(true, NS_COMPOSITION_UPDATE,
                                              mWidget);
     compositionUpdate.time = textEvent.time;
     compositionUpdate.data = textEvent.theText;
     mLastDispatchedCompositionString = textEvent.theText;
     DispatchEvent(compositionUpdate);
     if (mIsInFocusProcessing || Destroyed()) {
       PR_LOG(gLog, PR_LOG_ALWAYS,
         ("%p IMEInputHandler::DispatchTextEvent, compositionupdate causes "
          "aborting the composition, mIsInFocusProcessing=%s, Destryoed()=%s",
          this, TrueOrFalse(mIsInFocusProcessing), TrueOrFalse(Destroyed())));
       if (Destroyed()) {
         return true;
       }
     }
   }
   return DispatchEvent(textEvent);
 }
 void
 IMEInputHandler::InitCompositionEvent(WidgetCompositionEvent& aCompositionEvent)
 {
   aCompositionEvent.time = PR_IntervalNow();
 }
 void
 IMEInputHandler::InsertTextAsCommittingComposition(
                    NSAttributedString* aAttrString,
                    NSRange* aReplacementRange)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::InsertTextAsCommittingComposition, "
      "aAttrString=\"%s\", aReplacementRange=%p { location=%llu, length=%llu }, "
      "Destroyed()=%s, IsIMEComposing()=%s, "
      "mMarkedRange={ location=%llu, length=%llu }",
      this, GetCharacters([aAttrString string]), aReplacementRange,
      aReplacementRange ? aReplacementRange->location : 0,
      aReplacementRange ? aReplacementRange->length : 0,
      TrueOrFalse(Destroyed()), TrueOrFalse(IsIMEComposing()),
      mMarkedRange.location, mMarkedRange.length));
   if (IgnoreIMECommit()) {
     MOZ_CRASH("IMEInputHandler::InsertTextAsCommittingComposition() must not"
               "be called while canceling the composition");
   }
   if (Destroyed()) {
     return;
   }
   // First, commit current composition with the latest composition string if the
   // replacement range is different from marked range.
   if (IsIMEComposing() && aReplacementRange &&
       aReplacementRange->location != NSNotFound &&
       !NSEqualRanges(MarkedRange(), *aReplacementRange)) {
     NSString* latestStr =
       nsCocoaUtils::ToNSString(mLastDispatchedCompositionString);
     NSAttributedString* attrLatestStr =
       [[[NSAttributedString alloc] initWithString:latestStr] autorelease];
     InsertTextAsCommittingComposition(attrLatestStr, nullptr);
     if (Destroyed()) {
       PR_LOG(gLog, PR_LOG_ALWAYS,
         ("%p IMEInputHandler::InsertTextAsCommittingComposition, "
          "destroyed by commiting composition for setting replacement range",
          this));
       return;
     }
   }
   nsRefPtr<IMEInputHandler> kungFuDeathGrip(this);
   nsString str;
   nsCocoaUtils::GetStringForNSString([aAttrString string], str);
   if (!IsIMEComposing()) {
     // If there is no selection and replacement range is specified, set the
     // range as selection.
     if (aReplacementRange && aReplacementRange->location != NSNotFound &&
         !NSEqualRanges(SelectedRange(), *aReplacementRange)) {
       NS_ENSURE_TRUE_VOID(SetSelection(*aReplacementRange));
     }
     // XXXmnakano Probably, we shouldn't emulate composition in this case.
     // I think that we should just fire DOM3 textInput event if we implement it.
     WidgetCompositionEvent compStart(true, NS_COMPOSITION_START, mWidget);
     InitCompositionEvent(compStart);
     DispatchEvent(compStart);
     if (Destroyed()) {
       PR_LOG(gLog, PR_LOG_ALWAYS,
         ("%p IMEInputHandler::InsertTextAsCommittingComposition, "
          "destroyed by compositionstart event", this));
       return;
     }
     OnStartIMEComposition();
   }
   NSRange range = NSMakeRange(0, str.Length());
   DispatchTextEvent(str, aAttrString, range, true);
   if (Destroyed()) {
     PR_LOG(gLog, PR_LOG_ALWAYS,
       ("%p IMEInputHandler::InsertTextAsCommittingComposition, "
        "destroyed by text event", this));
     return;
   }
   OnUpdateIMEComposition([aAttrString string]);
   WidgetCompositionEvent compEnd(true, NS_COMPOSITION_END, mWidget);
   InitCompositionEvent(compEnd);
   compEnd.data = mLastDispatchedCompositionString;
   DispatchEvent(compEnd);
   if (Destroyed()) {
     PR_LOG(gLog, PR_LOG_ALWAYS,
       ("%p IMEInputHandler::InsertTextAsCommittingComposition, "
        "destroyed by compositionend event", this));
     return;
   }
   OnEndIMEComposition();
   mMarkedRange = NSMakeRange(NSNotFound, 0);
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 void
 IMEInputHandler::SetMarkedText(NSAttributedString* aAttrString,
                                NSRange& aSelectedRange,
                                NSRange* aReplacementRange)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::SetMarkedText, "
      "aAttrString=\"%s\", aSelectedRange={ location=%llu, length=%llu }, "
      "aReplacementRange=%p { location=%llu, length=%llu }, "
      "Destroyed()=%s, IgnoreIMEComposition()=%s, IsIMEComposing()=%s, "
      "mMarkedRange={ location=%llu, length=%llu }",
      this, GetCharacters([aAttrString string]),
      aSelectedRange.location, aSelectedRange.length, aReplacementRange,
      aReplacementRange ? aReplacementRange->location : 0,
      aReplacementRange ? aReplacementRange->length : 0,
      TrueOrFalse(Destroyed()), TrueOrFalse(IgnoreIMEComposition()),
      TrueOrFalse(IsIMEComposing()),
      mMarkedRange.location, mMarkedRange.length));
   if (Destroyed() || IgnoreIMEComposition()) {
     return;
   }
   nsRefPtr<IMEInputHandler> kungFuDeathGrip(this);
   // First, commit current composition with the latest composition string if the
   // replacement range is different from marked range.
   if (IsIMEComposing() && aReplacementRange &&
       aReplacementRange->location != NSNotFound &&
       !NSEqualRanges(MarkedRange(), *aReplacementRange)) {
     NSString* latestStr =
       nsCocoaUtils::ToNSString(mLastDispatchedCompositionString);
     NSAttributedString* attrLatestStr =
       [[[NSAttributedString alloc] initWithString:latestStr] autorelease];
     bool ignoreIMECommit = mIgnoreIMECommit;
     mIgnoreIMECommit = false;
     InsertTextAsCommittingComposition(attrLatestStr, nullptr);
     mIgnoreIMECommit = ignoreIMECommit;
     if (Destroyed()) {
       PR_LOG(gLog, PR_LOG_ALWAYS,
         ("%p IMEInputHandler::SetMarkedText, "
          "destroyed by commiting composition for setting replacement range",
          this));
       return;
     }
   }
   nsString str;
   nsCocoaUtils::GetStringForNSString([aAttrString string], str);
   mMarkedRange.length = str.Length();
   if (!IsIMEComposing() && !str.IsEmpty()) {
     // If there is no selection and replacement range is specified, set the
     // range as selection.
     if (aReplacementRange && aReplacementRange->location != NSNotFound &&
         !NSEqualRanges(SelectedRange(), *aReplacementRange)) {
       NS_ENSURE_TRUE_VOID(SetSelection(*aReplacementRange));
     }
     mMarkedRange.location = SelectedRange().location;
     WidgetCompositionEvent compStart(true, NS_COMPOSITION_START, mWidget);
     InitCompositionEvent(compStart);
     DispatchEvent(compStart);
     if (Destroyed()) {
       PR_LOG(gLog, PR_LOG_ALWAYS,
         ("%p IMEInputHandler::SetMarkedText, "
          "destroyed by compositionstart event", this));
       return;
     }
     OnStartIMEComposition();
   }
   if (IsIMEComposing()) {
     OnUpdateIMEComposition([aAttrString string]);
     bool doCommit = str.IsEmpty();
     DispatchTextEvent(str, aAttrString, aSelectedRange, doCommit);
     if (Destroyed()) {
       PR_LOG(gLog, PR_LOG_ALWAYS,
         ("%p IMEInputHandler::SetMarkedText, "
          "destroyed by text event", this));
       return;
     }
     if (doCommit) {
       WidgetCompositionEvent compEnd(true, NS_COMPOSITION_END, mWidget);
       InitCompositionEvent(compEnd);
       compEnd.data = mLastDispatchedCompositionString;
       DispatchEvent(compEnd);
       if (Destroyed()) {
         PR_LOG(gLog, PR_LOG_ALWAYS,
           ("%p IMEInputHandler::SetMarkedText, "
            "destroyed by compositionend event", this));
         return;
       }
       OnEndIMEComposition();
     }
   }
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 NSInteger
 IMEInputHandler::ConversationIdentifier()
 {
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::ConversationIdentifier, Destroyed()=%s",
      this, TrueOrFalse(Destroyed())));
   if (Destroyed()) {
     return reinterpret_cast<NSInteger>(mView);
   }
   nsRefPtr<IMEInputHandler> kungFuDeathGrip(this);
   // NOTE: The size of NSInteger is same as pointer size.
   WidgetQueryContentEvent textContent(true, NS_QUERY_TEXT_CONTENT, mWidget);
   textContent.InitForQueryTextContent(0, 0);
   DispatchEvent(textContent);
   if (!textContent.mSucceeded) {
     PR_LOG(gLog, PR_LOG_ALWAYS,
       ("%p IMEInputHandler::ConversationIdentifier, Failed", this));
     return reinterpret_cast<NSInteger>(mView);
   }
   // XXX This might return same ID as a previously existing editor if the
   //     deleted editor was created at the same address.  Is there a better way?
   return reinterpret_cast<NSInteger>(textContent.mReply.mContentsRoot);
 }
 NSAttributedString*
 IMEInputHandler::GetAttributedSubstringFromRange(NSRange& aRange,
                                                  NSRange* aActualRange)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::GetAttributedSubstringFromRange, "
      "aRange={ location=%llu, length=%llu }, aActualRange=%p, Destroyed()=%s",
      this, aRange.location, aRange.length, aActualRange,
      TrueOrFalse(Destroyed())));
   if (aActualRange) {
     *aActualRange = NSMakeRange(NSNotFound, 0);
   }
   if (Destroyed() || aRange.location == NSNotFound || aRange.length == 0) {
     return nil;
   }
   nsRefPtr<IMEInputHandler> kungFuDeathGrip(this);
   nsAutoString str;
   WidgetQueryContentEvent textContent(true, NS_QUERY_TEXT_CONTENT, mWidget);
   textContent.InitForQueryTextContent(aRange.location, aRange.length);
   DispatchEvent(textContent);
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::GetAttributedSubstringFromRange, "
      "textContent={ mSucceeded=%s, mReply={ mString=\"%s\", mOffset=%llu } }",
      this, TrueOrFalse(textContent.mSucceeded),
      NS_ConvertUTF16toUTF8(textContent.mReply.mString).get(),
      textContent.mReply.mOffset));
   if (!textContent.mSucceeded) {
     return nil;
   }
   NSString* nsstr = nsCocoaUtils::ToNSString(textContent.mReply.mString);
   NSAttributedString* result =
     [[[NSAttributedString alloc] initWithString:nsstr
                                      attributes:nil] autorelease];
   if (aActualRange) {
     aActualRange->location = textContent.mReply.mOffset;
     aActualRange->length = textContent.mReply.mString.Length();
   }
   return result;
   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 }
 bool
 IMEInputHandler::HasMarkedText()
 {
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::HasMarkedText, "
      "mMarkedRange={ location=%llu, length=%llu }",
      this, mMarkedRange.location, mMarkedRange.length));
   return (mMarkedRange.location != NSNotFound) && (mMarkedRange.length != 0);
 }
 NSRange
 IMEInputHandler::MarkedRange()
 {
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::MarkedRange, "
      "mMarkedRange={ location=%llu, length=%llu }",
      this, mMarkedRange.location, mMarkedRange.length));
   if (!HasMarkedText()) {
     return NSMakeRange(NSNotFound, 0);
   }
   return mMarkedRange;
 }
 NSRange
 IMEInputHandler::SelectedRange()
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::SelectedRange, Destroyed()=%s, mSelectedRange={ "
      "location=%llu, length=%llu }",
      this, TrueOrFalse(Destroyed()), mSelectedRange.location,
      mSelectedRange.length));
   if (Destroyed()) {
     return mSelectedRange;
   }
   if (mSelectedRange.location != NSNotFound) {
     MOZ_ASSERT(mIMEHasFocus);
     return mSelectedRange;
   }
   nsRefPtr<IMEInputHandler> kungFuDeathGrip(this);
   WidgetQueryContentEvent selection(true, NS_QUERY_SELECTED_TEXT, mWidget);
   DispatchEvent(selection);
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::SelectedRange, selection={ mSucceeded=%s, "
      "mReply={ mOffset=%llu, mString.Length()=%llu } }",
      this, TrueOrFalse(selection.mSucceeded), selection.mReply.mOffset,
      selection.mReply.mString.Length()));
   if (!selection.mSucceeded) {
     return mSelectedRange;
   }
   if (mIMEHasFocus) {
     mSelectedRange.location = selection.mReply.mOffset;
     mSelectedRange.length = selection.mReply.mString.Length();
     return mSelectedRange;
   }
   return NSMakeRange(selection.mReply.mOffset,
                      selection.mReply.mString.Length());
   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(mSelectedRange);
 }
 NSRect
 IMEInputHandler::FirstRectForCharacterRange(NSRange& aRange,
                                             NSRange* aActualRange)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::FirstRectForCharacterRange, Destroyed()=%s, "
      "aRange={ location=%llu, length=%llu }, aActualRange=%p }",
      this, TrueOrFalse(Destroyed()), aRange.location, aRange.length,
      aActualRange));
   // XXX this returns first character rect or caret rect, it is limitation of
   // now. We need more work for returns first line rect. But current
   // implementation is enough for IMEs.
   NSRect rect = NSMakeRect(0.0, 0.0, 0.0, 0.0);
   NSRange actualRange = NSMakeRange(NSNotFound, 0);
   if (aActualRange) {
     *aActualRange = actualRange;
   }
   if (Destroyed() || aRange.location == NSNotFound) {
     return rect;
   }
   nsRefPtr<IMEInputHandler> kungFuDeathGrip(this);
   nsIntRect r;
   bool useCaretRect = (aRange.length == 0);
   if (!useCaretRect) {
     WidgetQueryContentEvent charRect(true, NS_QUERY_TEXT_RECT, mWidget);
     charRect.InitForQueryTextRect(aRange.location, 1);
     DispatchEvent(charRect);
     if (charRect.mSucceeded) {
       r = charRect.mReply.mRect;
       actualRange.location = charRect.mReply.mOffset;
       actualRange.length = charRect.mReply.mString.Length();
     } else {
       useCaretRect = true;
     }
   }
   if (useCaretRect) {
     WidgetQueryContentEvent caretRect(true, NS_QUERY_CARET_RECT, mWidget);
     caretRect.InitForQueryCaretRect(aRange.location);
     DispatchEvent(caretRect);
     if (!caretRect.mSucceeded) {
       return rect;
     }
     r = caretRect.mReply.mRect;
     r.width = 0;
     actualRange.location = caretRect.mReply.mOffset;
     actualRange.length = 0;
   }
   nsIWidget* rootWidget = mWidget->GetTopLevelWidget();
   NSWindow* rootWindow =
     static_cast<NSWindow*>(rootWidget->GetNativeData(NS_NATIVE_WINDOW));
   NSView* rootView =
     static_cast<NSView*>(rootWidget->GetNativeData(NS_NATIVE_WIDGET));
   if (!rootWindow || !rootView) {
     return rect;
   }
   rect = nsCocoaUtils::DevPixelsToCocoaPoints(r, mWidget->BackingScaleFactor());
   rect = [rootView convertRect:rect toView:nil];
   rect.origin = [rootWindow convertBaseToScreen:rect.origin];
   if (aActualRange) {
     *aActualRange = actualRange;
   }
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::FirstRectForCharacterRange, "
      "useCaretRect=%s rect={ x=%f, y=%f, width=%f, height=%f }, "
      "actualRange={ location=%llu, length=%llu }",
      this, TrueOrFalse(useCaretRect), rect.origin.x, rect.origin.y,
      rect.size.width, rect.size.height, actualRange.location,
      actualRange.length));
   return rect;
   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NSMakeRect(0.0, 0.0, 0.0, 0.0));
 }
 NSUInteger
 IMEInputHandler::CharacterIndexForPoint(NSPoint& aPoint)
 {
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::CharacterIndexForPoint, aPoint={ x=%f, y=%f }",
      this, aPoint.x, aPoint.y));
   //nsRefPtr<IMEInputHandler> kungFuDeathGrip(this);
   // To implement this, we'd have to grovel in text frames looking at text
   // offsets.
   return 0;
 }
 NSArray*
 IMEInputHandler::GetValidAttributesForMarkedText()
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::GetValidAttributesForMarkedText", this));
   //nsRefPtr<IMEInputHandler> kungFuDeathGrip(this);
   //return [NSArray arrayWithObjects:NSUnderlineStyleAttributeName,
   //                                 NSMarkedClauseSegmentAttributeName,
   //                                 NSTextInputReplacementRangeAttributeName,
   //                                 nil];
   // empty array; we don't support any attributes right now
   return [NSArray array];
   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 }
 #pragma mark -
 /******************************************************************************
  *
  *  IMEInputHandler implementation #2
  *
  ******************************************************************************/
 IMEInputHandler::IMEInputHandler(nsChildView* aWidget,
                                  NSView<mozView> *aNativeView) :
   PluginTextInputHandler(aWidget, aNativeView),
   mPendingMethods(0), mIMECompositionString(nullptr),
   mIsIMEComposing(false), mIsIMEEnabled(true),
   mIsASCIICapableOnly(false), mIgnoreIMECommit(false),
   mIsInFocusProcessing(false), mIMEHasFocus(false)
 {
   InitStaticMembers();
   mMarkedRange.location = NSNotFound;
   mMarkedRange.length = 0;
   mSelectedRange.location = NSNotFound;
   mSelectedRange.length = 0;
 }
 IMEInputHandler::~IMEInputHandler()
 {
   if (mTimer) {
     mTimer->Cancel();
     mTimer = nullptr;
   }
   if (sFocusedIMEHandler == this) {
     sFocusedIMEHandler = nullptr;
   }
 }
 void
 IMEInputHandler::OnFocusChangeInGecko(bool aFocus)
 {
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::OnFocusChangeInGecko, aFocus=%s, Destroyed()=%s, "
      "sFocusedIMEHandler=%p",
      this, TrueOrFalse(aFocus), TrueOrFalse(Destroyed()), sFocusedIMEHandler));
   mSelectedRange.location = NSNotFound; // Marking dirty
   mIMEHasFocus = aFocus;
   // This is called when the native focus is changed and when the native focus
   // isn't changed but the focus is changed in Gecko.
   if (!aFocus) {
     if (sFocusedIMEHandler == this)
       sFocusedIMEHandler = nullptr;
     return;
   }
   sFocusedIMEHandler = this;
   mIsInFocusProcessing = true;
   // We need to notify IME of focus change in Gecko as native focus change
   // because the window level of the focused element in Gecko may be changed.
   mPendingMethods |= kNotifyIMEOfFocusChangeInGecko;
   ResetTimer();
 }
 bool
 IMEInputHandler::OnDestroyWidget(nsChildView* aDestroyingWidget)
 {
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::OnDestroyWidget, aDestroyingWidget=%p, "
      "sFocusedIMEHandler=%p, IsIMEComposing()=%s",
      this, aDestroyingWidget, sFocusedIMEHandler,
      TrueOrFalse(IsIMEComposing())));
   // If we're not focused, the focused IMEInputHandler may have been
   // created by another widget/nsChildView.
   if (sFocusedIMEHandler && sFocusedIMEHandler != this) {
     sFocusedIMEHandler->OnDestroyWidget(aDestroyingWidget);
   }
   if (!PluginTextInputHandler::OnDestroyWidget(aDestroyingWidget)) {
     return false;
   }
   if (IsIMEComposing()) {
     // If our view is in the composition, we should clean up it.
     CancelIMEComposition();
     OnEndIMEComposition();
   }
   mSelectedRange.location = NSNotFound; // Marking dirty
   mIMEHasFocus = false;
   return true;
 }
 void
 IMEInputHandler::OnStartIMEComposition()
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::OnStartIMEComposition, mView=%p, mWidget=%p"
      "inputContext=%p, mIsIMEComposing=%s",
      this, mView, mWidget, mView ? [mView inputContext] : nullptr,
      TrueOrFalse(mIsIMEComposing)));
   NS_ASSERTION(!mIsIMEComposing, "There is a composition already");
   mIsIMEComposing = true;
   mLastDispatchedCompositionString.Truncate();
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 void
 IMEInputHandler::OnUpdateIMEComposition(NSString* aIMECompositionString)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::OnUpdateIMEComposition, mView=%p, mWidget=%p, "
      "inputContext=%p, mIsIMEComposing=%s, aIMECompositionString=\"%s\"",
      this, mView, mWidget, mView ? [mView inputContext] : nullptr,
      TrueOrFalse(mIsIMEComposing), GetCharacters(aIMECompositionString)));
   NS_ASSERTION(mIsIMEComposing, "We're not in composition");
   if (mIMECompositionString)
     [mIMECompositionString release];
   mIMECompositionString = [aIMECompositionString retain];
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 void
 IMEInputHandler::OnEndIMEComposition()
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::OnEndIMEComposition, mView=%p, mWidget=%p, "
      "inputContext=%p, mIsIMEComposing=%s",
      this, mView, mWidget, mView ? [mView inputContext] : nullptr,
      TrueOrFalse(mIsIMEComposing)));
   NS_ASSERTION(mIsIMEComposing, "We're not in composition");
   mIsIMEComposing = false;
   if (mIMECompositionString) {
     [mIMECompositionString release];
     mIMECompositionString = nullptr;
   }
   mLastDispatchedCompositionString.Truncate();
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 void
 IMEInputHandler::SendCommittedText(NSString *aString)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::SendCommittedText, mView=%p, mWidget=%p, "
      "inputContext=%p, mIsIMEComposing=%s",
      this, mView, mWidget, mView ? [mView inputContext] : nullptr,
      TrueOrFalse(mIsIMEComposing), mWidget));
   NS_ENSURE_TRUE(mWidget, );
   // XXX We should send the string without mView.
   if (!mView) {
     return;
   }
   NSAttributedString* attrStr =
     [[NSAttributedString alloc] initWithString:aString];
   [mView insertText:attrStr];
   [attrStr release];
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 void
 IMEInputHandler::KillIMEComposition()
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::KillIMEComposition, mView=%p, mWidget=%p, "
      "inputContext=%p, mIsIMEComposing=%s, "
      "Destroyed()=%s, IsFocused()=%s",
      this, mView, mWidget, mView ? [mView inputContext] : nullptr,
      TrueOrFalse(mIsIMEComposing), TrueOrFalse(Destroyed()),
      TrueOrFalse(IsFocused())));
   if (Destroyed()) {
     return;
   }
   if (IsFocused()) {
     NS_ENSURE_TRUE_VOID(mView);
     NSTextInputContext* inputContext = [mView inputContext];
     NS_ENSURE_TRUE_VOID(inputContext);
     [inputContext discardMarkedText];
     return;
   }
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::KillIMEComposition, Pending...", this));
   // Commit the composition internally.
   SendCommittedText(mIMECompositionString);
   NS_ASSERTION(!mIsIMEComposing, "We're still in a composition");
   // The pending method will be fired by the next focus event.
   mPendingMethods |= kDiscardIMEComposition;
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 void
 IMEInputHandler::CommitIMEComposition()
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   if (!IsIMEComposing())
     return;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::CommitIMEComposition, mIMECompositionString=%s",
      this, GetCharacters(mIMECompositionString)));
   KillIMEComposition();
   if (!IsIMEComposing())
     return;
   // If the composition is still there, KillIMEComposition only kills the
   // composition in TSM.  We also need to finish the our composition too.
   SendCommittedText(mIMECompositionString);
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 void
 IMEInputHandler::CancelIMEComposition()
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   if (!IsIMEComposing())
     return;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::CancelIMEComposition, mIMECompositionString=%s",
      this, GetCharacters(mIMECompositionString)));
   // For canceling the current composing, we need to ignore the param of
   // insertText.  But this code is ugly...
   mIgnoreIMECommit = true;
   KillIMEComposition();
   mIgnoreIMECommit = false;
   if (!IsIMEComposing())
     return;
   // If the composition is still there, KillIMEComposition only kills the
   // composition in TSM.  We also need to kill the our composition too.
   SendCommittedText(@"");
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 bool
 IMEInputHandler::IsFocused()
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   NS_ENSURE_TRUE(!Destroyed(), false);
   NSWindow* window = [mView window];
   NS_ENSURE_TRUE(window, false);
   return [window firstResponder] == mView &&
          [window isKeyWindow] &&
          [[NSApplication sharedApplication] isActive];
   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(false);
 }
 bool
 IMEInputHandler::IsIMEOpened()
 {
   TISInputSourceWrapper tis;
   tis.InitByCurrentInputSource();
   return tis.IsOpenedIMEMode();
 }
 void
 IMEInputHandler::SetASCIICapableOnly(bool aASCIICapableOnly)
 {
   if (aASCIICapableOnly == mIsASCIICapableOnly)
     return;
   CommitIMEComposition();
   mIsASCIICapableOnly = aASCIICapableOnly;
   SyncASCIICapableOnly();
 }
 void
 IMEInputHandler::EnableIME(bool aEnableIME)
 {
   if (aEnableIME == mIsIMEEnabled)
     return;
   CommitIMEComposition();
   mIsIMEEnabled = aEnableIME;
 }
 void
 IMEInputHandler::SetIMEOpenState(bool aOpenIME)
 {
   if (!IsFocused() || IsIMEOpened() == aOpenIME)
     return;
   if (!aOpenIME) {
     TISInputSourceWrapper tis;
     tis.InitByCurrentASCIICapableInputSource();
     tis.Select();
     return;
   }
   // If we know the latest IME opened mode, we should select it.
   if (sLatestIMEOpenedModeInputSourceID) {
     TISInputSourceWrapper tis;
     tis.InitByInputSourceID(sLatestIMEOpenedModeInputSourceID);
     tis.Select();
     return;
   }
   // XXX If the current input source is a mode of IME, we should turn on it,
   // but we haven't found such way...
   // Finally, we should refer the system locale but this is a little expensive,
   // we shouldn't retry this (if it was succeeded, we already set
   // sLatestIMEOpenedModeInputSourceID at that time).
   static bool sIsPrefferredIMESearched = false;
   if (sIsPrefferredIMESearched)
     return;
   sIsPrefferredIMESearched = true;
   OpenSystemPreferredLanguageIME();
 }
 void
 IMEInputHandler::OpenSystemPreferredLanguageIME()
 {
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p IMEInputHandler::OpenSystemPreferredLanguageIME", this));
   CFArrayRef langList = ::CFLocaleCopyPreferredLanguages();
   if (!langList) {
     PR_LOG(gLog, PR_LOG_ALWAYS,
       ("%p IMEInputHandler::OpenSystemPreferredLanguageIME, langList is NULL",
        this));
     return;
   }
   CFIndex count = ::CFArrayGetCount(langList);
   for (CFIndex i = 0; i < count; i++) {
     CFLocaleRef locale =
       ::CFLocaleCreate(kCFAllocatorDefault,
           static_cast<CFStringRef>(::CFArrayGetValueAtIndex(langList, i)));
     if (!locale) {
       continue;
     }
     bool changed = false;
     CFStringRef lang = static_cast<CFStringRef>(
       ::CFLocaleGetValue(locale, kCFLocaleLanguageCode));
     NS_ASSERTION(lang, "lang is null");
     if (lang) {
       TISInputSourceWrapper tis;
       tis.InitByLanguage(lang);
       if (tis.IsOpenedIMEMode()) {
 #ifdef PR_LOGGING
         if (PR_LOG_TEST(gLog, PR_LOG_ALWAYS)) {
           CFStringRef foundTIS;
           tis.GetInputSourceID(foundTIS);
           PR_LOG(gLog, PR_LOG_ALWAYS,
             ("%p IMEInputHandler::OpenSystemPreferredLanguageIME, "
              "foundTIS=%s, lang=%s",
              this, GetCharacters(foundTIS), GetCharacters(lang)));
         }
 #endif // #ifdef PR_LOGGING
         tis.Select();
         changed = true;
       }
     }
     ::CFRelease(locale);
     if (changed) {
       break;
     }
   }
   ::CFRelease(langList);
 }
 #pragma mark -
 /******************************************************************************
  *
  *  PluginTextInputHandler implementation
  *
  ******************************************************************************/
 PluginTextInputHandler::PluginTextInputHandler(nsChildView* aWidget,
                                                NSView<mozView> *aNativeView) :
   TextInputHandlerBase(aWidget, aNativeView),
   mIgnoreNextKeyUpEvent(false),
 #ifndef __LP64__
   mPluginTSMDoc(0), mPluginTSMInComposition(false),
 #endif // #ifndef __LP64__
   mPluginComplexTextInputRequested(false)
 {
 }
 PluginTextInputHandler::~PluginTextInputHandler()
 {
 #ifndef __LP64__
   if (mPluginTSMDoc) {
     ::DeleteTSMDocument(mPluginTSMDoc);
   }
 #endif // #ifndef __LP64__
 }
 /* static */ void
 PluginTextInputHandler::ConvertCocoaKeyEventToNPCocoaEvent(
                           NSEvent* aCocoaEvent,
                           NPCocoaEvent& aPluginEvent)
 {
   nsCocoaUtils::InitNPCocoaEvent(&aPluginEvent);
   NSEventType nativeType = [aCocoaEvent type];
   switch (nativeType) {
     case NSKeyDown:
       aPluginEvent.type = NPCocoaEventKeyDown;
       break;
     case NSKeyUp:
       aPluginEvent.type = NPCocoaEventKeyUp;
       break;
     case NSFlagsChanged:
       aPluginEvent.type = NPCocoaEventFlagsChanged;
       break;
     default:
       NS_WARNING("Asked to convert key event of unknown type to Cocoa plugin event!");
   }
   aPluginEvent.data.key.modifierFlags = [aCocoaEvent modifierFlags];
   aPluginEvent.data.key.keyCode = [aCocoaEvent keyCode];
   // don't try to access character data for flags changed events,
   // it will raise an exception
   if (nativeType != NSFlagsChanged) {
     aPluginEvent.data.key.characters = (NPNSString*)[aCocoaEvent characters];
     aPluginEvent.data.key.charactersIgnoringModifiers =
       (NPNSString*)[aCocoaEvent charactersIgnoringModifiers];
     aPluginEvent.data.key.isARepeat = [aCocoaEvent isARepeat];
   }
 }
 #ifndef __LP64__
 EventHandlerRef PluginTextInputHandler::sPluginKeyEventsHandler = NULL;
 /* static */ void
 PluginTextInputHandler::InstallPluginKeyEventsHandler()
 {
   if (sPluginKeyEventsHandler) {
     return;
   }
   static const EventTypeSpec sTSMEvents[] =
     { { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent } };
   ::InstallEventHandler(::GetEventDispatcherTarget(),
                         ::NewEventHandlerUPP(PluginKeyEventsHandler),
                         GetEventTypeCount(sTSMEvents),
                         sTSMEvents,
                         NULL,
                         &sPluginKeyEventsHandler);
 }
 /* static */ void
 PluginTextInputHandler::RemovePluginKeyEventsHandler()
 {
   if (!sPluginKeyEventsHandler) {
     return;
   }
   ::RemoveEventHandler(sPluginKeyEventsHandler);
   sPluginKeyEventsHandler = NULL;
 }
 /* static */ void
 PluginTextInputHandler::SwizzleMethods()
 {
   Class IMKInputSessionClass = ::NSClassFromString(@"IMKInputSession");
   nsToolkit::SwizzleMethods(IMKInputSessionClass, @selector(handleEvent:),
     @selector(PluginTextInputHandler_IMKInputSession_handleEvent:));
   nsToolkit::SwizzleMethods(IMKInputSessionClass, @selector(commitComposition),
     @selector(PluginTextInputHandler_IMKInputSession_commitComposition));
   nsToolkit::SwizzleMethods(IMKInputSessionClass, @selector(finishSession),
     @selector(PluginTextInputHandler_IMKInputSession_finishSession));
 }
 /* static */ OSStatus
 PluginTextInputHandler::PluginKeyEventsHandler(EventHandlerCallRef aHandlerRef,
                                                EventRef aEvent,
                                                void *aUserData)
 {
   nsAutoreleasePool localPool;
   TSMDocumentID activeDoc = ::TSMGetActiveDocument();
   NS_ENSURE_TRUE(activeDoc, eventNotHandledErr);
   ChildView *target = nil;
   OSStatus status = ::TSMGetDocumentProperty(activeDoc,
                                              kFocusedChildViewTSMDocPropertyTag,
                                              sizeof(ChildView *), nil, &target);
   NS_ENSURE_TRUE(status == noErr, eventNotHandledErr);
   NS_ENSURE_TRUE(target, eventNotHandledErr);
   EventRef keyEvent = NULL;
   status = ::GetEventParameter(aEvent, kEventParamTextInputSendKeyboardEvent,
                                typeEventRef, NULL, sizeof(EventRef), NULL,
                                &keyEvent);
   NS_ENSURE_TRUE(status == noErr, eventNotHandledErr);
   NS_ENSURE_TRUE(keyEvent, eventNotHandledErr);
   nsIWidget* widget = [target widget];
   NS_ENSURE_TRUE(widget, eventNotHandledErr);
   TextInputHandler*  handler =
     static_cast<nsChildView*>(widget)->GetTextInputHandler();
   NS_ENSURE_TRUE(handler, eventNotHandledErr);
   handler->HandleCarbonPluginKeyEvent(keyEvent);
   return noErr;
 }
 // Called from PluginKeyEventsHandler() (a handler for Carbon TSM events) to
 // process a Carbon key event for the currently focused plugin.  Both Unicode
 // characters and "Mac encoding characters" (in the MBCS or "multibyte
 // character system") are (or should be) available from aKeyEvent, but here we
 // use the MCBS characters.  This is how the WebKit does things, and seems to
 // be what plugins expect.
 void
 PluginTextInputHandler::HandleCarbonPluginKeyEvent(EventRef aKeyEvent)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
   if (Destroyed()) {
     return;
   }
   NS_ASSERTION(mView, "mView must not be NULL");
   nsRefPtr<nsChildView> kungFuDeathGrip(mWidget);
   if ([mView pluginEventModel] == NPEventModelCocoa) {
     UInt32 size;
     OSStatus status =
       ::GetEventParameter(aKeyEvent, kEventParamKeyUnicodes, typeUnicodeText,
                           NULL, 0, &size, NULL);
     NS_ENSURE_TRUE(status == noErr, );
     UniChar* chars = (UniChar*)malloc(size);
     NS_ENSURE_TRUE(chars, );
     status = ::GetEventParameter(aKeyEvent, kEventParamKeyUnicodes,
                                  typeUnicodeText, NULL, size, NULL, chars);
     if (status != noErr) {
       free(chars);
       return;
     }
     CFStringRef text =
       ::CFStringCreateWithCharactersNoCopy(kCFAllocatorDefault, chars,
                                            (size / sizeof(UniChar)),
                                            kCFAllocatorNull);
     if (!text) {
       free(chars);
       return;
     }
     NPCocoaEvent cocoaTextEvent;
     nsCocoaUtils::InitNPCocoaEvent(&cocoaTextEvent);
     cocoaTextEvent.type = NPCocoaEventTextInput;
     cocoaTextEvent.data.text.text = (NPNSString*)text;
     WidgetPluginEvent pluginEvent(true, NS_PLUGIN_INPUT_EVENT, mWidget);
     nsCocoaUtils::InitPluginEvent(pluginEvent, cocoaTextEvent);
     DispatchEvent(pluginEvent);
     ::CFRelease(text);
     free(chars);
     return;
   }
   UInt32 numCharCodes;
   OSStatus status = ::GetEventParameter(aKeyEvent, kEventParamKeyMacCharCodes,
                                         typeChar, NULL, 0, &numCharCodes, NULL);
   NS_ENSURE_TRUE(status == noErr, );
   nsAutoTArray<unsigned char, 3> charCodes;
   charCodes.SetLength(numCharCodes);
   status = ::GetEventParameter(aKeyEvent, kEventParamKeyMacCharCodes,
                                typeChar, NULL, numCharCodes, NULL,
                                charCodes.Elements());
   NS_ENSURE_TRUE(status == noErr, );
   UInt32 modifiers;
   status = ::GetEventParameter(aKeyEvent, kEventParamKeyModifiers,
                                typeUInt32, NULL, sizeof(modifiers), NULL,
                                &modifiers);
   NS_ENSURE_TRUE(status == noErr, );
   NSUInteger cocoaModifiers = 0;
   if (modifiers & shiftKey) {
     cocoaModifiers |= NSShiftKeyMask;
   }
   if (modifiers & controlKey) {
     cocoaModifiers |= NSControlKeyMask;
   }
   if (modifiers & optionKey) {
     cocoaModifiers |= NSAlternateKeyMask;
   }
   if (modifiers & cmdKey) { // Should never happen
     cocoaModifiers |= NSCommandKeyMask;
   }
   UInt32 macKeyCode;
   status = ::GetEventParameter(aKeyEvent, kEventParamKeyCode,
                                typeUInt32, NULL, sizeof(macKeyCode), NULL,
                                &macKeyCode);
   NS_ENSURE_TRUE(status == noErr, );
   TISInputSourceWrapper& currentInputSource =
     TISInputSourceWrapper::CurrentInputSource();
   EventRef cloneEvent = ::CopyEvent(aKeyEvent);
   for (uint32_t i = 0; i < numCharCodes; ++i) {
     status = ::SetEventParameter(cloneEvent, kEventParamKeyMacCharCodes,
                                  typeChar, 1, charCodes.Elements() + i);
     NS_ENSURE_TRUE(status == noErr, );
     EventRecord eventRec;
     if (::ConvertEventRefToEventRecord(cloneEvent, &eventRec)) {
       WidgetKeyboardEvent keydownEvent(true, NS_KEY_DOWN, mWidget);
       nsCocoaUtils::InitInputEvent(keydownEvent, cocoaModifiers);
       uint32_t keyCode =
         currentInputSource.ComputeGeckoKeyCode(macKeyCode, ::LMGetKbdType(),
                                                keydownEvent.IsMeta());
       uint32_t charCode(charCodes.ElementAt(i));
       keydownEvent.time = PR_IntervalNow();
       keydownEvent.pluginEvent = &eventRec;
       if (IsSpecialGeckoKey(macKeyCode)) {
         keydownEvent.keyCode = keyCode;
       } else {
         // XXX This is wrong. charCode must be 0 for keydown event.
         keydownEvent.charCode = charCode;
         keydownEvent.isChar   = true;
       }
       DispatchEvent(keydownEvent);
       if (Destroyed()) {
         break;
       }
     }
   }
   ::ReleaseEvent(cloneEvent);
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 void
 PluginTextInputHandler::ActivatePluginTSMDocument()
 {
   if (!mPluginTSMDoc) {
     // Create a TSM document that supports both non-Unicode and Unicode input.
     // Though ProcessPluginKeyEvent() only sends Mac char codes to
     // the plugin, this makes the input window behave better when it contains
     // more than one kind of input (say Hiragana and Romaji).  This is what
     // the OS does when it creates a TSM document for use by an
     // NSTSMInputContext class.
     InterfaceTypeList supportedServices;
     supportedServices[0] = kTextServiceDocumentInterfaceType;
     supportedServices[1] = kUnicodeDocumentInterfaceType;
     ::NewTSMDocument(2, supportedServices, &mPluginTSMDoc, 0);
     // We'll need to use the "input window".
     ::UseInputWindow(mPluginTSMDoc, YES);
     ::ActivateTSMDocument(mPluginTSMDoc);
   } else if (::TSMGetActiveDocument() != mPluginTSMDoc) {
     ::ActivateTSMDocument(mPluginTSMDoc);
   }
 }
 #endif // #ifndef __LP64__
 void
 PluginTextInputHandler::HandleKeyDownEventForPlugin(NSEvent* aNativeKeyEvent)
 {
   if (Destroyed()) {
     return;
   }
   NS_ASSERTION(mView, "mView must not be NULL");
 #ifdef __LP64__
   if ([mView pluginEventModel] != NPEventModelCocoa) {
     return;
   }
   ComplexTextInputPanel* ctiPanel =
     [ComplexTextInputPanel sharedComplexTextInputPanel];
   [ctiPanel adjustTo:mView];
   // If a composition is in progress then simply let the input panel continue
   // it.
   if (IsInPluginComposition()) {
     // Don't send key up events for key downs associated with compositions.
     mIgnoreNextKeyUpEvent = true;
     NSString* textString = nil;
     [ctiPanel interpretKeyEvent:aNativeKeyEvent string:&textString];
     if (textString) {
       DispatchCocoaNPAPITextEvent(textString);
     }
     return;
   }
   // Reset complex text input request flag.
   mPluginComplexTextInputRequested = false;
   // Send key down event to the plugin.
   WidgetPluginEvent pluginEvent(true, NS_PLUGIN_INPUT_EVENT, mWidget);
   NPCocoaEvent cocoaEvent;
   ConvertCocoaKeyEventToNPCocoaEvent(aNativeKeyEvent, cocoaEvent);
   nsCocoaUtils::InitPluginEvent(pluginEvent, cocoaEvent);
   DispatchEvent(pluginEvent);
   if (Destroyed()) {
     return;
   }
   // Start complex text composition if requested.
   if (mPluginComplexTextInputRequested) {
     // Don't send key up events for key downs associated with compositions.
     mIgnoreNextKeyUpEvent = true;
     NSString* textString = nil;
     [ctiPanel interpretKeyEvent:aNativeKeyEvent string:&textString];
     if (textString) {
       DispatchCocoaNPAPITextEvent(textString);
     }
   }
 #else // #ifdef __LP64__
   bool wasInComposition = false;
   if ([mView pluginEventModel] == NPEventModelCocoa) {
     if (IsInPluginComposition()) {
       wasInComposition = true;
       // Don't send key up events for key downs associated with compositions.
       mIgnoreNextKeyUpEvent = true;
     } else {
       // Reset complex text input request flag.
       mPluginComplexTextInputRequested = false;
       // Send key down event to the plugin.
       WidgetPluginEvent pluginEvent(true, NS_PLUGIN_INPUT_EVENT, mWidget);
       NPCocoaEvent cocoaEvent;
       ConvertCocoaKeyEventToNPCocoaEvent(aNativeKeyEvent, cocoaEvent);
       nsCocoaUtils::InitPluginEvent(pluginEvent, cocoaEvent);
       DispatchEvent(pluginEvent);
       if (Destroyed()) {
         return;
       }
       // Only continue if plugin wants complex text input.
       if (!mPluginComplexTextInputRequested) {
         return;
       }
       // Don't send key up events for key downs associated with compositions.
       mIgnoreNextKeyUpEvent = true;
     }
     // Don't send complex text input to a plugin in Cocoa event mode if
     // either the Control key or the Command key is pressed -- even if the
     // plugin has requested it, or we are already in IME composition.  This
     // conforms to our behavior in 64-bit mode and fixes bug 619217.
     NSUInteger modifierFlags = [aNativeKeyEvent modifierFlags];
     if ((modifierFlags & NSControlKeyMask) ||
         (modifierFlags & NSCommandKeyMask)) {
       return;
     }
   }
   // This will take care of all Carbon plugin events and also send Cocoa plugin
   // text events when NSInputContext is not available (ifndef NP_NO_CARBON).
   ActivatePluginTSMDocument();
   // We use the active TSM document to pass a pointer to ourselves (the
   // currently focused ChildView) to PluginKeyEventsHandler().  Because this
   // pointer is weak, we should retain and release ourselves around the call
   // to TSMProcessRawKeyEvent().
   nsAutoRetainCocoaObject kungFuDeathGrip(mView);
   ::TSMSetDocumentProperty(mPluginTSMDoc,
                            kFocusedChildViewTSMDocPropertyTag,
                            sizeof(ChildView *), &mView);
   ::TSMProcessRawKeyEvent([aNativeKeyEvent _eventRef]);
   ::TSMRemoveDocumentProperty(mPluginTSMDoc,
                               kFocusedChildViewTSMDocPropertyTag);
 #endif // #ifdef __LP64__ else
 }
 void
 PluginTextInputHandler::HandleKeyUpEventForPlugin(NSEvent* aNativeKeyEvent)
 {
   if (mIgnoreNextKeyUpEvent) {
     mIgnoreNextKeyUpEvent = false;
     return;
   }
   if (Destroyed()) {
     return;
   }
   NS_ASSERTION(mView, "mView must not be NULL");
   NPEventModel eventModel = [mView pluginEventModel];
   if (eventModel == NPEventModelCocoa) {
     // Don't send key up events to Cocoa plugins during composition.
     if (IsInPluginComposition()) {
       return;
     }
     WidgetKeyboardEvent keyupEvent(true, NS_KEY_UP, mWidget);
     InitKeyEvent(aNativeKeyEvent, keyupEvent);
     NPCocoaEvent pluginEvent;
     ConvertCocoaKeyEventToNPCocoaEvent(aNativeKeyEvent, pluginEvent);
     keyupEvent.pluginEvent = &pluginEvent;
     DispatchEvent(keyupEvent);
     return;
   }
 }
 bool
 PluginTextInputHandler::IsInPluginComposition()
 {
   return
 #ifdef __LP64__
     [[ComplexTextInputPanel sharedComplexTextInputPanel] inComposition] != NO;
 #else // #ifdef __LP64__
     mPluginTSMInComposition;
 #endif // #ifdef __LP64__ else
 }
 bool
 PluginTextInputHandler::DispatchCocoaNPAPITextEvent(NSString* aString)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
   NPCocoaEvent cocoaTextEvent;
   nsCocoaUtils::InitNPCocoaEvent(&cocoaTextEvent);
   cocoaTextEvent.type = NPCocoaEventTextInput;
   cocoaTextEvent.data.text.text = (NPNSString*)aString;
   WidgetPluginEvent pluginEvent(true, NS_PLUGIN_INPUT_EVENT, mWidget);
   nsCocoaUtils::InitPluginEvent(pluginEvent, cocoaTextEvent);
   return DispatchEvent(pluginEvent);
   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(false);
 }
 #pragma mark -
 #ifndef __LP64__
 /******************************************************************************
  *
  *  PluginTextInputHandler_IMKInputSession_* implementation
  *
  ******************************************************************************/
 // IMKInputSession is an undocumented class in the HIToolbox framework.  It's
 // present on both Leopard and SnowLeopard, and is used at a low level to
 // process IME input regardless of which high-level API is used (Text Services
 // Manager or Cocoa).  It works the same way in both 32-bit and 64-bit code.
 @interface NSObject (IMKInputSessionMethodSwizzling)
 - (BOOL)PluginTextInputHandler_IMKInputSession_handleEvent:(EventRef)theEvent;
 - (void)PluginTextInputHandler_IMKInputSession_commitComposition;
 - (void)PluginTextInputHandler_IMKInputSession_finishSession;
 @end
 @implementation NSObject (IMKInputSessionMethodSwizzling)
 - (BOOL)PluginTextInputHandler_IMKInputSession_handleEvent:(EventRef)theEvent
 {
   [self retain];
   BOOL retval =
     [self PluginTextInputHandler_IMKInputSession_handleEvent:theEvent];
   NSUInteger retainCount = [self retainCount];
   [self release];
   // Return without doing anything if we've been deleted.
   if (retainCount == 1) {
     return retval;
   }
   NSWindow *mainWindow = [NSApp mainWindow];
   NSResponder *firstResponder = [mainWindow firstResponder];
   if (![firstResponder isKindOfClass:[ChildView class]]) {
     return retval;
   }
   // 'charactersEntered' is the length (in bytes) of currently "marked text"
   // -- text that's been entered in IME but not yet committed.  If it's
   // non-zero we're composing text in an IME session; if it's zero we're
   // not in an IME session.
   NSInteger entered = 0;
   object_getInstanceVariable(self, "charactersEntered",
                              (void **) &entered);
   nsIWidget* widget = [(ChildView*)firstResponder widget];
   NS_ENSURE_TRUE(widget, retval);
   TextInputHandler* handler =
     static_cast<nsChildView*>(widget)->GetTextInputHandler();
   NS_ENSURE_TRUE(handler, retval);
   handler->SetPluginTSMInComposition(entered != 0);
   return retval;
 }
 // This method is called whenever IME input is committed as a result of an
 // "abnormal" termination -- for example when changing the keyboard focus from
 // one input field to another.
 - (void)PluginTextInputHandler_IMKInputSession_commitComposition
 {
   NSWindow *mainWindow = [NSApp mainWindow];
   NSResponder *firstResponder = [mainWindow firstResponder];
   if ([firstResponder isKindOfClass:[ChildView class]]) {
     nsIWidget* widget = [(ChildView*)firstResponder widget];
     if (widget) {
       TextInputHandler* handler =
         static_cast<nsChildView*>(widget)->GetTextInputHandler();
       if (handler) {
         handler->SetPluginTSMInComposition(false);
       }
     }
   }
   [self PluginTextInputHandler_IMKInputSession_commitComposition];
 }
 // This method is called just before we're deallocated.
 - (void)PluginTextInputHandler_IMKInputSession_finishSession
 {
   NSWindow *mainWindow = [NSApp mainWindow];
   NSResponder *firstResponder = [mainWindow firstResponder];
   if ([firstResponder isKindOfClass:[ChildView class]]) {
     nsIWidget* widget = [(ChildView*)firstResponder widget];
     if (widget) {
       TextInputHandler* handler =
         static_cast<nsChildView*>(widget)->GetTextInputHandler();
       if (handler) {
         handler->SetPluginTSMInComposition(false);
       }
     }
   }
   [self PluginTextInputHandler_IMKInputSession_finishSession];
 }
 @end
 #endif // #ifndef __LP64__
 #pragma mark -
 /******************************************************************************
  *
  *  TextInputHandlerBase implementation
  *
  ******************************************************************************/
 int32_t TextInputHandlerBase::sSecureEventInputCount = 0;
 TextInputHandlerBase::TextInputHandlerBase(nsChildView* aWidget,
                                            NSView<mozView> *aNativeView) :
   mWidget(aWidget)
 {
   gHandlerInstanceCount++;
   mView = [aNativeView retain];
 }
 TextInputHandlerBase::~TextInputHandlerBase()
 {
   [mView release];
   if (--gHandlerInstanceCount == 0) {
     FinalizeCurrentInputSource();
   }
 }
 bool
 TextInputHandlerBase::OnDestroyWidget(nsChildView* aDestroyingWidget)
 {
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TextInputHandlerBase::OnDestroyWidget, "
      "aDestroyingWidget=%p, mWidget=%p",
      this, aDestroyingWidget, mWidget));
   if (aDestroyingWidget != mWidget) {
     return false;
   }
   mWidget = nullptr;
   return true;
 }
 bool
 TextInputHandlerBase::DispatchEvent(WidgetGUIEvent& aEvent)
 {
   if (aEvent.message == NS_KEY_PRESS) {
     WidgetInputEvent& inputEvent = *aEvent.AsInputEvent();
     if (!inputEvent.IsMeta()) {
       PR_LOG(gLog, PR_LOG_ALWAYS,
         ("%p TextInputHandlerBase::DispatchEvent, hiding mouse cursor", this));
       [NSCursor setHiddenUntilMouseMoves:YES];
     }
   }
   return mWidget->DispatchWindowEvent(aEvent);
 }
 void
 TextInputHandlerBase::InitKeyEvent(NSEvent *aNativeKeyEvent,
                                    WidgetKeyboardEvent& aKeyEvent,
                                    const nsAString* aInsertString)
 {
   NS_ASSERTION(aNativeKeyEvent, "aNativeKeyEvent must not be NULL");
   if (mKeyboardOverride.mOverrideEnabled) {
     TISInputSourceWrapper tis;
     tis.InitByLayoutID(mKeyboardOverride.mKeyboardLayout, true);
     tis.InitKeyEvent(aNativeKeyEvent, aKeyEvent, aInsertString);
     return;
   }
   TISInputSourceWrapper::CurrentInputSource().
     InitKeyEvent(aNativeKeyEvent, aKeyEvent, aInsertString);
 }
 nsresult
 TextInputHandlerBase::SynthesizeNativeKeyEvent(
                         int32_t aNativeKeyboardLayout,
                         int32_t aNativeKeyCode,
                         uint32_t aModifierFlags,
                         const nsAString& aCharacters,
                         const nsAString& aUnmodifiedCharacters)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
   static const uint32_t sModifierFlagMap[][2] = {
     { nsIWidget::CAPS_LOCK,       NSAlphaShiftKeyMask },
     { nsIWidget::SHIFT_L,         NSShiftKeyMask      | 0x0002 },
     { nsIWidget::SHIFT_R,         NSShiftKeyMask      | 0x0004 },
     { nsIWidget::CTRL_L,          NSControlKeyMask    | 0x0001 },
     { nsIWidget::CTRL_R,          NSControlKeyMask    | 0x2000 },
     { nsIWidget::ALT_L,           NSAlternateKeyMask  | 0x0020 },
     { nsIWidget::ALT_R,           NSAlternateKeyMask  | 0x0040 },
     { nsIWidget::COMMAND_L,       NSCommandKeyMask    | 0x0008 },
     { nsIWidget::COMMAND_R,       NSCommandKeyMask    | 0x0010 },
     { nsIWidget::NUMERIC_KEY_PAD, NSNumericPadKeyMask },
     { nsIWidget::HELP,            NSHelpKeyMask },
     { nsIWidget::FUNCTION,        NSFunctionKeyMask }
   };
   uint32_t modifierFlags = 0;
   for (uint32_t i = 0; i < ArrayLength(sModifierFlagMap); ++i) {
     if (aModifierFlags & sModifierFlagMap[i][0]) {
       modifierFlags |= sModifierFlagMap[i][1];
     }
   }
   NSInteger windowNumber = [[mView window] windowNumber];
   bool sendFlagsChangedEvent = IsModifierKey(aNativeKeyCode);
   NSEventType eventType = sendFlagsChangedEvent ? NSFlagsChanged : NSKeyDown;
   NSEvent* downEvent =
     [NSEvent     keyEventWithType:eventType
                          location:NSMakePoint(0,0)
                     modifierFlags:modifierFlags
                         timestamp:0
                      windowNumber:windowNumber
                           context:[NSGraphicsContext currentContext]
                        characters:nsCocoaUtils::ToNSString(aCharacters)
       charactersIgnoringModifiers:nsCocoaUtils::ToNSString(aUnmodifiedCharacters)
                         isARepeat:NO
                           keyCode:aNativeKeyCode];
   NSEvent* upEvent = sendFlagsChangedEvent ?
     nil : nsCocoaUtils::MakeNewCocoaEventWithType(NSKeyUp, downEvent);
   if (downEvent && (sendFlagsChangedEvent || upEvent)) {
     KeyboardLayoutOverride currentLayout = mKeyboardOverride;
     mKeyboardOverride.mKeyboardLayout = aNativeKeyboardLayout;
     mKeyboardOverride.mOverrideEnabled = true;
     [NSApp sendEvent:downEvent];
     if (upEvent) {
       [NSApp sendEvent:upEvent];
     }
     // processKeyDownEvent and keyUp block exceptions so we're sure to
     // reach here to restore mKeyboardOverride
     mKeyboardOverride = currentLayout;
   }
   return NS_OK;
   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
 }
 NSInteger
 TextInputHandlerBase::GetWindowLevel()
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TextInputHandlerBase::GetWindowLevel, Destryoed()=%s",
      this, TrueOrFalse(Destroyed())));
   if (Destroyed()) {
     return NSNormalWindowLevel;
   }
   // When an <input> element on a XUL <panel> is focused, the actual focused view
   // is the panel's parent view (mView). But the editor is displayed on the
   // popped-up widget's view (editorView).  We want the latter's window level.
   NSView<mozView>* editorView = mWidget->GetEditorView();
   NS_ENSURE_TRUE(editorView, NSNormalWindowLevel);
   NSInteger windowLevel = [[editorView window] level];
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TextInputHandlerBase::GetWindowLevel, windowLevel=%s (%X)",
      this, GetWindowLevelName(windowLevel), windowLevel));
   return windowLevel;
   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NSNormalWindowLevel);
 }
 NS_IMETHODIMP
 TextInputHandlerBase::AttachNativeKeyEvent(WidgetKeyboardEvent& aKeyEvent)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
   // Don't try to replace a native event if one already exists.
   // OS X doesn't have an OS modifier, can't make a native event.
   if (aKeyEvent.mNativeKeyEvent || aKeyEvent.modifiers & MODIFIER_OS) {
     return NS_OK;
   }
   PR_LOG(gLog, PR_LOG_ALWAYS,
     ("%p TextInputHandlerBase::AttachNativeKeyEvent, key=0x%X, char=0x%X, "
      "mod=0x%X", this, aKeyEvent.keyCode, aKeyEvent.charCode,
      aKeyEvent.modifiers));
   NSEventType eventType;
   if (aKeyEvent.message == NS_KEY_UP) {
     eventType = NSKeyUp;
   } else {
     eventType = NSKeyDown;
   }
   static const uint32_t sModifierFlagMap[][2] = {
     { MODIFIER_SHIFT,    NSShiftKeyMask },
     { MODIFIER_CONTROL,  NSControlKeyMask },
     { MODIFIER_ALT,      NSAlternateKeyMask },
     { MODIFIER_ALTGRAPH, NSAlternateKeyMask },
     { MODIFIER_META,     NSCommandKeyMask },
     { MODIFIER_CAPSLOCK, NSAlphaShiftKeyMask },
     { MODIFIER_NUMLOCK,  NSNumericPadKeyMask }
   };
   NSUInteger modifierFlags = 0;
   for (uint32_t i = 0; i < ArrayLength(sModifierFlagMap); ++i) {
     if (aKeyEvent.modifiers & sModifierFlagMap[i][0]) {
       modifierFlags |= sModifierFlagMap[i][1];
     }
   }
   NSInteger windowNumber = [[mView window] windowNumber];
   NSString* characters;
   if (aKeyEvent.charCode) {
     characters = [NSString stringWithCharacters:
       reinterpret_cast<const unichar*>(&(aKeyEvent.charCode)) length:1];
   } else {
     uint32_t cocoaCharCode =
       nsCocoaUtils::ConvertGeckoKeyCodeToMacCharCode(aKeyEvent.keyCode);
     characters = [NSString stringWithCharacters:
       reinterpret_cast<const unichar*>(&cocoaCharCode) length:1];
   }
   aKeyEvent.mNativeKeyEvent =
     [NSEvent     keyEventWithType:eventType
                          location:NSMakePoint(0,0)
                     modifierFlags:modifierFlags
                         timestamp:0
                      windowNumber:windowNumber
                           context:[NSGraphicsContext currentContext]
                        characters:characters
       charactersIgnoringModifiers:characters
                         isARepeat:NO
                           keyCode:0]; // Native key code not currently needed
   return NS_OK;
   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
 }
 bool
 TextInputHandlerBase::SetSelection(NSRange& aRange)
 {
   MOZ_ASSERT(!Destroyed());
   nsRefPtr<TextInputHandlerBase> kungFuDeathGrip(this);
   WidgetSelectionEvent selectionEvent(true, NS_SELECTION_SET, mWidget);
   selectionEvent.mOffset = aRange.location;
   selectionEvent.mLength = aRange.length;
   selectionEvent.mReversed = false;
   selectionEvent.mExpandToClusterBoundary = false;
   DispatchEvent(selectionEvent);
   NS_ENSURE_TRUE(selectionEvent.mSucceeded, false);
   return !Destroyed();
 }
 /* static */ bool
 TextInputHandlerBase::IsPrintableChar(char16_t aChar)
 {
   return (aChar >= 0x20 && aChar <= 0x7E) || aChar >= 0xA0;
 }
 /* static */ bool
 TextInputHandlerBase::IsSpecialGeckoKey(UInt32 aNativeKeyCode)
 {
   // this table is used to determine which keys are special and should not
   // generate a charCode
   switch (aNativeKeyCode) {
     // modifiers - we don't get separate events for these yet
     case kVK_Escape:
     case kVK_Shift:
     case kVK_RightShift:
     case kVK_Command:
     case kVK_RightCommand:
     case kVK_CapsLock:
     case kVK_Control:
     case kVK_RightControl:
     case kVK_Option:
     case kVK_RightOption:
     case kVK_ANSI_KeypadClear:
     case kVK_Function:
     // function keys
     case kVK_F1:
     case kVK_F2:
     case kVK_F3:
     case kVK_F4:
     case kVK_F5:
     case kVK_F6:
     case kVK_F7:
     case kVK_F8:
     case kVK_F9:
     case kVK_F10:
     case kVK_F11:
     case kVK_F12:
     case kVK_PC_Pause:
     case kVK_PC_ScrollLock:
     case kVK_PC_PrintScreen:
     case kVK_F16:
     case kVK_F17:
     case kVK_F18:
     case kVK_F19:
     case kVK_PC_Insert:
     case kVK_PC_Delete:
     case kVK_Tab:
     case kVK_PC_Backspace:
     case kVK_PC_ContextMenu:
     case kVK_JIS_Eisu:
     case kVK_JIS_Kana:
     case kVK_Home:
     case kVK_End:
     case kVK_PageUp:
     case kVK_PageDown:
     case kVK_LeftArrow:
     case kVK_RightArrow:
     case kVK_UpArrow:
     case kVK_DownArrow:
     case kVK_Return:
     case kVK_ANSI_KeypadEnter:
     case kVK_Powerbook_KeypadEnter:
       return true;
   }
   return false;
 }
 /* static */ bool
 TextInputHandlerBase::IsNormalCharInputtingEvent(
                         const WidgetKeyboardEvent& aKeyEvent)
 {
   // this is not character inputting event, simply.
   if (!aKeyEvent.isChar || !aKeyEvent.charCode || aKeyEvent.IsMeta()) {
     return false;
   }
   // if this is unicode char inputting event, we don't need to check
   // ctrl/alt/command keys
   if (aKeyEvent.charCode > 0x7F) {
     return true;
   }
   // ASCII chars should be inputted without ctrl/alt/command keys
   return !aKeyEvent.IsControl() && !aKeyEvent.IsAlt();
 }
 /* static */ bool
 TextInputHandlerBase::IsModifierKey(UInt32 aNativeKeyCode)
 {
   switch (aNativeKeyCode) {
     case kVK_CapsLock:
     case kVK_RightCommand:
     case kVK_Command:
     case kVK_Shift:
     case kVK_Option:
     case kVK_Control:
     case kVK_RightShift:
     case kVK_RightOption:
     case kVK_RightControl:
     case kVK_Function:
       return true;
   }
   return false;
 }
 /* static */ void
 TextInputHandlerBase::EnableSecureEventInput()
 {
   sSecureEventInputCount++;
   ::EnableSecureEventInput();
 }
 /* static */ void
 TextInputHandlerBase::DisableSecureEventInput()
 {
   if (!sSecureEventInputCount) {
     return;
   }
   sSecureEventInputCount--;
   ::DisableSecureEventInput();
 }
 /* static */ bool
 TextInputHandlerBase::IsSecureEventInputEnabled()
 {
   NS_ASSERTION(!!sSecureEventInputCount == !!::IsSecureEventInputEnabled(),
                "Some other process has enabled secure event input");
   return !!sSecureEventInputCount;
 }
 /* static */ void
 TextInputHandlerBase::EnsureSecureEventInputDisabled()
 {
   while (sSecureEventInputCount) {
     TextInputHandlerBase::DisableSecureEventInput();
   }
 }

The Tor Browser / annotate

widget/cocoa/TextInputHandler.mm@ac0c01689b40 (annotated)

widget/cocoa/TextInputHandler.mm