Support NSFlagsChanged in ui::EventFromNative.

content/browser/renderer_host/input/web_input_event_builders_mac.mm

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /*
  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006-2009 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ skipping 30 matching lines @@
 #include "ui/base/cocoa/cocoa_base_utils.h"
 #include "ui/events/blink/blink_event_util.h"
 #import "ui/events/cocoa/cocoa_event_utils.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 #include "ui/events/keycodes/keyboard_code_conversion_mac.h"
 
 namespace content {
 
 namespace {
 
-// Return true if the target modifier key is up. OS X has an "official" flag
-// to test whether either left or right versions of a modifier key are held,
-// and "unofficial" flags for the left and right versions independently. This
-// function verifies that |target_key_mask| and |otherKeyMask| (which should be
-// the left and right versions of a modifier) are consistent with with the
-// state of |eitherKeyMask| (which should be the corresponding ""official"
-// flag). If they are consistent, it tests |target_key_mask|; otherwise it tests
-// |either_key_mask|.
-inline bool IsModifierKeyUp(unsigned int flags,
-                            unsigned int target_key_mask,
-                            unsigned int other_key_mask,
-                            unsigned int either_key_mask) {
-  bool either_key_down = (flags & either_key_mask) != 0;
-  bool target_key_down = (flags & target_key_mask) != 0;
-  bool other_key_down = (flags & other_key_mask) != 0;
-  if (either_key_down != (target_key_down || other_key_down))
-    return !either_key_down;
-  return !target_key_down;
-}
-
-bool IsKeyUpEvent(NSEvent* event) {
-  if ([event type] != NSFlagsChanged)
-    return [event type] == NSKeyUp;
-
-  // Unofficial bit-masks for left- and right-hand versions of modifier keys.
-  // These values were determined empirically.
-  const unsigned int kLeftControlKeyMask = 1 << 0;
-  const unsigned int kLeftShiftKeyMask = 1 << 1;
-  const unsigned int kRightShiftKeyMask = 1 << 2;
-  const unsigned int kLeftCommandKeyMask = 1 << 3;
-  const unsigned int kRightCommandKeyMask = 1 << 4;
-  const unsigned int kLeftAlternateKeyMask = 1 << 5;
-  const unsigned int kRightAlternateKeyMask = 1 << 6;
-  const unsigned int kRightControlKeyMask = 1 << 13;
-
-  switch ([event keyCode]) {
-    case 54:  // Right Command
-      return IsModifierKeyUp([event modifierFlags], kRightCommandKeyMask,
-                             kLeftCommandKeyMask, NSCommandKeyMask);
-    case 55:  // Left Command
-      return IsModifierKeyUp([event modifierFlags], kLeftCommandKeyMask,
-                             kRightCommandKeyMask, NSCommandKeyMask);
-
-    case 57:  // Capslock
-      return ([event modifierFlags] & NSAlphaShiftKeyMask) == 0;
-
-    case 56:  // Left Shift
-      return IsModifierKeyUp([event modifierFlags], kLeftShiftKeyMask,
-                             kRightShiftKeyMask, NSShiftKeyMask);
-    case 60:  // Right Shift
-      return IsModifierKeyUp([event modifierFlags], kRightShiftKeyMask,
-                             kLeftShiftKeyMask, NSShiftKeyMask);
-
-    case 58:  // Left Alt
-      return IsModifierKeyUp([event modifierFlags], kLeftAlternateKeyMask,
-                             kRightAlternateKeyMask, NSAlternateKeyMask);
-    case 61:  // Right Alt
-      return IsModifierKeyUp([event modifierFlags], kRightAlternateKeyMask,
-                             kLeftAlternateKeyMask, NSAlternateKeyMask);
-
-    case 59:  // Left Ctrl
-      return IsModifierKeyUp([event modifierFlags], kLeftControlKeyMask,
-                             kRightControlKeyMask, NSControlKeyMask);
-    case 62:  // Right Ctrl
-      return IsModifierKeyUp([event modifierFlags], kRightControlKeyMask,
-                             kLeftControlKeyMask, NSControlKeyMask);
-
-    case 63:  // Function
-      return ([event modifierFlags] & NSFunctionKeyMask) == 0;
-  }
-  return false;
-}
-
 inline NSString* FilterSpecialCharacter(NSString* str) {
   if ([str length] != 1)
     return str;
   unichar c = [str characterAtIndex:0];
   NSString* result = str;
   if (c == 0x7F) {
     // Backspace should be 8
     result = @"\x8";
   } else if (c >= 0xF700 && c <= 0xF7FF) {
     // Mac private use characters should be @"\0" (@"" won't work)
@@ skipping 135 matching lines @@
   if (key != ui::DomKey::NONE)
     return key;
   return ui::DomKey::UNIDENTIFIED;
 }
 
 }  // namespace
 
 blink::WebKeyboardEvent WebKeyboardEventBuilder::Build(NSEvent* event) {
   blink::WebKeyboardEvent result;
 
-  result.type = IsKeyUpEvent(event) ? blink::WebInputEvent::KeyUp
-                                    : blink::WebInputEvent::RawKeyDown;
+  result.type = ui::IsKeyUpEvent(event) ? blink::WebInputEvent::KeyUp
+                                        : blink::WebInputEvent::RawKeyDown;
 
   result.modifiers = ModifiersFromEvent(event);
 
   if (([event type] != NSFlagsChanged) && [event isARepeat])
     result.modifiers |= blink::WebInputEvent::IsAutoRepeat;
 
   ui::DomCode dom_code = ui::DomCodeFromNSEvent(event);
   result.windowsKeyCode =
       ui::LocatedToNonLocatedKeyboardCode(ui::KeyboardCodeFromNSEvent(event));
   result.modifiers |= ui::DomCodeToWebInputEventModifiers(dom_code);
@@ skipping 324 matching lines @@
       break;
     default:
       NOTIMPLEMENTED();
       result.type = blink::WebInputEvent::Undefined;
   }
 
   return result;
 }
 
 }  // namespace content