Android: convert kEnumName to ENUM_NAME in java_cpp_enum.py.

content/public/android/java/src/org/chromium/content/browser/input/ImeAdapter.java

 // Copyright 2012 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.
 
 package org.chromium.content.browser.input;
 
 import android.annotation.SuppressLint;
 import android.content.res.Configuration;
 import android.graphics.Rect;
 import android.os.Build;
@@ skipping 79 matching lines @@
     // This holds the information necessary for constructing CursorAnchorInfo, and notifies to
     // InputMethodManager on appropriate timing, depending on how IME requested the information
     // via InputConnection. The update request is per InputConnection, hence for each time it is
     // re-created, the monitoring status will be reset.
     private final CursorAnchorInfoController mCursorAnchorInfoController;
 
     private final List<ImeEventObserver> mEventObservers = new ArrayList<>();
 
     private int mTextInputType = TextInputType.NONE;
     private int mTextInputFlags;
-    private int mTextInputMode = WebTextInputMode.kDefault;
+    private int mTextInputMode = WebTextInputMode.DEFAULT;
     private boolean mNodeEditable;
     private boolean mNodePassword;
 
     // Viewport rect before the OSK was brought up.
     // Used to tell View#onSizeChanged to focus a form element.
     private final Rect mFocusPreOSKViewportRect = new Rect();
 
     // Keep the current configuration to detect the change when onConfigurationChanged() is called.
     private Configuration mCurrentConfig;
 
