Use the new java_cpp_enum rule in content.

content/public/android/java/src/org/chromium/content/browser/SpeechRecognition.java

 // Copyright 2013 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;
 
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.PackageManager;
 import android.content.pm.PackageManager.NameNotFoundException;
 import android.content.pm.ResolveInfo;
 import android.content.pm.ServiceInfo;
 import android.os.Bundle;
 import android.speech.RecognitionListener;
 import android.speech.RecognitionService;
 import android.speech.RecognizerIntent;
 import android.speech.SpeechRecognizer;
 
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
+import org.chromium.content_public.common.SpeechRecognitionErrorCode;
 
 import java.util.ArrayList;
 import java.util.List;
 
 /**
  * This class uses Android's SpeechRecognizer to perform speech recognition for the Web Speech API
  * on Android. Using Android's platform recognizer offers several benefits, like good quality and
  * good local fallback when no data connection is available.
  */
 @JNINamespace("content")
@@ skipping 50 matching lines @@
                 nativeOnSoundEnd(mNativeSpeechRecognizerImplAndroid);
                 // Since Android doesn't have a dedicated event for when audio capture is finished,
                 // we fire it after speech has ended.
                 nativeOnAudioEnd(mNativeSpeechRecognizerImplAndroid);
                 mState = STATE_IDLE;
             }
         }
 
         @Override
         public void onError(int error) {
-            int code = SpeechRecognitionError.NONE;
+            int code = SpeechRecognitionErrorCode.NONE;
 
             // Translate Android SpeechRecognizer errors to Web Speech API errors.
             switch(error) {
                 case SpeechRecognizer.ERROR_AUDIO:
-                    code = SpeechRecognitionError.AUDIO;
+                    code = SpeechRecognitionErrorCode.AUDIO;
                     break;
                 case SpeechRecognizer.ERROR_CLIENT:
-                    code = SpeechRecognitionError.ABORTED;
+                    code = SpeechRecognitionErrorCode.ABORTED;
                     break;
                 case SpeechRecognizer.ERROR_RECOGNIZER_BUSY:
                 case SpeechRecognizer.ERROR_INSUFFICIENT_PERMISSIONS:
-                    code = SpeechRecognitionError.NOT_ALLOWED;
+                    code = SpeechRecognitionErrorCode.NOT_ALLOWED;
                     break;
                 case SpeechRecognizer.ERROR_NETWORK_TIMEOUT:
                 case SpeechRecognizer.ERROR_NETWORK:
                 case SpeechRecognizer.ERROR_SERVER:
-                    code = SpeechRecognitionError.NETWORK;
+                    code = SpeechRecognitionErrorCode.NETWORK;
                     break;
                 case SpeechRecognizer.ERROR_NO_MATCH:
-                    code = SpeechRecognitionError.NO_MATCH;
+                    code = SpeechRecognitionErrorCode.NO_MATCH;
                     break;
                 case SpeechRecognizer.ERROR_SPEECH_TIMEOUT:
-                    code = SpeechRecognitionError.NO_SPEECH;
+                    code = SpeechRecognitionErrorCode.NO_SPEECH;
                     break;
                 default:
                     assert false;
                     return;
             }
 
             terminate(code);
         }
 
         @Override
         public void onEvent(int event, Bundle bundle) { }
 
         @Override
         public void onPartialResults(Bundle bundle) {
             handleResults(bundle, true);
         }
 
         @Override
         public void onReadyForSpeech(Bundle bundle) {
             mState = STATE_AWAITING_SPEECH;
             nativeOnAudioStart(mNativeSpeechRecognizerImplAndroid);
         }
 
         @Override
         public void onResults(Bundle bundle) {
             handleResults(bundle, false);
             // We assume that onResults is called only once, at the end of a session, thus we
             // terminate. If one day the recognition provider changes dictation mode behavior to
             // call onResults several times, we should terminate only if (!mContinuous).
-            terminate(SpeechRecognitionError.NONE);
+            terminate(SpeechRecognitionErrorCode.NONE);
         }
 
         @Override
         public void onRmsChanged(float rms) { }
 
         private void handleResults(Bundle bundle, boolean provisional) {
             if (mContinuous && provisional) {
                 // In continuous mode, Android's recognizer sends final results as provisional.
                 provisional = false;
             }
@@ skipping 74 matching lines @@
     private void terminate(int error) {
 
         if (mState != STATE_IDLE) {
             if (mState == STATE_CAPTURING_SPEECH) {
                 nativeOnSoundEnd(mNativeSpeechRecognizerImplAndroid);
             }
             nativeOnAudioEnd(mNativeSpeechRecognizerImplAndroid);
             mState = STATE_IDLE;
         }
 
-        if (error != SpeechRecognitionError.NONE)
+        if (error != SpeechRecognitionErrorCode.NONE)
             nativeOnRecognitionError(mNativeSpeechRecognizerImplAndroid, error);
 
         mRecognizer.destroy();
         mRecognizer = null;
         nativeOnRecognitionEnd(mNativeSpeechRecognizerImplAndroid);
         mNativeSpeechRecognizerImplAndroid = 0;
     }
 
     @CalledByNative
     private static SpeechRecognition createSpeechRecognition(
@@ skipping 12 matching lines @@
         mIntent.putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, interimResults);
         mRecognizer.startListening(mIntent);
     }
 
     @CalledByNative
     private void abortRecognition() {
         if (mRecognizer == null)
             return;
 
         mRecognizer.cancel();
-        terminate(SpeechRecognitionError.ABORTED);
+        terminate(SpeechRecognitionErrorCode.ABORTED);
     }
 
     @CalledByNative
     private void stopRecognition() {
         if (mRecognizer == null)
             return;
 
         mContinuous = false;
         mRecognizer.stopListening();
     }
 
     // Native JNI calls to content/browser/speech/speech_recognizer_impl_android.cc
     private native void nativeOnAudioStart(long nativeSpeechRecognizerImplAndroid);
     private native void nativeOnSoundStart(long nativeSpeechRecognizerImplAndroid);
     private native void nativeOnSoundEnd(long nativeSpeechRecognizerImplAndroid);
     private native void nativeOnAudioEnd(long nativeSpeechRecognizerImplAndroid);
     private native void nativeOnRecognitionResults(long nativeSpeechRecognizerImplAndroid,
                                                    String[] results,
                                                    float[] scores,
                                                    boolean provisional);
     private native void nativeOnRecognitionError(long nativeSpeechRecognizerImplAndroid, int error);
     private native void nativeOnRecognitionEnd(long nativeSpeechRecognizerImplAndroid);
 }