@@ skipping 169 matching lines @@
      * Get the current input connection for testing purposes.
      */
     @VisibleForTesting
     public ChromiumBaseInputConnection getInputConnectionForTest() {
         return mInputConnection;
     }
 
     private static int getModifiers(int metaState) {
         int modifiers = 0;
         if ((metaState & KeyEvent.META_SHIFT_ON) != 0) {
-            modifiers |= WebInputEventModifier.kShiftKey;
+            modifiers |= WebInputEventModifier.SHIFT_KEY;
         }
         if ((metaState & KeyEvent.META_ALT_ON) != 0) {
-            modifiers |= WebInputEventModifier.kAltKey;
+            modifiers |= WebInputEventModifier.ALT_KEY;
         }
         if ((metaState & KeyEvent.META_CTRL_ON) != 0) {
-            modifiers |= WebInputEventModifier.kControlKey;
+            modifiers |= WebInputEventModifier.CONTROL_KEY;
         }
         if ((metaState & KeyEvent.META_CAPS_LOCK_ON) != 0) {
-            modifiers |= WebInputEventModifier.kCapsLockOn;
+            modifiers |= WebInputEventModifier.CAPS_LOCK_ON;
         }
         if ((metaState & KeyEvent.META_NUM_LOCK_ON) != 0) {
-            modifiers |= WebInputEventModifier.kNumLockOn;
+            modifiers |= WebInputEventModifier.NUM_LOCK_ON;
         }
         return modifiers;
     }
 
     /**
      * Updates internal representation of the text being edited and its selection and composition
      * properties.
      *
      * @param textInputType Text input type for the currently focused field in renderer.
      * @param textInputFlags Text input flags.
@@ skipping 237 matching lines @@
         return sendKeyEvent(event);
     }
 
     /**
      * Resets IME adapter and hides keyboard. Note that this will also unblock input connection.
      */
     public void resetAndHideKeyboard() {
         if (DEBUG_LOGS) Log.i(TAG, "resetAndHideKeyboard");
         mTextInputType = TextInputType.NONE;
         mTextInputFlags = 0;
-        mTextInputMode = WebTextInputMode.kDefault;
+        mTextInputMode = WebTextInputMode.DEFAULT;
         mRestartInputOnNextStateUpdate = false;
         // This will trigger unblocking if necessary.
         hideKeyboard();
     }
 
     @CalledByNative
     private void destroy() {
         resetAndHideKeyboard();
         mNativeImeAdapterAndroid = 0;
         mIsConnected = false;
@@ skipping 90 matching lines @@
 
         // One WebView app detects Enter in JS by looking at KeyDown (http://crbug/577967).
         if (TextUtils.equals(text, "\n")) {
             sendSyntheticKeyPress(KeyEvent.KEYCODE_ENTER,
                     KeyEvent.FLAG_SOFT_KEYBOARD | KeyEvent.FLAG_KEEP_TOUCH_MODE);
             return true;
         }
 
         onImeEvent();
         long timestampMs = SystemClock.uptimeMillis();
-        nativeSendKeyEvent(mNativeImeAdapterAndroid, null, WebInputEventType.kRawKeyDown, 0,
+        nativeSendKeyEvent(mNativeImeAdapterAndroid, null, WebInputEventType.RAW_KEY_DOWN, 0,
                 timestampMs, COMPOSITION_KEY_CODE, 0, false, unicodeFromKeyEvent);
 
         if (isCommit) {
             nativeCommitText(mNativeImeAdapterAndroid, text, text.toString(), newCursorPosition);
         } else {
             nativeSetComposingText(
                     mNativeImeAdapterAndroid, text, text.toString(), newCursorPosition);
         }
 
-        nativeSendKeyEvent(mNativeImeAdapterAndroid, null, WebInputEventType.kKeyUp, 0, timestampMs,
+        nativeSendKeyEvent(mNativeImeAdapterAndroid, null, WebInputEventType.KEY_UP, 0, timestampMs,
                 COMPOSITION_KEY_CODE, 0, false, unicodeFromKeyEvent);
         return true;
     }
 
     @VisibleForTesting
     boolean finishComposingText() {
         if (!isValid()) return false;
         nativeFinishComposingText(mNativeImeAdapterAndroid);
         return true;
     }
 
     boolean sendKeyEvent(KeyEvent event) {
         if (!isValid()) return false;
 
         int action = event.getAction();
         int type;
         if (action == KeyEvent.ACTION_DOWN) {
-            type = WebInputEventType.kKeyDown;
+            type = WebInputEventType.KEY_DOWN;
         } else if (action == KeyEvent.ACTION_UP) {
-            type = WebInputEventType.kKeyUp;
+            type = WebInputEventType.KEY_UP;
         } else {
             // In theory, KeyEvent.ACTION_MULTIPLE is a valid value, but in practice
             // this seems to have been quietly deprecated and we've never observed
             // a case where it's sent (holding down physical keyboard key also
             // sends ACTION_DOWN), so it's fine to silently drop it.
             return false;
         }
         onImeEvent();
 
         return nativeSendKeyEvent(mNativeImeAdapterAndroid, event, type,
                 getModifiers(event.getMetaState()), event.getEventTime(), event.getKeyCode(),
                              event.getScanCode(), /*isSystemKey=*/false, event.getUnicodeChar());
     }
 
     /**
      * Send a request to the native counterpart to delete a given range of characters.
      * @param beforeLength Number of characters to extend the selection by before the existing
      *                     selection.
      * @param afterLength Number of characters to extend the selection by after the existing
      *                    selection.
      * @return Whether the native counterpart of ImeAdapter received the call.
      */
     boolean deleteSurroundingText(int beforeLength, int afterLength) {
         onImeEvent();
         if (!isValid()) return false;
-        nativeSendKeyEvent(mNativeImeAdapterAndroid, null, WebInputEventType.kRawKeyDown, 0,
+        nativeSendKeyEvent(mNativeImeAdapterAndroid, null, WebInputEventType.RAW_KEY_DOWN, 0,
                 SystemClock.uptimeMillis(), COMPOSITION_KEY_CODE, 0, false, 0);
         nativeDeleteSurroundingText(mNativeImeAdapterAndroid, beforeLength, afterLength);
-        nativeSendKeyEvent(mNativeImeAdapterAndroid, null, WebInputEventType.kKeyUp, 0,
+        nativeSendKeyEvent(mNativeImeAdapterAndroid, null, WebInputEventType.KEY_UP, 0,
                 SystemClock.uptimeMillis(), COMPOSITION_KEY_CODE, 0, false, 0);
         return true;
     }
 
     /**
      * Send a request to the native counterpart to delete a given range of characters.
      * @param beforeLength Number of code points to extend the selection by before the existing
      *                     selection.
      * @param afterLength Number of code points to extend the selection by after the existing
      *                    selection.
      * @return Whether the native counterpart of ImeAdapter received the call.
      */
     boolean deleteSurroundingTextInCodePoints(int beforeLength, int afterLength) {
         onImeEvent();
         if (!isValid()) return false;
-        nativeSendKeyEvent(mNativeImeAdapterAndroid, null, WebInputEventType.kRawKeyDown, 0,
+        nativeSendKeyEvent(mNativeImeAdapterAndroid, null, WebInputEventType.RAW_KEY_DOWN, 0,
                 SystemClock.uptimeMillis(), COMPOSITION_KEY_CODE, 0, false, 0);
         nativeDeleteSurroundingTextInCodePoints(
                 mNativeImeAdapterAndroid, beforeLength, afterLength);
-        nativeSendKeyEvent(mNativeImeAdapterAndroid, null, WebInputEventType.kKeyUp, 0,
+        nativeSendKeyEvent(mNativeImeAdapterAndroid, null, WebInputEventType.KEY_UP, 0,
                 SystemClock.uptimeMillis(), COMPOSITION_KEY_CODE, 0, false, 0);
         return true;
     }
 
     /**
      * Send a request to the native counterpart to set the selection to given range.
      * @param start Selection start index.
      * @param end Selection end index.
      * @return Whether the native counterpart of ImeAdapter received the call.
      */
@@ skipping 139 matching lines @@
             int start, int end);
     private native void nativeSetComposingRegion(long nativeImeAdapterAndroid, int start, int end);
     private native void nativeDeleteSurroundingText(long nativeImeAdapterAndroid,
             int before, int after);
     private native void nativeDeleteSurroundingTextInCodePoints(
             long nativeImeAdapterAndroid, int before, int after);
     private native boolean nativeRequestTextInputStateUpdate(long nativeImeAdapterAndroid);
     private native void nativeRequestCursorUpdate(long nativeImeAdapterAndroid,
             boolean immediateRequest, boolean monitorRequest);
 }