| OLD | NEW | 
|     1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |     1 // Copyright 2014 The Chromium Authors. All rights reserved. | 
|     2 // Use of this source code is governed by a BSD-style license that can be |     2 // Use of this source code is governed by a BSD-style license that can be | 
|     3 // found in the LICENSE file. |     3 // found in the LICENSE file. | 
|     4  |     4  | 
|     5 // This file is autogenerated by |     5 // This file is autogenerated by | 
|     6 //     base/android/jni_generator/jni_generator.py |     6 //     base/android/jni_generator/jni_generator.py | 
|     7 // For |     7 // For | 
|     8 //     android/view/MotionEvent |     8 //     android/view/MotionEvent | 
|     9  |     9  | 
|    10 #ifndef android_view_MotionEvent_JNI |    10 #ifndef android_view_MotionEvent_JNI | 
|    11 #define android_view_MotionEvent_JNI |    11 #define android_view_MotionEvent_JNI | 
|    12  |    12  | 
|    13 #include <jni.h> |    13 #include <jni.h> | 
|    14  |    14  | 
|    15 #include "base/android/jni_generator/jni_generator_helper.h" |    15 #include "base/android/jni_generator/jni_generator_helper.h" | 
|    16  |    16  | 
|    17 #include "base/android/jni_int_wrapper.h" |    17 #include "base/android/jni_int_wrapper.h" | 
|    18  |    18  | 
|    19 // Step 1: forward declarations. |    19 // Step 1: forward declarations. | 
|    20 namespace { |    20 namespace { | 
|    21 const char kMotionEventClassPath[] = "android/view/MotionEvent"; |    21 const char kMotionEventClassPath[] = "android/view/MotionEvent"; | 
 |    22 #if __clang__ | 
 |    23 #pragma clang diagnostic push | 
 |    24 #pragma clang diagnostic ignored "-Wunused-function" | 
 |    25 #endif | 
|    22 // Leaking this jclass as we cannot use LazyInstance from some threads. |    26 // Leaking this jclass as we cannot use LazyInstance from some threads. | 
|    23 jclass g_MotionEvent_clazz = NULL; |    27 jclass g_MotionEvent_clazz = NULL; | 
 |    28 jclass MotionEvent_clazz(JNIEnv*) { return g_MotionEvent_clazz; } | 
 |    29 #if __clang__ | 
 |    30 #pragma clang diagnostic pop | 
 |    31 #endif | 
|    24  |    32  | 
|    25 }  // namespace |    33 }  // namespace | 
|    26  |    34  | 
|    27 namespace JNI_MotionEvent { |    35 namespace JNI_MotionEvent { | 
|    28  |    36  | 
|    29 enum Java_MotionEvent_constant_fields { |    37 enum Java_MotionEvent_constant_fields { | 
|    30   INVALID_POINTER_ID = -1, |    38   INVALID_POINTER_ID = -1, | 
|    31   ACTION_MASK = 255, |    39   ACTION_MASK = 255, | 
|    32   ACTION_DOWN = 0, |    40   ACTION_DOWN = 0, | 
|    33   ACTION_UP = 1, |    41   ACTION_UP = 1, | 
| (...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after  Loading... | 
|   110 }; |   118 }; | 
|   111  |   119  | 
|   112 // Step 2: method stubs. |   120 // Step 2: method stubs. | 
|   113  |   121  | 
|   114 static base::subtle::AtomicWord g_MotionEvent_finalize = 0; |   122 static base::subtle::AtomicWord g_MotionEvent_finalize = 0; | 
|   115 static void Java_MotionEvent_finalize(JNIEnv* env, jobject obj) __attribute__ |   123 static void Java_MotionEvent_finalize(JNIEnv* env, jobject obj) __attribute__ | 
|   116     ((unused)); |   124     ((unused)); | 
|   117 static void Java_MotionEvent_finalize(JNIEnv* env, jobject obj) { |   125 static void Java_MotionEvent_finalize(JNIEnv* env, jobject obj) { | 
|   118   /* Must call RegisterNativesImpl()  */ |   126   /* Must call RegisterNativesImpl()  */ | 
|   119   CHECK_CLAZZ(env, obj, |   127   CHECK_CLAZZ(env, obj, | 
|   120       g_MotionEvent_clazz); |   128       MotionEvent_clazz(env)); | 
|   121   jmethodID method_id = |   129   jmethodID method_id = | 
|   122       base::android::MethodID::LazyGet< |   130       base::android::MethodID::LazyGet< | 
|   123       base::android::MethodID::TYPE_INSTANCE>( |   131       base::android::MethodID::TYPE_INSTANCE>( | 
|   124       env, g_MotionEvent_clazz, |   132       env, MotionEvent_clazz(env), | 
|   125       "finalize", |   133       "finalize", | 
|   126       "()V", |   134       "()V", | 
|   127       &g_MotionEvent_finalize); |   135       &g_MotionEvent_finalize); | 
|   128  |   136  | 
|   129      env->CallVoidMethod(obj, |   137      env->CallVoidMethod(obj, | 
|   130           method_id); |   138           method_id); | 
|   131   jni_generator::CheckException(env); |   139   jni_generator::CheckException(env); | 
|   132  |   140  | 
|   133 } |   141 } | 
|   134  |   142  | 
| (...skipping 25 matching lines...) Expand all  Loading... | 
|   160     jobjectArray p5, |   168     jobjectArray p5, | 
|   161     JniIntWrapper p6, |   169     JniIntWrapper p6, | 
|   162     JniIntWrapper p7, |   170     JniIntWrapper p7, | 
|   163     jfloat p8, |   171     jfloat p8, | 
|   164     jfloat p9, |   172     jfloat p9, | 
|   165     JniIntWrapper p10, |   173     JniIntWrapper p10, | 
|   166     JniIntWrapper p11, |   174     JniIntWrapper p11, | 
|   167     JniIntWrapper p12, |   175     JniIntWrapper p12, | 
|   168     JniIntWrapper p13) { |   176     JniIntWrapper p13) { | 
|   169   /* Must call RegisterNativesImpl()  */ |   177   /* Must call RegisterNativesImpl()  */ | 
|   170   CHECK_CLAZZ(env, g_MotionEvent_clazz, |   178   CHECK_CLAZZ(env, MotionEvent_clazz(env), | 
|   171       g_MotionEvent_clazz, NULL); |   179       MotionEvent_clazz(env), NULL); | 
|   172   jmethodID method_id = |   180   jmethodID method_id = | 
|   173       base::android::MethodID::LazyGet< |   181       base::android::MethodID::LazyGet< | 
|   174       base::android::MethodID::TYPE_STATIC>( |   182       base::android::MethodID::TYPE_STATIC>( | 
|   175       env, g_MotionEvent_clazz, |   183       env, MotionEvent_clazz(env), | 
|   176       "obtain", |   184       "obtain", | 
|   177 "(JJII[Landroid/view/MotionEvent$PointerProperties;[Landroid/view/MotionEvent$Po
      interCoords;IIFFIIII)Landroid/view/MotionEvent;", |   185 "(JJII[Landroid/view/MotionEvent$PointerProperties;[Landroid/view/MotionEvent$Po
      interCoords;IIFFIIII)Landroid/view/MotionEvent;", | 
|   178       &g_MotionEvent_obtainAVME_J_J_I_I_LAVMEPP_LAVMEPC_I_I_F_F_I_I_I_I); |   186       &g_MotionEvent_obtainAVME_J_J_I_I_LAVMEPP_LAVMEPC_I_I_F_F_I_I_I_I); | 
|   179  |   187  | 
|   180   jobject ret = |   188   jobject ret = | 
|   181       env->CallStaticObjectMethod(g_MotionEvent_clazz, |   189       env->CallStaticObjectMethod(MotionEvent_clazz(env), | 
|   182           method_id, p0, p1, as_jint(p2), as_jint(p3), p4, p5, as_jint(p6), |   190           method_id, p0, p1, as_jint(p2), as_jint(p3), p4, p5, as_jint(p6), | 
|   183               as_jint(p7), p8, p9, as_jint(p10), as_jint(p11), as_jint(p12), |   191               as_jint(p7), p8, p9, as_jint(p10), as_jint(p11), as_jint(p12), | 
|   184               as_jint(p13)); |   192               as_jint(p13)); | 
|   185   jni_generator::CheckException(env); |   193   jni_generator::CheckException(env); | 
|   186   return base::android::ScopedJavaLocalRef<jobject>(env, ret); |   194   return base::android::ScopedJavaLocalRef<jobject>(env, ret); | 
|   187 } |   195 } | 
|   188  |   196  | 
|   189 static base::subtle::AtomicWord |   197 static base::subtle::AtomicWord | 
|   190     g_MotionEvent_obtainAVME_J_J_I_I_AI_LAVMEPC_I_F_F_I_I_I_I = 0; |   198     g_MotionEvent_obtainAVME_J_J_I_I_AI_LAVMEPC_I_F_F_I_I_I_I = 0; | 
|   191 static base::android::ScopedJavaLocalRef<jobject> |   199 static base::android::ScopedJavaLocalRef<jobject> | 
| (...skipping 20 matching lines...) Expand all  Loading... | 
|   212     jintArray p4, |   220     jintArray p4, | 
|   213     jobjectArray p5, |   221     jobjectArray p5, | 
|   214     JniIntWrapper p6, |   222     JniIntWrapper p6, | 
|   215     jfloat p7, |   223     jfloat p7, | 
|   216     jfloat p8, |   224     jfloat p8, | 
|   217     JniIntWrapper p9, |   225     JniIntWrapper p9, | 
|   218     JniIntWrapper p10, |   226     JniIntWrapper p10, | 
|   219     JniIntWrapper p11, |   227     JniIntWrapper p11, | 
|   220     JniIntWrapper p12) { |   228     JniIntWrapper p12) { | 
|   221   /* Must call RegisterNativesImpl()  */ |   229   /* Must call RegisterNativesImpl()  */ | 
|   222   CHECK_CLAZZ(env, g_MotionEvent_clazz, |   230   CHECK_CLAZZ(env, MotionEvent_clazz(env), | 
|   223       g_MotionEvent_clazz, NULL); |   231       MotionEvent_clazz(env), NULL); | 
|   224   jmethodID method_id = |   232   jmethodID method_id = | 
|   225       base::android::MethodID::LazyGet< |   233       base::android::MethodID::LazyGet< | 
|   226       base::android::MethodID::TYPE_STATIC>( |   234       base::android::MethodID::TYPE_STATIC>( | 
|   227       env, g_MotionEvent_clazz, |   235       env, MotionEvent_clazz(env), | 
|   228       "obtain", |   236       "obtain", | 
|   229 "(JJII[I[Landroid/view/MotionEvent$PointerCoords;IFFIIII)Landroid/view/MotionEve
      nt;", |   237 "(JJII[I[Landroid/view/MotionEvent$PointerCoords;IFFIIII)Landroid/view/MotionEve
      nt;", | 
|   230       &g_MotionEvent_obtainAVME_J_J_I_I_AI_LAVMEPC_I_F_F_I_I_I_I); |   238       &g_MotionEvent_obtainAVME_J_J_I_I_AI_LAVMEPC_I_F_F_I_I_I_I); | 
|   231  |   239  | 
|   232   jobject ret = |   240   jobject ret = | 
|   233       env->CallStaticObjectMethod(g_MotionEvent_clazz, |   241       env->CallStaticObjectMethod(MotionEvent_clazz(env), | 
|   234           method_id, p0, p1, as_jint(p2), as_jint(p3), p4, p5, as_jint(p6), p7, |   242           method_id, p0, p1, as_jint(p2), as_jint(p3), p4, p5, as_jint(p6), p7, | 
|   235               p8, as_jint(p9), as_jint(p10), as_jint(p11), as_jint(p12)); |   243               p8, as_jint(p9), as_jint(p10), as_jint(p11), as_jint(p12)); | 
|   236   jni_generator::CheckException(env); |   244   jni_generator::CheckException(env); | 
|   237   return base::android::ScopedJavaLocalRef<jobject>(env, ret); |   245   return base::android::ScopedJavaLocalRef<jobject>(env, ret); | 
|   238 } |   246 } | 
|   239  |   247  | 
|   240 static base::subtle::AtomicWord g_MotionEvent_obtainAVME_J_J_I_F_F_F_F_I_F_F_I_I |   248 static base::subtle::AtomicWord g_MotionEvent_obtainAVME_J_J_I_F_F_F_F_I_F_F_I_I | 
|   241     = 0; |   249     = 0; | 
|   242 static base::android::ScopedJavaLocalRef<jobject> |   250 static base::android::ScopedJavaLocalRef<jobject> | 
|   243     Java_MotionEvent_obtainAVME_J_J_I_F_F_F_F_I_F_F_I_I(JNIEnv* env, jlong p0, |   251     Java_MotionEvent_obtainAVME_J_J_I_F_F_F_F_I_F_F_I_I(JNIEnv* env, jlong p0, | 
| (...skipping 15 matching lines...) Expand all  Loading... | 
|   259     jfloat p3, |   267     jfloat p3, | 
|   260     jfloat p4, |   268     jfloat p4, | 
|   261     jfloat p5, |   269     jfloat p5, | 
|   262     jfloat p6, |   270     jfloat p6, | 
|   263     JniIntWrapper p7, |   271     JniIntWrapper p7, | 
|   264     jfloat p8, |   272     jfloat p8, | 
|   265     jfloat p9, |   273     jfloat p9, | 
|   266     JniIntWrapper p10, |   274     JniIntWrapper p10, | 
|   267     JniIntWrapper p11) { |   275     JniIntWrapper p11) { | 
|   268   /* Must call RegisterNativesImpl()  */ |   276   /* Must call RegisterNativesImpl()  */ | 
|   269   CHECK_CLAZZ(env, g_MotionEvent_clazz, |   277   CHECK_CLAZZ(env, MotionEvent_clazz(env), | 
|   270       g_MotionEvent_clazz, NULL); |   278       MotionEvent_clazz(env), NULL); | 
|   271   jmethodID method_id = |   279   jmethodID method_id = | 
|   272       base::android::MethodID::LazyGet< |   280       base::android::MethodID::LazyGet< | 
|   273       base::android::MethodID::TYPE_STATIC>( |   281       base::android::MethodID::TYPE_STATIC>( | 
|   274       env, g_MotionEvent_clazz, |   282       env, MotionEvent_clazz(env), | 
|   275       "obtain", |   283       "obtain", | 
|   276       "(JJIFFFFIFFII)Landroid/view/MotionEvent;", |   284       "(JJIFFFFIFFII)Landroid/view/MotionEvent;", | 
|   277       &g_MotionEvent_obtainAVME_J_J_I_F_F_F_F_I_F_F_I_I); |   285       &g_MotionEvent_obtainAVME_J_J_I_F_F_F_F_I_F_F_I_I); | 
|   278  |   286  | 
|   279   jobject ret = |   287   jobject ret = | 
|   280       env->CallStaticObjectMethod(g_MotionEvent_clazz, |   288       env->CallStaticObjectMethod(MotionEvent_clazz(env), | 
|   281           method_id, p0, p1, as_jint(p2), p3, p4, p5, p6, as_jint(p7), p8, p9, |   289           method_id, p0, p1, as_jint(p2), p3, p4, p5, p6, as_jint(p7), p8, p9, | 
|   282               as_jint(p10), as_jint(p11)); |   290               as_jint(p10), as_jint(p11)); | 
|   283   jni_generator::CheckException(env); |   291   jni_generator::CheckException(env); | 
|   284   return base::android::ScopedJavaLocalRef<jobject>(env, ret); |   292   return base::android::ScopedJavaLocalRef<jobject>(env, ret); | 
|   285 } |   293 } | 
|   286  |   294  | 
|   287 static base::subtle::AtomicWord |   295 static base::subtle::AtomicWord | 
|   288     g_MotionEvent_obtainAVME_J_J_I_I_F_F_F_F_I_F_F_I_I = 0; |   296     g_MotionEvent_obtainAVME_J_J_I_I_F_F_F_F_I_F_F_I_I = 0; | 
|   289 static base::android::ScopedJavaLocalRef<jobject> |   297 static base::android::ScopedJavaLocalRef<jobject> | 
|   290     Java_MotionEvent_obtainAVME_J_J_I_I_F_F_F_F_I_F_F_I_I(JNIEnv* env, jlong p0, |   298     Java_MotionEvent_obtainAVME_J_J_I_I_F_F_F_F_I_F_F_I_I(JNIEnv* env, jlong p0, | 
| (...skipping 17 matching lines...) Expand all  Loading... | 
|   308     jfloat p4, |   316     jfloat p4, | 
|   309     jfloat p5, |   317     jfloat p5, | 
|   310     jfloat p6, |   318     jfloat p6, | 
|   311     jfloat p7, |   319     jfloat p7, | 
|   312     JniIntWrapper p8, |   320     JniIntWrapper p8, | 
|   313     jfloat p9, |   321     jfloat p9, | 
|   314     jfloat p10, |   322     jfloat p10, | 
|   315     JniIntWrapper p11, |   323     JniIntWrapper p11, | 
|   316     JniIntWrapper p12) { |   324     JniIntWrapper p12) { | 
|   317   /* Must call RegisterNativesImpl()  */ |   325   /* Must call RegisterNativesImpl()  */ | 
|   318   CHECK_CLAZZ(env, g_MotionEvent_clazz, |   326   CHECK_CLAZZ(env, MotionEvent_clazz(env), | 
|   319       g_MotionEvent_clazz, NULL); |   327       MotionEvent_clazz(env), NULL); | 
|   320   jmethodID method_id = |   328   jmethodID method_id = | 
|   321       base::android::MethodID::LazyGet< |   329       base::android::MethodID::LazyGet< | 
|   322       base::android::MethodID::TYPE_STATIC>( |   330       base::android::MethodID::TYPE_STATIC>( | 
|   323       env, g_MotionEvent_clazz, |   331       env, MotionEvent_clazz(env), | 
|   324       "obtain", |   332       "obtain", | 
|   325       "(JJIIFFFFIFFII)Landroid/view/MotionEvent;", |   333       "(JJIIFFFFIFFII)Landroid/view/MotionEvent;", | 
|   326       &g_MotionEvent_obtainAVME_J_J_I_I_F_F_F_F_I_F_F_I_I); |   334       &g_MotionEvent_obtainAVME_J_J_I_I_F_F_F_F_I_F_F_I_I); | 
|   327  |   335  | 
|   328   jobject ret = |   336   jobject ret = | 
|   329       env->CallStaticObjectMethod(g_MotionEvent_clazz, |   337       env->CallStaticObjectMethod(MotionEvent_clazz(env), | 
|   330           method_id, p0, p1, as_jint(p2), as_jint(p3), p4, p5, p6, p7, |   338           method_id, p0, p1, as_jint(p2), as_jint(p3), p4, p5, p6, p7, | 
|   331               as_jint(p8), p9, p10, as_jint(p11), as_jint(p12)); |   339               as_jint(p8), p9, p10, as_jint(p11), as_jint(p12)); | 
|   332   jni_generator::CheckException(env); |   340   jni_generator::CheckException(env); | 
|   333   return base::android::ScopedJavaLocalRef<jobject>(env, ret); |   341   return base::android::ScopedJavaLocalRef<jobject>(env, ret); | 
|   334 } |   342 } | 
|   335  |   343  | 
|   336 static base::subtle::AtomicWord g_MotionEvent_obtainAVME_J_J_I_F_F_I = 0; |   344 static base::subtle::AtomicWord g_MotionEvent_obtainAVME_J_J_I_F_F_I = 0; | 
|   337 static base::android::ScopedJavaLocalRef<jobject> |   345 static base::android::ScopedJavaLocalRef<jobject> | 
|   338     Java_MotionEvent_obtainAVME_J_J_I_F_F_I(JNIEnv* env, jlong p0, |   346     Java_MotionEvent_obtainAVME_J_J_I_F_F_I(JNIEnv* env, jlong p0, | 
|   339     jlong p1, |   347     jlong p1, | 
|   340     JniIntWrapper p2, |   348     JniIntWrapper p2, | 
|   341     jfloat p3, |   349     jfloat p3, | 
|   342     jfloat p4, |   350     jfloat p4, | 
|   343     JniIntWrapper p5) __attribute__ ((unused)); |   351     JniIntWrapper p5) __attribute__ ((unused)); | 
|   344 static base::android::ScopedJavaLocalRef<jobject> |   352 static base::android::ScopedJavaLocalRef<jobject> | 
|   345     Java_MotionEvent_obtainAVME_J_J_I_F_F_I(JNIEnv* env, jlong p0, |   353     Java_MotionEvent_obtainAVME_J_J_I_F_F_I(JNIEnv* env, jlong p0, | 
|   346     jlong p1, |   354     jlong p1, | 
|   347     JniIntWrapper p2, |   355     JniIntWrapper p2, | 
|   348     jfloat p3, |   356     jfloat p3, | 
|   349     jfloat p4, |   357     jfloat p4, | 
|   350     JniIntWrapper p5) { |   358     JniIntWrapper p5) { | 
|   351   /* Must call RegisterNativesImpl()  */ |   359   /* Must call RegisterNativesImpl()  */ | 
|   352   CHECK_CLAZZ(env, g_MotionEvent_clazz, |   360   CHECK_CLAZZ(env, MotionEvent_clazz(env), | 
|   353       g_MotionEvent_clazz, NULL); |   361       MotionEvent_clazz(env), NULL); | 
|   354   jmethodID method_id = |   362   jmethodID method_id = | 
|   355       base::android::MethodID::LazyGet< |   363       base::android::MethodID::LazyGet< | 
|   356       base::android::MethodID::TYPE_STATIC>( |   364       base::android::MethodID::TYPE_STATIC>( | 
|   357       env, g_MotionEvent_clazz, |   365       env, MotionEvent_clazz(env), | 
|   358       "obtain", |   366       "obtain", | 
|   359       "(JJIFFI)Landroid/view/MotionEvent;", |   367       "(JJIFFI)Landroid/view/MotionEvent;", | 
|   360       &g_MotionEvent_obtainAVME_J_J_I_F_F_I); |   368       &g_MotionEvent_obtainAVME_J_J_I_F_F_I); | 
|   361  |   369  | 
|   362   jobject ret = |   370   jobject ret = | 
|   363       env->CallStaticObjectMethod(g_MotionEvent_clazz, |   371       env->CallStaticObjectMethod(MotionEvent_clazz(env), | 
|   364           method_id, p0, p1, as_jint(p2), p3, p4, as_jint(p5)); |   372           method_id, p0, p1, as_jint(p2), p3, p4, as_jint(p5)); | 
|   365   jni_generator::CheckException(env); |   373   jni_generator::CheckException(env); | 
|   366   return base::android::ScopedJavaLocalRef<jobject>(env, ret); |   374   return base::android::ScopedJavaLocalRef<jobject>(env, ret); | 
|   367 } |   375 } | 
|   368  |   376  | 
|   369 static base::subtle::AtomicWord g_MotionEvent_obtainAVME_AVME = 0; |   377 static base::subtle::AtomicWord g_MotionEvent_obtainAVME_AVME = 0; | 
|   370 static base::android::ScopedJavaLocalRef<jobject> |   378 static base::android::ScopedJavaLocalRef<jobject> | 
|   371     Java_MotionEvent_obtainAVME_AVME(JNIEnv* env, jobject p0) __attribute__ |   379     Java_MotionEvent_obtainAVME_AVME(JNIEnv* env, jobject p0) __attribute__ | 
|   372     ((unused)); |   380     ((unused)); | 
|   373 static base::android::ScopedJavaLocalRef<jobject> |   381 static base::android::ScopedJavaLocalRef<jobject> | 
|   374     Java_MotionEvent_obtainAVME_AVME(JNIEnv* env, jobject p0) { |   382     Java_MotionEvent_obtainAVME_AVME(JNIEnv* env, jobject p0) { | 
|   375   /* Must call RegisterNativesImpl()  */ |   383   /* Must call RegisterNativesImpl()  */ | 
|   376   CHECK_CLAZZ(env, g_MotionEvent_clazz, |   384   CHECK_CLAZZ(env, MotionEvent_clazz(env), | 
|   377       g_MotionEvent_clazz, NULL); |   385       MotionEvent_clazz(env), NULL); | 
|   378   jmethodID method_id = |   386   jmethodID method_id = | 
|   379       base::android::MethodID::LazyGet< |   387       base::android::MethodID::LazyGet< | 
|   380       base::android::MethodID::TYPE_STATIC>( |   388       base::android::MethodID::TYPE_STATIC>( | 
|   381       env, g_MotionEvent_clazz, |   389       env, MotionEvent_clazz(env), | 
|   382       "obtain", |   390       "obtain", | 
|   383       "(Landroid/view/MotionEvent;)Landroid/view/MotionEvent;", |   391       "(Landroid/view/MotionEvent;)Landroid/view/MotionEvent;", | 
|   384       &g_MotionEvent_obtainAVME_AVME); |   392       &g_MotionEvent_obtainAVME_AVME); | 
|   385  |   393  | 
|   386   jobject ret = |   394   jobject ret = | 
|   387       env->CallStaticObjectMethod(g_MotionEvent_clazz, |   395       env->CallStaticObjectMethod(MotionEvent_clazz(env), | 
|   388           method_id, p0); |   396           method_id, p0); | 
|   389   jni_generator::CheckException(env); |   397   jni_generator::CheckException(env); | 
|   390   return base::android::ScopedJavaLocalRef<jobject>(env, ret); |   398   return base::android::ScopedJavaLocalRef<jobject>(env, ret); | 
|   391 } |   399 } | 
|   392  |   400  | 
|   393 static base::subtle::AtomicWord g_MotionEvent_obtainNoHistory = 0; |   401 static base::subtle::AtomicWord g_MotionEvent_obtainNoHistory = 0; | 
|   394 static base::android::ScopedJavaLocalRef<jobject> |   402 static base::android::ScopedJavaLocalRef<jobject> | 
|   395     Java_MotionEvent_obtainNoHistory(JNIEnv* env, jobject p0) __attribute__ |   403     Java_MotionEvent_obtainNoHistory(JNIEnv* env, jobject p0) __attribute__ | 
|   396     ((unused)); |   404     ((unused)); | 
|   397 static base::android::ScopedJavaLocalRef<jobject> |   405 static base::android::ScopedJavaLocalRef<jobject> | 
|   398     Java_MotionEvent_obtainNoHistory(JNIEnv* env, jobject p0) { |   406     Java_MotionEvent_obtainNoHistory(JNIEnv* env, jobject p0) { | 
|   399   /* Must call RegisterNativesImpl()  */ |   407   /* Must call RegisterNativesImpl()  */ | 
|   400   CHECK_CLAZZ(env, g_MotionEvent_clazz, |   408   CHECK_CLAZZ(env, MotionEvent_clazz(env), | 
|   401       g_MotionEvent_clazz, NULL); |   409       MotionEvent_clazz(env), NULL); | 
|   402   jmethodID method_id = |   410   jmethodID method_id = | 
|   403       base::android::MethodID::LazyGet< |   411       base::android::MethodID::LazyGet< | 
|   404       base::android::MethodID::TYPE_STATIC>( |   412       base::android::MethodID::TYPE_STATIC>( | 
|   405       env, g_MotionEvent_clazz, |   413       env, MotionEvent_clazz(env), | 
|   406       "obtainNoHistory", |   414       "obtainNoHistory", | 
|   407       "(Landroid/view/MotionEvent;)Landroid/view/MotionEvent;", |   415       "(Landroid/view/MotionEvent;)Landroid/view/MotionEvent;", | 
|   408       &g_MotionEvent_obtainNoHistory); |   416       &g_MotionEvent_obtainNoHistory); | 
|   409  |   417  | 
|   410   jobject ret = |   418   jobject ret = | 
|   411       env->CallStaticObjectMethod(g_MotionEvent_clazz, |   419       env->CallStaticObjectMethod(MotionEvent_clazz(env), | 
|   412           method_id, p0); |   420           method_id, p0); | 
|   413   jni_generator::CheckException(env); |   421   jni_generator::CheckException(env); | 
|   414   return base::android::ScopedJavaLocalRef<jobject>(env, ret); |   422   return base::android::ScopedJavaLocalRef<jobject>(env, ret); | 
|   415 } |   423 } | 
|   416  |   424  | 
|   417 static base::subtle::AtomicWord g_MotionEvent_recycle = 0; |   425 static base::subtle::AtomicWord g_MotionEvent_recycle = 0; | 
|   418 static void Java_MotionEvent_recycle(JNIEnv* env, jobject obj) __attribute__ |   426 static void Java_MotionEvent_recycle(JNIEnv* env, jobject obj) __attribute__ | 
|   419     ((unused)); |   427     ((unused)); | 
|   420 static void Java_MotionEvent_recycle(JNIEnv* env, jobject obj) { |   428 static void Java_MotionEvent_recycle(JNIEnv* env, jobject obj) { | 
|   421   /* Must call RegisterNativesImpl()  */ |   429   /* Must call RegisterNativesImpl()  */ | 
|   422   CHECK_CLAZZ(env, obj, |   430   CHECK_CLAZZ(env, obj, | 
|   423       g_MotionEvent_clazz); |   431       MotionEvent_clazz(env)); | 
|   424   jmethodID method_id = |   432   jmethodID method_id = | 
|   425       base::android::MethodID::LazyGet< |   433       base::android::MethodID::LazyGet< | 
|   426       base::android::MethodID::TYPE_INSTANCE>( |   434       base::android::MethodID::TYPE_INSTANCE>( | 
|   427       env, g_MotionEvent_clazz, |   435       env, MotionEvent_clazz(env), | 
|   428       "recycle", |   436       "recycle", | 
|   429       "()V", |   437       "()V", | 
|   430       &g_MotionEvent_recycle); |   438       &g_MotionEvent_recycle); | 
|   431  |   439  | 
|   432      env->CallVoidMethod(obj, |   440      env->CallVoidMethod(obj, | 
|   433           method_id); |   441           method_id); | 
|   434   jni_generator::CheckException(env); |   442   jni_generator::CheckException(env); | 
|   435  |   443  | 
|   436 } |   444 } | 
|   437  |   445  | 
|   438 static base::subtle::AtomicWord g_MotionEvent_getDeviceId = 0; |   446 static base::subtle::AtomicWord g_MotionEvent_getDeviceId = 0; | 
|   439 static jint Java_MotionEvent_getDeviceId(JNIEnv* env, jobject obj) __attribute__ |   447 static jint Java_MotionEvent_getDeviceId(JNIEnv* env, jobject obj) __attribute__ | 
|   440     ((unused)); |   448     ((unused)); | 
|   441 static jint Java_MotionEvent_getDeviceId(JNIEnv* env, jobject obj) { |   449 static jint Java_MotionEvent_getDeviceId(JNIEnv* env, jobject obj) { | 
|   442   /* Must call RegisterNativesImpl()  */ |   450   /* Must call RegisterNativesImpl()  */ | 
|   443   CHECK_CLAZZ(env, obj, |   451   CHECK_CLAZZ(env, obj, | 
|   444       g_MotionEvent_clazz, 0); |   452       MotionEvent_clazz(env), 0); | 
|   445   jmethodID method_id = |   453   jmethodID method_id = | 
|   446       base::android::MethodID::LazyGet< |   454       base::android::MethodID::LazyGet< | 
|   447       base::android::MethodID::TYPE_INSTANCE>( |   455       base::android::MethodID::TYPE_INSTANCE>( | 
|   448       env, g_MotionEvent_clazz, |   456       env, MotionEvent_clazz(env), | 
|   449       "getDeviceId", |   457       "getDeviceId", | 
|   450       "()I", |   458       "()I", | 
|   451       &g_MotionEvent_getDeviceId); |   459       &g_MotionEvent_getDeviceId); | 
|   452  |   460  | 
|   453   jint ret = |   461   jint ret = | 
|   454       env->CallIntMethod(obj, |   462       env->CallIntMethod(obj, | 
|   455           method_id); |   463           method_id); | 
|   456   jni_generator::CheckException(env); |   464   jni_generator::CheckException(env); | 
|   457   return ret; |   465   return ret; | 
|   458 } |   466 } | 
|   459  |   467  | 
|   460 static base::subtle::AtomicWord g_MotionEvent_getSource = 0; |   468 static base::subtle::AtomicWord g_MotionEvent_getSource = 0; | 
|   461 static jint Java_MotionEvent_getSource(JNIEnv* env, jobject obj) __attribute__ |   469 static jint Java_MotionEvent_getSource(JNIEnv* env, jobject obj) __attribute__ | 
|   462     ((unused)); |   470     ((unused)); | 
|   463 static jint Java_MotionEvent_getSource(JNIEnv* env, jobject obj) { |   471 static jint Java_MotionEvent_getSource(JNIEnv* env, jobject obj) { | 
|   464   /* Must call RegisterNativesImpl()  */ |   472   /* Must call RegisterNativesImpl()  */ | 
|   465   CHECK_CLAZZ(env, obj, |   473   CHECK_CLAZZ(env, obj, | 
|   466       g_MotionEvent_clazz, 0); |   474       MotionEvent_clazz(env), 0); | 
|   467   jmethodID method_id = |   475   jmethodID method_id = | 
|   468       base::android::MethodID::LazyGet< |   476       base::android::MethodID::LazyGet< | 
|   469       base::android::MethodID::TYPE_INSTANCE>( |   477       base::android::MethodID::TYPE_INSTANCE>( | 
|   470       env, g_MotionEvent_clazz, |   478       env, MotionEvent_clazz(env), | 
|   471       "getSource", |   479       "getSource", | 
|   472       "()I", |   480       "()I", | 
|   473       &g_MotionEvent_getSource); |   481       &g_MotionEvent_getSource); | 
|   474  |   482  | 
|   475   jint ret = |   483   jint ret = | 
|   476       env->CallIntMethod(obj, |   484       env->CallIntMethod(obj, | 
|   477           method_id); |   485           method_id); | 
|   478   jni_generator::CheckException(env); |   486   jni_generator::CheckException(env); | 
|   479   return ret; |   487   return ret; | 
|   480 } |   488 } | 
|   481  |   489  | 
|   482 static base::subtle::AtomicWord g_MotionEvent_setSource = 0; |   490 static base::subtle::AtomicWord g_MotionEvent_setSource = 0; | 
|   483 static void Java_MotionEvent_setSource(JNIEnv* env, jobject obj, JniIntWrapper |   491 static void Java_MotionEvent_setSource(JNIEnv* env, jobject obj, JniIntWrapper | 
|   484     p0) __attribute__ ((unused)); |   492     p0) __attribute__ ((unused)); | 
|   485 static void Java_MotionEvent_setSource(JNIEnv* env, jobject obj, JniIntWrapper |   493 static void Java_MotionEvent_setSource(JNIEnv* env, jobject obj, JniIntWrapper | 
|   486     p0) { |   494     p0) { | 
|   487   /* Must call RegisterNativesImpl()  */ |   495   /* Must call RegisterNativesImpl()  */ | 
|   488   CHECK_CLAZZ(env, obj, |   496   CHECK_CLAZZ(env, obj, | 
|   489       g_MotionEvent_clazz); |   497       MotionEvent_clazz(env)); | 
|   490   jmethodID method_id = |   498   jmethodID method_id = | 
|   491       base::android::MethodID::LazyGet< |   499       base::android::MethodID::LazyGet< | 
|   492       base::android::MethodID::TYPE_INSTANCE>( |   500       base::android::MethodID::TYPE_INSTANCE>( | 
|   493       env, g_MotionEvent_clazz, |   501       env, MotionEvent_clazz(env), | 
|   494       "setSource", |   502       "setSource", | 
|   495       "(I)V", |   503       "(I)V", | 
|   496       &g_MotionEvent_setSource); |   504       &g_MotionEvent_setSource); | 
|   497  |   505  | 
|   498      env->CallVoidMethod(obj, |   506      env->CallVoidMethod(obj, | 
|   499           method_id, as_jint(p0)); |   507           method_id, as_jint(p0)); | 
|   500   jni_generator::CheckException(env); |   508   jni_generator::CheckException(env); | 
|   501  |   509  | 
|   502 } |   510 } | 
|   503  |   511  | 
|   504 static base::subtle::AtomicWord g_MotionEvent_getAction = 0; |   512 static base::subtle::AtomicWord g_MotionEvent_getAction = 0; | 
|   505 static jint Java_MotionEvent_getAction(JNIEnv* env, jobject obj) __attribute__ |   513 static jint Java_MotionEvent_getAction(JNIEnv* env, jobject obj) __attribute__ | 
|   506     ((unused)); |   514     ((unused)); | 
|   507 static jint Java_MotionEvent_getAction(JNIEnv* env, jobject obj) { |   515 static jint Java_MotionEvent_getAction(JNIEnv* env, jobject obj) { | 
|   508   /* Must call RegisterNativesImpl()  */ |   516   /* Must call RegisterNativesImpl()  */ | 
|   509   CHECK_CLAZZ(env, obj, |   517   CHECK_CLAZZ(env, obj, | 
|   510       g_MotionEvent_clazz, 0); |   518       MotionEvent_clazz(env), 0); | 
|   511   jmethodID method_id = |   519   jmethodID method_id = | 
|   512       base::android::MethodID::LazyGet< |   520       base::android::MethodID::LazyGet< | 
|   513       base::android::MethodID::TYPE_INSTANCE>( |   521       base::android::MethodID::TYPE_INSTANCE>( | 
|   514       env, g_MotionEvent_clazz, |   522       env, MotionEvent_clazz(env), | 
|   515       "getAction", |   523       "getAction", | 
|   516       "()I", |   524       "()I", | 
|   517       &g_MotionEvent_getAction); |   525       &g_MotionEvent_getAction); | 
|   518  |   526  | 
|   519   jint ret = |   527   jint ret = | 
|   520       env->CallIntMethod(obj, |   528       env->CallIntMethod(obj, | 
|   521           method_id); |   529           method_id); | 
|   522   jni_generator::CheckException(env); |   530   jni_generator::CheckException(env); | 
|   523   return ret; |   531   return ret; | 
|   524 } |   532 } | 
|   525  |   533  | 
|   526 static base::subtle::AtomicWord g_MotionEvent_getActionMasked = 0; |   534 static base::subtle::AtomicWord g_MotionEvent_getActionMasked = 0; | 
|   527 static jint Java_MotionEvent_getActionMasked(JNIEnv* env, jobject obj) |   535 static jint Java_MotionEvent_getActionMasked(JNIEnv* env, jobject obj) | 
|   528     __attribute__ ((unused)); |   536     __attribute__ ((unused)); | 
|   529 static jint Java_MotionEvent_getActionMasked(JNIEnv* env, jobject obj) { |   537 static jint Java_MotionEvent_getActionMasked(JNIEnv* env, jobject obj) { | 
|   530   /* Must call RegisterNativesImpl()  */ |   538   /* Must call RegisterNativesImpl()  */ | 
|   531   CHECK_CLAZZ(env, obj, |   539   CHECK_CLAZZ(env, obj, | 
|   532       g_MotionEvent_clazz, 0); |   540       MotionEvent_clazz(env), 0); | 
|   533   jmethodID method_id = |   541   jmethodID method_id = | 
|   534       base::android::MethodID::LazyGet< |   542       base::android::MethodID::LazyGet< | 
|   535       base::android::MethodID::TYPE_INSTANCE>( |   543       base::android::MethodID::TYPE_INSTANCE>( | 
|   536       env, g_MotionEvent_clazz, |   544       env, MotionEvent_clazz(env), | 
|   537       "getActionMasked", |   545       "getActionMasked", | 
|   538       "()I", |   546       "()I", | 
|   539       &g_MotionEvent_getActionMasked); |   547       &g_MotionEvent_getActionMasked); | 
|   540  |   548  | 
|   541   jint ret = |   549   jint ret = | 
|   542       env->CallIntMethod(obj, |   550       env->CallIntMethod(obj, | 
|   543           method_id); |   551           method_id); | 
|   544   jni_generator::CheckException(env); |   552   jni_generator::CheckException(env); | 
|   545   return ret; |   553   return ret; | 
|   546 } |   554 } | 
|   547  |   555  | 
|   548 static base::subtle::AtomicWord g_MotionEvent_getActionIndex = 0; |   556 static base::subtle::AtomicWord g_MotionEvent_getActionIndex = 0; | 
|   549 static jint Java_MotionEvent_getActionIndex(JNIEnv* env, jobject obj) |   557 static jint Java_MotionEvent_getActionIndex(JNIEnv* env, jobject obj) | 
|   550     __attribute__ ((unused)); |   558     __attribute__ ((unused)); | 
|   551 static jint Java_MotionEvent_getActionIndex(JNIEnv* env, jobject obj) { |   559 static jint Java_MotionEvent_getActionIndex(JNIEnv* env, jobject obj) { | 
|   552   /* Must call RegisterNativesImpl()  */ |   560   /* Must call RegisterNativesImpl()  */ | 
|   553   CHECK_CLAZZ(env, obj, |   561   CHECK_CLAZZ(env, obj, | 
|   554       g_MotionEvent_clazz, 0); |   562       MotionEvent_clazz(env), 0); | 
|   555   jmethodID method_id = |   563   jmethodID method_id = | 
|   556       base::android::MethodID::LazyGet< |   564       base::android::MethodID::LazyGet< | 
|   557       base::android::MethodID::TYPE_INSTANCE>( |   565       base::android::MethodID::TYPE_INSTANCE>( | 
|   558       env, g_MotionEvent_clazz, |   566       env, MotionEvent_clazz(env), | 
|   559       "getActionIndex", |   567       "getActionIndex", | 
|   560       "()I", |   568       "()I", | 
|   561       &g_MotionEvent_getActionIndex); |   569       &g_MotionEvent_getActionIndex); | 
|   562  |   570  | 
|   563   jint ret = |   571   jint ret = | 
|   564       env->CallIntMethod(obj, |   572       env->CallIntMethod(obj, | 
|   565           method_id); |   573           method_id); | 
|   566   jni_generator::CheckException(env); |   574   jni_generator::CheckException(env); | 
|   567   return ret; |   575   return ret; | 
|   568 } |   576 } | 
|   569  |   577  | 
|   570 static base::subtle::AtomicWord g_MotionEvent_getFlags = 0; |   578 static base::subtle::AtomicWord g_MotionEvent_getFlags = 0; | 
|   571 static jint Java_MotionEvent_getFlags(JNIEnv* env, jobject obj) __attribute__ |   579 static jint Java_MotionEvent_getFlags(JNIEnv* env, jobject obj) __attribute__ | 
|   572     ((unused)); |   580     ((unused)); | 
|   573 static jint Java_MotionEvent_getFlags(JNIEnv* env, jobject obj) { |   581 static jint Java_MotionEvent_getFlags(JNIEnv* env, jobject obj) { | 
|   574   /* Must call RegisterNativesImpl()  */ |   582   /* Must call RegisterNativesImpl()  */ | 
|   575   CHECK_CLAZZ(env, obj, |   583   CHECK_CLAZZ(env, obj, | 
|   576       g_MotionEvent_clazz, 0); |   584       MotionEvent_clazz(env), 0); | 
|   577   jmethodID method_id = |   585   jmethodID method_id = | 
|   578       base::android::MethodID::LazyGet< |   586       base::android::MethodID::LazyGet< | 
|   579       base::android::MethodID::TYPE_INSTANCE>( |   587       base::android::MethodID::TYPE_INSTANCE>( | 
|   580       env, g_MotionEvent_clazz, |   588       env, MotionEvent_clazz(env), | 
|   581       "getFlags", |   589       "getFlags", | 
|   582       "()I", |   590       "()I", | 
|   583       &g_MotionEvent_getFlags); |   591       &g_MotionEvent_getFlags); | 
|   584  |   592  | 
|   585   jint ret = |   593   jint ret = | 
|   586       env->CallIntMethod(obj, |   594       env->CallIntMethod(obj, | 
|   587           method_id); |   595           method_id); | 
|   588   jni_generator::CheckException(env); |   596   jni_generator::CheckException(env); | 
|   589   return ret; |   597   return ret; | 
|   590 } |   598 } | 
|   591  |   599  | 
|   592 static base::subtle::AtomicWord g_MotionEvent_getDownTime = 0; |   600 static base::subtle::AtomicWord g_MotionEvent_getDownTime = 0; | 
|   593 static jlong Java_MotionEvent_getDownTime(JNIEnv* env, jobject obj) |   601 static jlong Java_MotionEvent_getDownTime(JNIEnv* env, jobject obj) | 
|   594     __attribute__ ((unused)); |   602     __attribute__ ((unused)); | 
|   595 static jlong Java_MotionEvent_getDownTime(JNIEnv* env, jobject obj) { |   603 static jlong Java_MotionEvent_getDownTime(JNIEnv* env, jobject obj) { | 
|   596   /* Must call RegisterNativesImpl()  */ |   604   /* Must call RegisterNativesImpl()  */ | 
|   597   CHECK_CLAZZ(env, obj, |   605   CHECK_CLAZZ(env, obj, | 
|   598       g_MotionEvent_clazz, 0); |   606       MotionEvent_clazz(env), 0); | 
|   599   jmethodID method_id = |   607   jmethodID method_id = | 
|   600       base::android::MethodID::LazyGet< |   608       base::android::MethodID::LazyGet< | 
|   601       base::android::MethodID::TYPE_INSTANCE>( |   609       base::android::MethodID::TYPE_INSTANCE>( | 
|   602       env, g_MotionEvent_clazz, |   610       env, MotionEvent_clazz(env), | 
|   603       "getDownTime", |   611       "getDownTime", | 
|   604       "()J", |   612       "()J", | 
|   605       &g_MotionEvent_getDownTime); |   613       &g_MotionEvent_getDownTime); | 
|   606  |   614  | 
|   607   jlong ret = |   615   jlong ret = | 
|   608       env->CallLongMethod(obj, |   616       env->CallLongMethod(obj, | 
|   609           method_id); |   617           method_id); | 
|   610   jni_generator::CheckException(env); |   618   jni_generator::CheckException(env); | 
|   611   return ret; |   619   return ret; | 
|   612 } |   620 } | 
|   613  |   621  | 
|   614 static base::subtle::AtomicWord g_MotionEvent_getEventTime = 0; |   622 static base::subtle::AtomicWord g_MotionEvent_getEventTime = 0; | 
|   615 static jlong Java_MotionEvent_getEventTime(JNIEnv* env, jobject obj) |   623 static jlong Java_MotionEvent_getEventTime(JNIEnv* env, jobject obj) | 
|   616     __attribute__ ((unused)); |   624     __attribute__ ((unused)); | 
|   617 static jlong Java_MotionEvent_getEventTime(JNIEnv* env, jobject obj) { |   625 static jlong Java_MotionEvent_getEventTime(JNIEnv* env, jobject obj) { | 
|   618   /* Must call RegisterNativesImpl()  */ |   626   /* Must call RegisterNativesImpl()  */ | 
|   619   CHECK_CLAZZ(env, obj, |   627   CHECK_CLAZZ(env, obj, | 
|   620       g_MotionEvent_clazz, 0); |   628       MotionEvent_clazz(env), 0); | 
|   621   jmethodID method_id = |   629   jmethodID method_id = | 
|   622       base::android::MethodID::LazyGet< |   630       base::android::MethodID::LazyGet< | 
|   623       base::android::MethodID::TYPE_INSTANCE>( |   631       base::android::MethodID::TYPE_INSTANCE>( | 
|   624       env, g_MotionEvent_clazz, |   632       env, MotionEvent_clazz(env), | 
|   625       "getEventTime", |   633       "getEventTime", | 
|   626       "()J", |   634       "()J", | 
|   627       &g_MotionEvent_getEventTime); |   635       &g_MotionEvent_getEventTime); | 
|   628  |   636  | 
|   629   jlong ret = |   637   jlong ret = | 
|   630       env->CallLongMethod(obj, |   638       env->CallLongMethod(obj, | 
|   631           method_id); |   639           method_id); | 
|   632   jni_generator::CheckException(env); |   640   jni_generator::CheckException(env); | 
|   633   return ret; |   641   return ret; | 
|   634 } |   642 } | 
|   635  |   643  | 
|   636 static base::subtle::AtomicWord g_MotionEvent_getXF = 0; |   644 static base::subtle::AtomicWord g_MotionEvent_getXF = 0; | 
|   637 static jfloat Java_MotionEvent_getXF(JNIEnv* env, jobject obj) __attribute__ |   645 static jfloat Java_MotionEvent_getXF(JNIEnv* env, jobject obj) __attribute__ | 
|   638     ((unused)); |   646     ((unused)); | 
|   639 static jfloat Java_MotionEvent_getXF(JNIEnv* env, jobject obj) { |   647 static jfloat Java_MotionEvent_getXF(JNIEnv* env, jobject obj) { | 
|   640   /* Must call RegisterNativesImpl()  */ |   648   /* Must call RegisterNativesImpl()  */ | 
|   641   CHECK_CLAZZ(env, obj, |   649   CHECK_CLAZZ(env, obj, | 
|   642       g_MotionEvent_clazz, 0); |   650       MotionEvent_clazz(env), 0); | 
|   643   jmethodID method_id = |   651   jmethodID method_id = | 
|   644       base::android::MethodID::LazyGet< |   652       base::android::MethodID::LazyGet< | 
|   645       base::android::MethodID::TYPE_INSTANCE>( |   653       base::android::MethodID::TYPE_INSTANCE>( | 
|   646       env, g_MotionEvent_clazz, |   654       env, MotionEvent_clazz(env), | 
|   647       "getX", |   655       "getX", | 
|   648       "()F", |   656       "()F", | 
|   649       &g_MotionEvent_getXF); |   657       &g_MotionEvent_getXF); | 
|   650  |   658  | 
|   651   jfloat ret = |   659   jfloat ret = | 
|   652       env->CallFloatMethod(obj, |   660       env->CallFloatMethod(obj, | 
|   653           method_id); |   661           method_id); | 
|   654   jni_generator::CheckException(env); |   662   jni_generator::CheckException(env); | 
|   655   return ret; |   663   return ret; | 
|   656 } |   664 } | 
|   657  |   665  | 
|   658 static base::subtle::AtomicWord g_MotionEvent_getYF = 0; |   666 static base::subtle::AtomicWord g_MotionEvent_getYF = 0; | 
|   659 static jfloat Java_MotionEvent_getYF(JNIEnv* env, jobject obj) __attribute__ |   667 static jfloat Java_MotionEvent_getYF(JNIEnv* env, jobject obj) __attribute__ | 
|   660     ((unused)); |   668     ((unused)); | 
|   661 static jfloat Java_MotionEvent_getYF(JNIEnv* env, jobject obj) { |   669 static jfloat Java_MotionEvent_getYF(JNIEnv* env, jobject obj) { | 
|   662   /* Must call RegisterNativesImpl()  */ |   670   /* Must call RegisterNativesImpl()  */ | 
|   663   CHECK_CLAZZ(env, obj, |   671   CHECK_CLAZZ(env, obj, | 
|   664       g_MotionEvent_clazz, 0); |   672       MotionEvent_clazz(env), 0); | 
|   665   jmethodID method_id = |   673   jmethodID method_id = | 
|   666       base::android::MethodID::LazyGet< |   674       base::android::MethodID::LazyGet< | 
|   667       base::android::MethodID::TYPE_INSTANCE>( |   675       base::android::MethodID::TYPE_INSTANCE>( | 
|   668       env, g_MotionEvent_clazz, |   676       env, MotionEvent_clazz(env), | 
|   669       "getY", |   677       "getY", | 
|   670       "()F", |   678       "()F", | 
|   671       &g_MotionEvent_getYF); |   679       &g_MotionEvent_getYF); | 
|   672  |   680  | 
|   673   jfloat ret = |   681   jfloat ret = | 
|   674       env->CallFloatMethod(obj, |   682       env->CallFloatMethod(obj, | 
|   675           method_id); |   683           method_id); | 
|   676   jni_generator::CheckException(env); |   684   jni_generator::CheckException(env); | 
|   677   return ret; |   685   return ret; | 
|   678 } |   686 } | 
|   679  |   687  | 
|   680 static base::subtle::AtomicWord g_MotionEvent_getPressureF = 0; |   688 static base::subtle::AtomicWord g_MotionEvent_getPressureF = 0; | 
|   681 static jfloat Java_MotionEvent_getPressureF(JNIEnv* env, jobject obj) |   689 static jfloat Java_MotionEvent_getPressureF(JNIEnv* env, jobject obj) | 
|   682     __attribute__ ((unused)); |   690     __attribute__ ((unused)); | 
|   683 static jfloat Java_MotionEvent_getPressureF(JNIEnv* env, jobject obj) { |   691 static jfloat Java_MotionEvent_getPressureF(JNIEnv* env, jobject obj) { | 
|   684   /* Must call RegisterNativesImpl()  */ |   692   /* Must call RegisterNativesImpl()  */ | 
|   685   CHECK_CLAZZ(env, obj, |   693   CHECK_CLAZZ(env, obj, | 
|   686       g_MotionEvent_clazz, 0); |   694       MotionEvent_clazz(env), 0); | 
|   687   jmethodID method_id = |   695   jmethodID method_id = | 
|   688       base::android::MethodID::LazyGet< |   696       base::android::MethodID::LazyGet< | 
|   689       base::android::MethodID::TYPE_INSTANCE>( |   697       base::android::MethodID::TYPE_INSTANCE>( | 
|   690       env, g_MotionEvent_clazz, |   698       env, MotionEvent_clazz(env), | 
|   691       "getPressure", |   699       "getPressure", | 
|   692       "()F", |   700       "()F", | 
|   693       &g_MotionEvent_getPressureF); |   701       &g_MotionEvent_getPressureF); | 
|   694  |   702  | 
|   695   jfloat ret = |   703   jfloat ret = | 
|   696       env->CallFloatMethod(obj, |   704       env->CallFloatMethod(obj, | 
|   697           method_id); |   705           method_id); | 
|   698   jni_generator::CheckException(env); |   706   jni_generator::CheckException(env); | 
|   699   return ret; |   707   return ret; | 
|   700 } |   708 } | 
|   701  |   709  | 
|   702 static base::subtle::AtomicWord g_MotionEvent_getSizeF = 0; |   710 static base::subtle::AtomicWord g_MotionEvent_getSizeF = 0; | 
|   703 static jfloat Java_MotionEvent_getSizeF(JNIEnv* env, jobject obj) __attribute__ |   711 static jfloat Java_MotionEvent_getSizeF(JNIEnv* env, jobject obj) __attribute__ | 
|   704     ((unused)); |   712     ((unused)); | 
|   705 static jfloat Java_MotionEvent_getSizeF(JNIEnv* env, jobject obj) { |   713 static jfloat Java_MotionEvent_getSizeF(JNIEnv* env, jobject obj) { | 
|   706   /* Must call RegisterNativesImpl()  */ |   714   /* Must call RegisterNativesImpl()  */ | 
|   707   CHECK_CLAZZ(env, obj, |   715   CHECK_CLAZZ(env, obj, | 
|   708       g_MotionEvent_clazz, 0); |   716       MotionEvent_clazz(env), 0); | 
|   709   jmethodID method_id = |   717   jmethodID method_id = | 
|   710       base::android::MethodID::LazyGet< |   718       base::android::MethodID::LazyGet< | 
|   711       base::android::MethodID::TYPE_INSTANCE>( |   719       base::android::MethodID::TYPE_INSTANCE>( | 
|   712       env, g_MotionEvent_clazz, |   720       env, MotionEvent_clazz(env), | 
|   713       "getSize", |   721       "getSize", | 
|   714       "()F", |   722       "()F", | 
|   715       &g_MotionEvent_getSizeF); |   723       &g_MotionEvent_getSizeF); | 
|   716  |   724  | 
|   717   jfloat ret = |   725   jfloat ret = | 
|   718       env->CallFloatMethod(obj, |   726       env->CallFloatMethod(obj, | 
|   719           method_id); |   727           method_id); | 
|   720   jni_generator::CheckException(env); |   728   jni_generator::CheckException(env); | 
|   721   return ret; |   729   return ret; | 
|   722 } |   730 } | 
|   723  |   731  | 
|   724 static base::subtle::AtomicWord g_MotionEvent_getTouchMajorF = 0; |   732 static base::subtle::AtomicWord g_MotionEvent_getTouchMajorF = 0; | 
|   725 static jfloat Java_MotionEvent_getTouchMajorF(JNIEnv* env, jobject obj) |   733 static jfloat Java_MotionEvent_getTouchMajorF(JNIEnv* env, jobject obj) | 
|   726     __attribute__ ((unused)); |   734     __attribute__ ((unused)); | 
|   727 static jfloat Java_MotionEvent_getTouchMajorF(JNIEnv* env, jobject obj) { |   735 static jfloat Java_MotionEvent_getTouchMajorF(JNIEnv* env, jobject obj) { | 
|   728   /* Must call RegisterNativesImpl()  */ |   736   /* Must call RegisterNativesImpl()  */ | 
|   729   CHECK_CLAZZ(env, obj, |   737   CHECK_CLAZZ(env, obj, | 
|   730       g_MotionEvent_clazz, 0); |   738       MotionEvent_clazz(env), 0); | 
|   731   jmethodID method_id = |   739   jmethodID method_id = | 
|   732       base::android::MethodID::LazyGet< |   740       base::android::MethodID::LazyGet< | 
|   733       base::android::MethodID::TYPE_INSTANCE>( |   741       base::android::MethodID::TYPE_INSTANCE>( | 
|   734       env, g_MotionEvent_clazz, |   742       env, MotionEvent_clazz(env), | 
|   735       "getTouchMajor", |   743       "getTouchMajor", | 
|   736       "()F", |   744       "()F", | 
|   737       &g_MotionEvent_getTouchMajorF); |   745       &g_MotionEvent_getTouchMajorF); | 
|   738  |   746  | 
|   739   jfloat ret = |   747   jfloat ret = | 
|   740       env->CallFloatMethod(obj, |   748       env->CallFloatMethod(obj, | 
|   741           method_id); |   749           method_id); | 
|   742   jni_generator::CheckException(env); |   750   jni_generator::CheckException(env); | 
|   743   return ret; |   751   return ret; | 
|   744 } |   752 } | 
|   745  |   753  | 
|   746 static base::subtle::AtomicWord g_MotionEvent_getTouchMinorF = 0; |   754 static base::subtle::AtomicWord g_MotionEvent_getTouchMinorF = 0; | 
|   747 static jfloat Java_MotionEvent_getTouchMinorF(JNIEnv* env, jobject obj) |   755 static jfloat Java_MotionEvent_getTouchMinorF(JNIEnv* env, jobject obj) | 
|   748     __attribute__ ((unused)); |   756     __attribute__ ((unused)); | 
|   749 static jfloat Java_MotionEvent_getTouchMinorF(JNIEnv* env, jobject obj) { |   757 static jfloat Java_MotionEvent_getTouchMinorF(JNIEnv* env, jobject obj) { | 
|   750   /* Must call RegisterNativesImpl()  */ |   758   /* Must call RegisterNativesImpl()  */ | 
|   751   CHECK_CLAZZ(env, obj, |   759   CHECK_CLAZZ(env, obj, | 
|   752       g_MotionEvent_clazz, 0); |   760       MotionEvent_clazz(env), 0); | 
|   753   jmethodID method_id = |   761   jmethodID method_id = | 
|   754       base::android::MethodID::LazyGet< |   762       base::android::MethodID::LazyGet< | 
|   755       base::android::MethodID::TYPE_INSTANCE>( |   763       base::android::MethodID::TYPE_INSTANCE>( | 
|   756       env, g_MotionEvent_clazz, |   764       env, MotionEvent_clazz(env), | 
|   757       "getTouchMinor", |   765       "getTouchMinor", | 
|   758       "()F", |   766       "()F", | 
|   759       &g_MotionEvent_getTouchMinorF); |   767       &g_MotionEvent_getTouchMinorF); | 
|   760  |   768  | 
|   761   jfloat ret = |   769   jfloat ret = | 
|   762       env->CallFloatMethod(obj, |   770       env->CallFloatMethod(obj, | 
|   763           method_id); |   771           method_id); | 
|   764   jni_generator::CheckException(env); |   772   jni_generator::CheckException(env); | 
|   765   return ret; |   773   return ret; | 
|   766 } |   774 } | 
|   767  |   775  | 
|   768 static base::subtle::AtomicWord g_MotionEvent_getToolMajorF = 0; |   776 static base::subtle::AtomicWord g_MotionEvent_getToolMajorF = 0; | 
|   769 static jfloat Java_MotionEvent_getToolMajorF(JNIEnv* env, jobject obj) |   777 static jfloat Java_MotionEvent_getToolMajorF(JNIEnv* env, jobject obj) | 
|   770     __attribute__ ((unused)); |   778     __attribute__ ((unused)); | 
|   771 static jfloat Java_MotionEvent_getToolMajorF(JNIEnv* env, jobject obj) { |   779 static jfloat Java_MotionEvent_getToolMajorF(JNIEnv* env, jobject obj) { | 
|   772   /* Must call RegisterNativesImpl()  */ |   780   /* Must call RegisterNativesImpl()  */ | 
|   773   CHECK_CLAZZ(env, obj, |   781   CHECK_CLAZZ(env, obj, | 
|   774       g_MotionEvent_clazz, 0); |   782       MotionEvent_clazz(env), 0); | 
|   775   jmethodID method_id = |   783   jmethodID method_id = | 
|   776       base::android::MethodID::LazyGet< |   784       base::android::MethodID::LazyGet< | 
|   777       base::android::MethodID::TYPE_INSTANCE>( |   785       base::android::MethodID::TYPE_INSTANCE>( | 
|   778       env, g_MotionEvent_clazz, |   786       env, MotionEvent_clazz(env), | 
|   779       "getToolMajor", |   787       "getToolMajor", | 
|   780       "()F", |   788       "()F", | 
|   781       &g_MotionEvent_getToolMajorF); |   789       &g_MotionEvent_getToolMajorF); | 
|   782  |   790  | 
|   783   jfloat ret = |   791   jfloat ret = | 
|   784       env->CallFloatMethod(obj, |   792       env->CallFloatMethod(obj, | 
|   785           method_id); |   793           method_id); | 
|   786   jni_generator::CheckException(env); |   794   jni_generator::CheckException(env); | 
|   787   return ret; |   795   return ret; | 
|   788 } |   796 } | 
|   789  |   797  | 
|   790 static base::subtle::AtomicWord g_MotionEvent_getToolMinorF = 0; |   798 static base::subtle::AtomicWord g_MotionEvent_getToolMinorF = 0; | 
|   791 static jfloat Java_MotionEvent_getToolMinorF(JNIEnv* env, jobject obj) |   799 static jfloat Java_MotionEvent_getToolMinorF(JNIEnv* env, jobject obj) | 
|   792     __attribute__ ((unused)); |   800     __attribute__ ((unused)); | 
|   793 static jfloat Java_MotionEvent_getToolMinorF(JNIEnv* env, jobject obj) { |   801 static jfloat Java_MotionEvent_getToolMinorF(JNIEnv* env, jobject obj) { | 
|   794   /* Must call RegisterNativesImpl()  */ |   802   /* Must call RegisterNativesImpl()  */ | 
|   795   CHECK_CLAZZ(env, obj, |   803   CHECK_CLAZZ(env, obj, | 
|   796       g_MotionEvent_clazz, 0); |   804       MotionEvent_clazz(env), 0); | 
|   797   jmethodID method_id = |   805   jmethodID method_id = | 
|   798       base::android::MethodID::LazyGet< |   806       base::android::MethodID::LazyGet< | 
|   799       base::android::MethodID::TYPE_INSTANCE>( |   807       base::android::MethodID::TYPE_INSTANCE>( | 
|   800       env, g_MotionEvent_clazz, |   808       env, MotionEvent_clazz(env), | 
|   801       "getToolMinor", |   809       "getToolMinor", | 
|   802       "()F", |   810       "()F", | 
|   803       &g_MotionEvent_getToolMinorF); |   811       &g_MotionEvent_getToolMinorF); | 
|   804  |   812  | 
|   805   jfloat ret = |   813   jfloat ret = | 
|   806       env->CallFloatMethod(obj, |   814       env->CallFloatMethod(obj, | 
|   807           method_id); |   815           method_id); | 
|   808   jni_generator::CheckException(env); |   816   jni_generator::CheckException(env); | 
|   809   return ret; |   817   return ret; | 
|   810 } |   818 } | 
|   811  |   819  | 
|   812 static base::subtle::AtomicWord g_MotionEvent_getOrientationF = 0; |   820 static base::subtle::AtomicWord g_MotionEvent_getOrientationF = 0; | 
|   813 static jfloat Java_MotionEvent_getOrientationF(JNIEnv* env, jobject obj) |   821 static jfloat Java_MotionEvent_getOrientationF(JNIEnv* env, jobject obj) | 
|   814     __attribute__ ((unused)); |   822     __attribute__ ((unused)); | 
|   815 static jfloat Java_MotionEvent_getOrientationF(JNIEnv* env, jobject obj) { |   823 static jfloat Java_MotionEvent_getOrientationF(JNIEnv* env, jobject obj) { | 
|   816   /* Must call RegisterNativesImpl()  */ |   824   /* Must call RegisterNativesImpl()  */ | 
|   817   CHECK_CLAZZ(env, obj, |   825   CHECK_CLAZZ(env, obj, | 
|   818       g_MotionEvent_clazz, 0); |   826       MotionEvent_clazz(env), 0); | 
|   819   jmethodID method_id = |   827   jmethodID method_id = | 
|   820       base::android::MethodID::LazyGet< |   828       base::android::MethodID::LazyGet< | 
|   821       base::android::MethodID::TYPE_INSTANCE>( |   829       base::android::MethodID::TYPE_INSTANCE>( | 
|   822       env, g_MotionEvent_clazz, |   830       env, MotionEvent_clazz(env), | 
|   823       "getOrientation", |   831       "getOrientation", | 
|   824       "()F", |   832       "()F", | 
|   825       &g_MotionEvent_getOrientationF); |   833       &g_MotionEvent_getOrientationF); | 
|   826  |   834  | 
|   827   jfloat ret = |   835   jfloat ret = | 
|   828       env->CallFloatMethod(obj, |   836       env->CallFloatMethod(obj, | 
|   829           method_id); |   837           method_id); | 
|   830   jni_generator::CheckException(env); |   838   jni_generator::CheckException(env); | 
|   831   return ret; |   839   return ret; | 
|   832 } |   840 } | 
|   833  |   841  | 
|   834 static base::subtle::AtomicWord g_MotionEvent_getAxisValueF_I = 0; |   842 static base::subtle::AtomicWord g_MotionEvent_getAxisValueF_I = 0; | 
|   835 static jfloat Java_MotionEvent_getAxisValueF_I(JNIEnv* env, jobject obj, |   843 static jfloat Java_MotionEvent_getAxisValueF_I(JNIEnv* env, jobject obj, | 
|   836     JniIntWrapper p0) __attribute__ ((unused)); |   844     JniIntWrapper p0) __attribute__ ((unused)); | 
|   837 static jfloat Java_MotionEvent_getAxisValueF_I(JNIEnv* env, jobject obj, |   845 static jfloat Java_MotionEvent_getAxisValueF_I(JNIEnv* env, jobject obj, | 
|   838     JniIntWrapper p0) { |   846     JniIntWrapper p0) { | 
|   839   /* Must call RegisterNativesImpl()  */ |   847   /* Must call RegisterNativesImpl()  */ | 
|   840   CHECK_CLAZZ(env, obj, |   848   CHECK_CLAZZ(env, obj, | 
|   841       g_MotionEvent_clazz, 0); |   849       MotionEvent_clazz(env), 0); | 
|   842   jmethodID method_id = |   850   jmethodID method_id = | 
|   843       base::android::MethodID::LazyGet< |   851       base::android::MethodID::LazyGet< | 
|   844       base::android::MethodID::TYPE_INSTANCE>( |   852       base::android::MethodID::TYPE_INSTANCE>( | 
|   845       env, g_MotionEvent_clazz, |   853       env, MotionEvent_clazz(env), | 
|   846       "getAxisValue", |   854       "getAxisValue", | 
|   847       "(I)F", |   855       "(I)F", | 
|   848       &g_MotionEvent_getAxisValueF_I); |   856       &g_MotionEvent_getAxisValueF_I); | 
|   849  |   857  | 
|   850   jfloat ret = |   858   jfloat ret = | 
|   851       env->CallFloatMethod(obj, |   859       env->CallFloatMethod(obj, | 
|   852           method_id, as_jint(p0)); |   860           method_id, as_jint(p0)); | 
|   853   jni_generator::CheckException(env); |   861   jni_generator::CheckException(env); | 
|   854   return ret; |   862   return ret; | 
|   855 } |   863 } | 
|   856  |   864  | 
|   857 static base::subtle::AtomicWord g_MotionEvent_getPointerCount = 0; |   865 static base::subtle::AtomicWord g_MotionEvent_getPointerCount = 0; | 
|   858 static jint Java_MotionEvent_getPointerCount(JNIEnv* env, jobject obj) |   866 static jint Java_MotionEvent_getPointerCount(JNIEnv* env, jobject obj) | 
|   859     __attribute__ ((unused)); |   867     __attribute__ ((unused)); | 
|   860 static jint Java_MotionEvent_getPointerCount(JNIEnv* env, jobject obj) { |   868 static jint Java_MotionEvent_getPointerCount(JNIEnv* env, jobject obj) { | 
|   861   /* Must call RegisterNativesImpl()  */ |   869   /* Must call RegisterNativesImpl()  */ | 
|   862   CHECK_CLAZZ(env, obj, |   870   CHECK_CLAZZ(env, obj, | 
|   863       g_MotionEvent_clazz, 0); |   871       MotionEvent_clazz(env), 0); | 
|   864   jmethodID method_id = |   872   jmethodID method_id = | 
|   865       base::android::MethodID::LazyGet< |   873       base::android::MethodID::LazyGet< | 
|   866       base::android::MethodID::TYPE_INSTANCE>( |   874       base::android::MethodID::TYPE_INSTANCE>( | 
|   867       env, g_MotionEvent_clazz, |   875       env, MotionEvent_clazz(env), | 
|   868       "getPointerCount", |   876       "getPointerCount", | 
|   869       "()I", |   877       "()I", | 
|   870       &g_MotionEvent_getPointerCount); |   878       &g_MotionEvent_getPointerCount); | 
|   871  |   879  | 
|   872   jint ret = |   880   jint ret = | 
|   873       env->CallIntMethod(obj, |   881       env->CallIntMethod(obj, | 
|   874           method_id); |   882           method_id); | 
|   875   jni_generator::CheckException(env); |   883   jni_generator::CheckException(env); | 
|   876   return ret; |   884   return ret; | 
|   877 } |   885 } | 
|   878  |   886  | 
|   879 static base::subtle::AtomicWord g_MotionEvent_getPointerId = 0; |   887 static base::subtle::AtomicWord g_MotionEvent_getPointerId = 0; | 
|   880 static jint Java_MotionEvent_getPointerId(JNIEnv* env, jobject obj, |   888 static jint Java_MotionEvent_getPointerId(JNIEnv* env, jobject obj, | 
|   881     JniIntWrapper p0) __attribute__ ((unused)); |   889     JniIntWrapper p0) __attribute__ ((unused)); | 
|   882 static jint Java_MotionEvent_getPointerId(JNIEnv* env, jobject obj, |   890 static jint Java_MotionEvent_getPointerId(JNIEnv* env, jobject obj, | 
|   883     JniIntWrapper p0) { |   891     JniIntWrapper p0) { | 
|   884   /* Must call RegisterNativesImpl()  */ |   892   /* Must call RegisterNativesImpl()  */ | 
|   885   CHECK_CLAZZ(env, obj, |   893   CHECK_CLAZZ(env, obj, | 
|   886       g_MotionEvent_clazz, 0); |   894       MotionEvent_clazz(env), 0); | 
|   887   jmethodID method_id = |   895   jmethodID method_id = | 
|   888       base::android::MethodID::LazyGet< |   896       base::android::MethodID::LazyGet< | 
|   889       base::android::MethodID::TYPE_INSTANCE>( |   897       base::android::MethodID::TYPE_INSTANCE>( | 
|   890       env, g_MotionEvent_clazz, |   898       env, MotionEvent_clazz(env), | 
|   891       "getPointerId", |   899       "getPointerId", | 
|   892       "(I)I", |   900       "(I)I", | 
|   893       &g_MotionEvent_getPointerId); |   901       &g_MotionEvent_getPointerId); | 
|   894  |   902  | 
|   895   jint ret = |   903   jint ret = | 
|   896       env->CallIntMethod(obj, |   904       env->CallIntMethod(obj, | 
|   897           method_id, as_jint(p0)); |   905           method_id, as_jint(p0)); | 
|   898   jni_generator::CheckException(env); |   906   jni_generator::CheckException(env); | 
|   899   return ret; |   907   return ret; | 
|   900 } |   908 } | 
|   901  |   909  | 
|   902 static base::subtle::AtomicWord g_MotionEvent_getToolType = 0; |   910 static base::subtle::AtomicWord g_MotionEvent_getToolType = 0; | 
|   903 static jint Java_MotionEvent_getToolType(JNIEnv* env, jobject obj, JniIntWrapper |   911 static jint Java_MotionEvent_getToolType(JNIEnv* env, jobject obj, JniIntWrapper | 
|   904     p0) __attribute__ ((unused)); |   912     p0) __attribute__ ((unused)); | 
|   905 static jint Java_MotionEvent_getToolType(JNIEnv* env, jobject obj, JniIntWrapper |   913 static jint Java_MotionEvent_getToolType(JNIEnv* env, jobject obj, JniIntWrapper | 
|   906     p0) { |   914     p0) { | 
|   907   /* Must call RegisterNativesImpl()  */ |   915   /* Must call RegisterNativesImpl()  */ | 
|   908   CHECK_CLAZZ(env, obj, |   916   CHECK_CLAZZ(env, obj, | 
|   909       g_MotionEvent_clazz, 0); |   917       MotionEvent_clazz(env), 0); | 
|   910   jmethodID method_id = |   918   jmethodID method_id = | 
|   911       base::android::MethodID::LazyGet< |   919       base::android::MethodID::LazyGet< | 
|   912       base::android::MethodID::TYPE_INSTANCE>( |   920       base::android::MethodID::TYPE_INSTANCE>( | 
|   913       env, g_MotionEvent_clazz, |   921       env, MotionEvent_clazz(env), | 
|   914       "getToolType", |   922       "getToolType", | 
|   915       "(I)I", |   923       "(I)I", | 
|   916       &g_MotionEvent_getToolType); |   924       &g_MotionEvent_getToolType); | 
|   917  |   925  | 
|   918   jint ret = |   926   jint ret = | 
|   919       env->CallIntMethod(obj, |   927       env->CallIntMethod(obj, | 
|   920           method_id, as_jint(p0)); |   928           method_id, as_jint(p0)); | 
|   921   jni_generator::CheckException(env); |   929   jni_generator::CheckException(env); | 
|   922   return ret; |   930   return ret; | 
|   923 } |   931 } | 
|   924  |   932  | 
|   925 static base::subtle::AtomicWord g_MotionEvent_findPointerIndex = 0; |   933 static base::subtle::AtomicWord g_MotionEvent_findPointerIndex = 0; | 
|   926 static jint Java_MotionEvent_findPointerIndex(JNIEnv* env, jobject obj, |   934 static jint Java_MotionEvent_findPointerIndex(JNIEnv* env, jobject obj, | 
|   927     JniIntWrapper p0) __attribute__ ((unused)); |   935     JniIntWrapper p0) __attribute__ ((unused)); | 
|   928 static jint Java_MotionEvent_findPointerIndex(JNIEnv* env, jobject obj, |   936 static jint Java_MotionEvent_findPointerIndex(JNIEnv* env, jobject obj, | 
|   929     JniIntWrapper p0) { |   937     JniIntWrapper p0) { | 
|   930   /* Must call RegisterNativesImpl()  */ |   938   /* Must call RegisterNativesImpl()  */ | 
|   931   CHECK_CLAZZ(env, obj, |   939   CHECK_CLAZZ(env, obj, | 
|   932       g_MotionEvent_clazz, 0); |   940       MotionEvent_clazz(env), 0); | 
|   933   jmethodID method_id = |   941   jmethodID method_id = | 
|   934       base::android::MethodID::LazyGet< |   942       base::android::MethodID::LazyGet< | 
|   935       base::android::MethodID::TYPE_INSTANCE>( |   943       base::android::MethodID::TYPE_INSTANCE>( | 
|   936       env, g_MotionEvent_clazz, |   944       env, MotionEvent_clazz(env), | 
|   937       "findPointerIndex", |   945       "findPointerIndex", | 
|   938       "(I)I", |   946       "(I)I", | 
|   939       &g_MotionEvent_findPointerIndex); |   947       &g_MotionEvent_findPointerIndex); | 
|   940  |   948  | 
|   941   jint ret = |   949   jint ret = | 
|   942       env->CallIntMethod(obj, |   950       env->CallIntMethod(obj, | 
|   943           method_id, as_jint(p0)); |   951           method_id, as_jint(p0)); | 
|   944   jni_generator::CheckException(env); |   952   jni_generator::CheckException(env); | 
|   945   return ret; |   953   return ret; | 
|   946 } |   954 } | 
|   947  |   955  | 
|   948 static base::subtle::AtomicWord g_MotionEvent_getXF_I = 0; |   956 static base::subtle::AtomicWord g_MotionEvent_getXF_I = 0; | 
|   949 static jfloat Java_MotionEvent_getXF_I(JNIEnv* env, jobject obj, JniIntWrapper |   957 static jfloat Java_MotionEvent_getXF_I(JNIEnv* env, jobject obj, JniIntWrapper | 
|   950     p0) __attribute__ ((unused)); |   958     p0) __attribute__ ((unused)); | 
|   951 static jfloat Java_MotionEvent_getXF_I(JNIEnv* env, jobject obj, JniIntWrapper |   959 static jfloat Java_MotionEvent_getXF_I(JNIEnv* env, jobject obj, JniIntWrapper | 
|   952     p0) { |   960     p0) { | 
|   953   /* Must call RegisterNativesImpl()  */ |   961   /* Must call RegisterNativesImpl()  */ | 
|   954   CHECK_CLAZZ(env, obj, |   962   CHECK_CLAZZ(env, obj, | 
|   955       g_MotionEvent_clazz, 0); |   963       MotionEvent_clazz(env), 0); | 
|   956   jmethodID method_id = |   964   jmethodID method_id = | 
|   957       base::android::MethodID::LazyGet< |   965       base::android::MethodID::LazyGet< | 
|   958       base::android::MethodID::TYPE_INSTANCE>( |   966       base::android::MethodID::TYPE_INSTANCE>( | 
|   959       env, g_MotionEvent_clazz, |   967       env, MotionEvent_clazz(env), | 
|   960       "getX", |   968       "getX", | 
|   961       "(I)F", |   969       "(I)F", | 
|   962       &g_MotionEvent_getXF_I); |   970       &g_MotionEvent_getXF_I); | 
|   963  |   971  | 
|   964   jfloat ret = |   972   jfloat ret = | 
|   965       env->CallFloatMethod(obj, |   973       env->CallFloatMethod(obj, | 
|   966           method_id, as_jint(p0)); |   974           method_id, as_jint(p0)); | 
|   967   jni_generator::CheckException(env); |   975   jni_generator::CheckException(env); | 
|   968   return ret; |   976   return ret; | 
|   969 } |   977 } | 
|   970  |   978  | 
|   971 static base::subtle::AtomicWord g_MotionEvent_getYF_I = 0; |   979 static base::subtle::AtomicWord g_MotionEvent_getYF_I = 0; | 
|   972 static jfloat Java_MotionEvent_getYF_I(JNIEnv* env, jobject obj, JniIntWrapper |   980 static jfloat Java_MotionEvent_getYF_I(JNIEnv* env, jobject obj, JniIntWrapper | 
|   973     p0) __attribute__ ((unused)); |   981     p0) __attribute__ ((unused)); | 
|   974 static jfloat Java_MotionEvent_getYF_I(JNIEnv* env, jobject obj, JniIntWrapper |   982 static jfloat Java_MotionEvent_getYF_I(JNIEnv* env, jobject obj, JniIntWrapper | 
|   975     p0) { |   983     p0) { | 
|   976   /* Must call RegisterNativesImpl()  */ |   984   /* Must call RegisterNativesImpl()  */ | 
|   977   CHECK_CLAZZ(env, obj, |   985   CHECK_CLAZZ(env, obj, | 
|   978       g_MotionEvent_clazz, 0); |   986       MotionEvent_clazz(env), 0); | 
|   979   jmethodID method_id = |   987   jmethodID method_id = | 
|   980       base::android::MethodID::LazyGet< |   988       base::android::MethodID::LazyGet< | 
|   981       base::android::MethodID::TYPE_INSTANCE>( |   989       base::android::MethodID::TYPE_INSTANCE>( | 
|   982       env, g_MotionEvent_clazz, |   990       env, MotionEvent_clazz(env), | 
|   983       "getY", |   991       "getY", | 
|   984       "(I)F", |   992       "(I)F", | 
|   985       &g_MotionEvent_getYF_I); |   993       &g_MotionEvent_getYF_I); | 
|   986  |   994  | 
|   987   jfloat ret = |   995   jfloat ret = | 
|   988       env->CallFloatMethod(obj, |   996       env->CallFloatMethod(obj, | 
|   989           method_id, as_jint(p0)); |   997           method_id, as_jint(p0)); | 
|   990   jni_generator::CheckException(env); |   998   jni_generator::CheckException(env); | 
|   991   return ret; |   999   return ret; | 
|   992 } |  1000 } | 
|   993  |  1001  | 
|   994 static base::subtle::AtomicWord g_MotionEvent_getPressureF_I = 0; |  1002 static base::subtle::AtomicWord g_MotionEvent_getPressureF_I = 0; | 
|   995 static jfloat Java_MotionEvent_getPressureF_I(JNIEnv* env, jobject obj, |  1003 static jfloat Java_MotionEvent_getPressureF_I(JNIEnv* env, jobject obj, | 
|   996     JniIntWrapper p0) __attribute__ ((unused)); |  1004     JniIntWrapper p0) __attribute__ ((unused)); | 
|   997 static jfloat Java_MotionEvent_getPressureF_I(JNIEnv* env, jobject obj, |  1005 static jfloat Java_MotionEvent_getPressureF_I(JNIEnv* env, jobject obj, | 
|   998     JniIntWrapper p0) { |  1006     JniIntWrapper p0) { | 
|   999   /* Must call RegisterNativesImpl()  */ |  1007   /* Must call RegisterNativesImpl()  */ | 
|  1000   CHECK_CLAZZ(env, obj, |  1008   CHECK_CLAZZ(env, obj, | 
|  1001       g_MotionEvent_clazz, 0); |  1009       MotionEvent_clazz(env), 0); | 
|  1002   jmethodID method_id = |  1010   jmethodID method_id = | 
|  1003       base::android::MethodID::LazyGet< |  1011       base::android::MethodID::LazyGet< | 
|  1004       base::android::MethodID::TYPE_INSTANCE>( |  1012       base::android::MethodID::TYPE_INSTANCE>( | 
|  1005       env, g_MotionEvent_clazz, |  1013       env, MotionEvent_clazz(env), | 
|  1006       "getPressure", |  1014       "getPressure", | 
|  1007       "(I)F", |  1015       "(I)F", | 
|  1008       &g_MotionEvent_getPressureF_I); |  1016       &g_MotionEvent_getPressureF_I); | 
|  1009  |  1017  | 
|  1010   jfloat ret = |  1018   jfloat ret = | 
|  1011       env->CallFloatMethod(obj, |  1019       env->CallFloatMethod(obj, | 
|  1012           method_id, as_jint(p0)); |  1020           method_id, as_jint(p0)); | 
|  1013   jni_generator::CheckException(env); |  1021   jni_generator::CheckException(env); | 
|  1014   return ret; |  1022   return ret; | 
|  1015 } |  1023 } | 
|  1016  |  1024  | 
|  1017 static base::subtle::AtomicWord g_MotionEvent_getSizeF_I = 0; |  1025 static base::subtle::AtomicWord g_MotionEvent_getSizeF_I = 0; | 
|  1018 static jfloat Java_MotionEvent_getSizeF_I(JNIEnv* env, jobject obj, |  1026 static jfloat Java_MotionEvent_getSizeF_I(JNIEnv* env, jobject obj, | 
|  1019     JniIntWrapper p0) __attribute__ ((unused)); |  1027     JniIntWrapper p0) __attribute__ ((unused)); | 
|  1020 static jfloat Java_MotionEvent_getSizeF_I(JNIEnv* env, jobject obj, |  1028 static jfloat Java_MotionEvent_getSizeF_I(JNIEnv* env, jobject obj, | 
|  1021     JniIntWrapper p0) { |  1029     JniIntWrapper p0) { | 
|  1022   /* Must call RegisterNativesImpl()  */ |  1030   /* Must call RegisterNativesImpl()  */ | 
|  1023   CHECK_CLAZZ(env, obj, |  1031   CHECK_CLAZZ(env, obj, | 
|  1024       g_MotionEvent_clazz, 0); |  1032       MotionEvent_clazz(env), 0); | 
|  1025   jmethodID method_id = |  1033   jmethodID method_id = | 
|  1026       base::android::MethodID::LazyGet< |  1034       base::android::MethodID::LazyGet< | 
|  1027       base::android::MethodID::TYPE_INSTANCE>( |  1035       base::android::MethodID::TYPE_INSTANCE>( | 
|  1028       env, g_MotionEvent_clazz, |  1036       env, MotionEvent_clazz(env), | 
|  1029       "getSize", |  1037       "getSize", | 
|  1030       "(I)F", |  1038       "(I)F", | 
|  1031       &g_MotionEvent_getSizeF_I); |  1039       &g_MotionEvent_getSizeF_I); | 
|  1032  |  1040  | 
|  1033   jfloat ret = |  1041   jfloat ret = | 
|  1034       env->CallFloatMethod(obj, |  1042       env->CallFloatMethod(obj, | 
|  1035           method_id, as_jint(p0)); |  1043           method_id, as_jint(p0)); | 
|  1036   jni_generator::CheckException(env); |  1044   jni_generator::CheckException(env); | 
|  1037   return ret; |  1045   return ret; | 
|  1038 } |  1046 } | 
|  1039  |  1047  | 
|  1040 static base::subtle::AtomicWord g_MotionEvent_getTouchMajorF_I = 0; |  1048 static base::subtle::AtomicWord g_MotionEvent_getTouchMajorF_I = 0; | 
|  1041 static jfloat Java_MotionEvent_getTouchMajorF_I(JNIEnv* env, jobject obj, |  1049 static jfloat Java_MotionEvent_getTouchMajorF_I(JNIEnv* env, jobject obj, | 
|  1042     JniIntWrapper p0) __attribute__ ((unused)); |  1050     JniIntWrapper p0) __attribute__ ((unused)); | 
|  1043 static jfloat Java_MotionEvent_getTouchMajorF_I(JNIEnv* env, jobject obj, |  1051 static jfloat Java_MotionEvent_getTouchMajorF_I(JNIEnv* env, jobject obj, | 
|  1044     JniIntWrapper p0) { |  1052     JniIntWrapper p0) { | 
|  1045   /* Must call RegisterNativesImpl()  */ |  1053   /* Must call RegisterNativesImpl()  */ | 
|  1046   CHECK_CLAZZ(env, obj, |  1054   CHECK_CLAZZ(env, obj, | 
|  1047       g_MotionEvent_clazz, 0); |  1055       MotionEvent_clazz(env), 0); | 
|  1048   jmethodID method_id = |  1056   jmethodID method_id = | 
|  1049       base::android::MethodID::LazyGet< |  1057       base::android::MethodID::LazyGet< | 
|  1050       base::android::MethodID::TYPE_INSTANCE>( |  1058       base::android::MethodID::TYPE_INSTANCE>( | 
|  1051       env, g_MotionEvent_clazz, |  1059       env, MotionEvent_clazz(env), | 
|  1052       "getTouchMajor", |  1060       "getTouchMajor", | 
|  1053       "(I)F", |  1061       "(I)F", | 
|  1054       &g_MotionEvent_getTouchMajorF_I); |  1062       &g_MotionEvent_getTouchMajorF_I); | 
|  1055  |  1063  | 
|  1056   jfloat ret = |  1064   jfloat ret = | 
|  1057       env->CallFloatMethod(obj, |  1065       env->CallFloatMethod(obj, | 
|  1058           method_id, as_jint(p0)); |  1066           method_id, as_jint(p0)); | 
|  1059   jni_generator::CheckException(env); |  1067   jni_generator::CheckException(env); | 
|  1060   return ret; |  1068   return ret; | 
|  1061 } |  1069 } | 
|  1062  |  1070  | 
|  1063 static base::subtle::AtomicWord g_MotionEvent_getTouchMinorF_I = 0; |  1071 static base::subtle::AtomicWord g_MotionEvent_getTouchMinorF_I = 0; | 
|  1064 static jfloat Java_MotionEvent_getTouchMinorF_I(JNIEnv* env, jobject obj, |  1072 static jfloat Java_MotionEvent_getTouchMinorF_I(JNIEnv* env, jobject obj, | 
|  1065     JniIntWrapper p0) __attribute__ ((unused)); |  1073     JniIntWrapper p0) __attribute__ ((unused)); | 
|  1066 static jfloat Java_MotionEvent_getTouchMinorF_I(JNIEnv* env, jobject obj, |  1074 static jfloat Java_MotionEvent_getTouchMinorF_I(JNIEnv* env, jobject obj, | 
|  1067     JniIntWrapper p0) { |  1075     JniIntWrapper p0) { | 
|  1068   /* Must call RegisterNativesImpl()  */ |  1076   /* Must call RegisterNativesImpl()  */ | 
|  1069   CHECK_CLAZZ(env, obj, |  1077   CHECK_CLAZZ(env, obj, | 
|  1070       g_MotionEvent_clazz, 0); |  1078       MotionEvent_clazz(env), 0); | 
|  1071   jmethodID method_id = |  1079   jmethodID method_id = | 
|  1072       base::android::MethodID::LazyGet< |  1080       base::android::MethodID::LazyGet< | 
|  1073       base::android::MethodID::TYPE_INSTANCE>( |  1081       base::android::MethodID::TYPE_INSTANCE>( | 
|  1074       env, g_MotionEvent_clazz, |  1082       env, MotionEvent_clazz(env), | 
|  1075       "getTouchMinor", |  1083       "getTouchMinor", | 
|  1076       "(I)F", |  1084       "(I)F", | 
|  1077       &g_MotionEvent_getTouchMinorF_I); |  1085       &g_MotionEvent_getTouchMinorF_I); | 
|  1078  |  1086  | 
|  1079   jfloat ret = |  1087   jfloat ret = | 
|  1080       env->CallFloatMethod(obj, |  1088       env->CallFloatMethod(obj, | 
|  1081           method_id, as_jint(p0)); |  1089           method_id, as_jint(p0)); | 
|  1082   jni_generator::CheckException(env); |  1090   jni_generator::CheckException(env); | 
|  1083   return ret; |  1091   return ret; | 
|  1084 } |  1092 } | 
|  1085  |  1093  | 
|  1086 static base::subtle::AtomicWord g_MotionEvent_getToolMajorF_I = 0; |  1094 static base::subtle::AtomicWord g_MotionEvent_getToolMajorF_I = 0; | 
|  1087 static jfloat Java_MotionEvent_getToolMajorF_I(JNIEnv* env, jobject obj, |  1095 static jfloat Java_MotionEvent_getToolMajorF_I(JNIEnv* env, jobject obj, | 
|  1088     JniIntWrapper p0) __attribute__ ((unused)); |  1096     JniIntWrapper p0) __attribute__ ((unused)); | 
|  1089 static jfloat Java_MotionEvent_getToolMajorF_I(JNIEnv* env, jobject obj, |  1097 static jfloat Java_MotionEvent_getToolMajorF_I(JNIEnv* env, jobject obj, | 
|  1090     JniIntWrapper p0) { |  1098     JniIntWrapper p0) { | 
|  1091   /* Must call RegisterNativesImpl()  */ |  1099   /* Must call RegisterNativesImpl()  */ | 
|  1092   CHECK_CLAZZ(env, obj, |  1100   CHECK_CLAZZ(env, obj, | 
|  1093       g_MotionEvent_clazz, 0); |  1101       MotionEvent_clazz(env), 0); | 
|  1094   jmethodID method_id = |  1102   jmethodID method_id = | 
|  1095       base::android::MethodID::LazyGet< |  1103       base::android::MethodID::LazyGet< | 
|  1096       base::android::MethodID::TYPE_INSTANCE>( |  1104       base::android::MethodID::TYPE_INSTANCE>( | 
|  1097       env, g_MotionEvent_clazz, |  1105       env, MotionEvent_clazz(env), | 
|  1098       "getToolMajor", |  1106       "getToolMajor", | 
|  1099       "(I)F", |  1107       "(I)F", | 
|  1100       &g_MotionEvent_getToolMajorF_I); |  1108       &g_MotionEvent_getToolMajorF_I); | 
|  1101  |  1109  | 
|  1102   jfloat ret = |  1110   jfloat ret = | 
|  1103       env->CallFloatMethod(obj, |  1111       env->CallFloatMethod(obj, | 
|  1104           method_id, as_jint(p0)); |  1112           method_id, as_jint(p0)); | 
|  1105   jni_generator::CheckException(env); |  1113   jni_generator::CheckException(env); | 
|  1106   return ret; |  1114   return ret; | 
|  1107 } |  1115 } | 
|  1108  |  1116  | 
|  1109 static base::subtle::AtomicWord g_MotionEvent_getToolMinorF_I = 0; |  1117 static base::subtle::AtomicWord g_MotionEvent_getToolMinorF_I = 0; | 
|  1110 static jfloat Java_MotionEvent_getToolMinorF_I(JNIEnv* env, jobject obj, |  1118 static jfloat Java_MotionEvent_getToolMinorF_I(JNIEnv* env, jobject obj, | 
|  1111     JniIntWrapper p0) __attribute__ ((unused)); |  1119     JniIntWrapper p0) __attribute__ ((unused)); | 
|  1112 static jfloat Java_MotionEvent_getToolMinorF_I(JNIEnv* env, jobject obj, |  1120 static jfloat Java_MotionEvent_getToolMinorF_I(JNIEnv* env, jobject obj, | 
|  1113     JniIntWrapper p0) { |  1121     JniIntWrapper p0) { | 
|  1114   /* Must call RegisterNativesImpl()  */ |  1122   /* Must call RegisterNativesImpl()  */ | 
|  1115   CHECK_CLAZZ(env, obj, |  1123   CHECK_CLAZZ(env, obj, | 
|  1116       g_MotionEvent_clazz, 0); |  1124       MotionEvent_clazz(env), 0); | 
|  1117   jmethodID method_id = |  1125   jmethodID method_id = | 
|  1118       base::android::MethodID::LazyGet< |  1126       base::android::MethodID::LazyGet< | 
|  1119       base::android::MethodID::TYPE_INSTANCE>( |  1127       base::android::MethodID::TYPE_INSTANCE>( | 
|  1120       env, g_MotionEvent_clazz, |  1128       env, MotionEvent_clazz(env), | 
|  1121       "getToolMinor", |  1129       "getToolMinor", | 
|  1122       "(I)F", |  1130       "(I)F", | 
|  1123       &g_MotionEvent_getToolMinorF_I); |  1131       &g_MotionEvent_getToolMinorF_I); | 
|  1124  |  1132  | 
|  1125   jfloat ret = |  1133   jfloat ret = | 
|  1126       env->CallFloatMethod(obj, |  1134       env->CallFloatMethod(obj, | 
|  1127           method_id, as_jint(p0)); |  1135           method_id, as_jint(p0)); | 
|  1128   jni_generator::CheckException(env); |  1136   jni_generator::CheckException(env); | 
|  1129   return ret; |  1137   return ret; | 
|  1130 } |  1138 } | 
|  1131  |  1139  | 
|  1132 static base::subtle::AtomicWord g_MotionEvent_getOrientationF_I = 0; |  1140 static base::subtle::AtomicWord g_MotionEvent_getOrientationF_I = 0; | 
|  1133 static jfloat Java_MotionEvent_getOrientationF_I(JNIEnv* env, jobject obj, |  1141 static jfloat Java_MotionEvent_getOrientationF_I(JNIEnv* env, jobject obj, | 
|  1134     JniIntWrapper p0) __attribute__ ((unused)); |  1142     JniIntWrapper p0) __attribute__ ((unused)); | 
|  1135 static jfloat Java_MotionEvent_getOrientationF_I(JNIEnv* env, jobject obj, |  1143 static jfloat Java_MotionEvent_getOrientationF_I(JNIEnv* env, jobject obj, | 
|  1136     JniIntWrapper p0) { |  1144     JniIntWrapper p0) { | 
|  1137   /* Must call RegisterNativesImpl()  */ |  1145   /* Must call RegisterNativesImpl()  */ | 
|  1138   CHECK_CLAZZ(env, obj, |  1146   CHECK_CLAZZ(env, obj, | 
|  1139       g_MotionEvent_clazz, 0); |  1147       MotionEvent_clazz(env), 0); | 
|  1140   jmethodID method_id = |  1148   jmethodID method_id = | 
|  1141       base::android::MethodID::LazyGet< |  1149       base::android::MethodID::LazyGet< | 
|  1142       base::android::MethodID::TYPE_INSTANCE>( |  1150       base::android::MethodID::TYPE_INSTANCE>( | 
|  1143       env, g_MotionEvent_clazz, |  1151       env, MotionEvent_clazz(env), | 
|  1144       "getOrientation", |  1152       "getOrientation", | 
|  1145       "(I)F", |  1153       "(I)F", | 
|  1146       &g_MotionEvent_getOrientationF_I); |  1154       &g_MotionEvent_getOrientationF_I); | 
|  1147  |  1155  | 
|  1148   jfloat ret = |  1156   jfloat ret = | 
|  1149       env->CallFloatMethod(obj, |  1157       env->CallFloatMethod(obj, | 
|  1150           method_id, as_jint(p0)); |  1158           method_id, as_jint(p0)); | 
|  1151   jni_generator::CheckException(env); |  1159   jni_generator::CheckException(env); | 
|  1152   return ret; |  1160   return ret; | 
|  1153 } |  1161 } | 
|  1154  |  1162  | 
|  1155 static base::subtle::AtomicWord g_MotionEvent_getAxisValueF_I_I = 0; |  1163 static base::subtle::AtomicWord g_MotionEvent_getAxisValueF_I_I = 0; | 
|  1156 static jfloat Java_MotionEvent_getAxisValueF_I_I(JNIEnv* env, jobject obj, |  1164 static jfloat Java_MotionEvent_getAxisValueF_I_I(JNIEnv* env, jobject obj, | 
|  1157     JniIntWrapper p0, |  1165     JniIntWrapper p0, | 
|  1158     JniIntWrapper p1) __attribute__ ((unused)); |  1166     JniIntWrapper p1) __attribute__ ((unused)); | 
|  1159 static jfloat Java_MotionEvent_getAxisValueF_I_I(JNIEnv* env, jobject obj, |  1167 static jfloat Java_MotionEvent_getAxisValueF_I_I(JNIEnv* env, jobject obj, | 
|  1160     JniIntWrapper p0, |  1168     JniIntWrapper p0, | 
|  1161     JniIntWrapper p1) { |  1169     JniIntWrapper p1) { | 
|  1162   /* Must call RegisterNativesImpl()  */ |  1170   /* Must call RegisterNativesImpl()  */ | 
|  1163   CHECK_CLAZZ(env, obj, |  1171   CHECK_CLAZZ(env, obj, | 
|  1164       g_MotionEvent_clazz, 0); |  1172       MotionEvent_clazz(env), 0); | 
|  1165   jmethodID method_id = |  1173   jmethodID method_id = | 
|  1166       base::android::MethodID::LazyGet< |  1174       base::android::MethodID::LazyGet< | 
|  1167       base::android::MethodID::TYPE_INSTANCE>( |  1175       base::android::MethodID::TYPE_INSTANCE>( | 
|  1168       env, g_MotionEvent_clazz, |  1176       env, MotionEvent_clazz(env), | 
|  1169       "getAxisValue", |  1177       "getAxisValue", | 
|  1170       "(II)F", |  1178       "(II)F", | 
|  1171       &g_MotionEvent_getAxisValueF_I_I); |  1179       &g_MotionEvent_getAxisValueF_I_I); | 
|  1172  |  1180  | 
|  1173   jfloat ret = |  1181   jfloat ret = | 
|  1174       env->CallFloatMethod(obj, |  1182       env->CallFloatMethod(obj, | 
|  1175           method_id, as_jint(p0), as_jint(p1)); |  1183           method_id, as_jint(p0), as_jint(p1)); | 
|  1176   jni_generator::CheckException(env); |  1184   jni_generator::CheckException(env); | 
|  1177   return ret; |  1185   return ret; | 
|  1178 } |  1186 } | 
|  1179  |  1187  | 
|  1180 static base::subtle::AtomicWord g_MotionEvent_getPointerCoords = 0; |  1188 static base::subtle::AtomicWord g_MotionEvent_getPointerCoords = 0; | 
|  1181 static void Java_MotionEvent_getPointerCoords(JNIEnv* env, jobject obj, |  1189 static void Java_MotionEvent_getPointerCoords(JNIEnv* env, jobject obj, | 
|  1182     JniIntWrapper p0, |  1190     JniIntWrapper p0, | 
|  1183     jobject p1) __attribute__ ((unused)); |  1191     jobject p1) __attribute__ ((unused)); | 
|  1184 static void Java_MotionEvent_getPointerCoords(JNIEnv* env, jobject obj, |  1192 static void Java_MotionEvent_getPointerCoords(JNIEnv* env, jobject obj, | 
|  1185     JniIntWrapper p0, |  1193     JniIntWrapper p0, | 
|  1186     jobject p1) { |  1194     jobject p1) { | 
|  1187   /* Must call RegisterNativesImpl()  */ |  1195   /* Must call RegisterNativesImpl()  */ | 
|  1188   CHECK_CLAZZ(env, obj, |  1196   CHECK_CLAZZ(env, obj, | 
|  1189       g_MotionEvent_clazz); |  1197       MotionEvent_clazz(env)); | 
|  1190   jmethodID method_id = |  1198   jmethodID method_id = | 
|  1191       base::android::MethodID::LazyGet< |  1199       base::android::MethodID::LazyGet< | 
|  1192       base::android::MethodID::TYPE_INSTANCE>( |  1200       base::android::MethodID::TYPE_INSTANCE>( | 
|  1193       env, g_MotionEvent_clazz, |  1201       env, MotionEvent_clazz(env), | 
|  1194       "getPointerCoords", |  1202       "getPointerCoords", | 
|  1195       "(ILandroid/view/MotionEvent$PointerCoords;)V", |  1203       "(ILandroid/view/MotionEvent$PointerCoords;)V", | 
|  1196       &g_MotionEvent_getPointerCoords); |  1204       &g_MotionEvent_getPointerCoords); | 
|  1197  |  1205  | 
|  1198      env->CallVoidMethod(obj, |  1206      env->CallVoidMethod(obj, | 
|  1199           method_id, as_jint(p0), p1); |  1207           method_id, as_jint(p0), p1); | 
|  1200   jni_generator::CheckException(env); |  1208   jni_generator::CheckException(env); | 
|  1201  |  1209  | 
|  1202 } |  1210 } | 
|  1203  |  1211  | 
|  1204 static base::subtle::AtomicWord g_MotionEvent_getPointerProperties = 0; |  1212 static base::subtle::AtomicWord g_MotionEvent_getPointerProperties = 0; | 
|  1205 static void Java_MotionEvent_getPointerProperties(JNIEnv* env, jobject obj, |  1213 static void Java_MotionEvent_getPointerProperties(JNIEnv* env, jobject obj, | 
|  1206     JniIntWrapper p0, |  1214     JniIntWrapper p0, | 
|  1207     jobject p1) __attribute__ ((unused)); |  1215     jobject p1) __attribute__ ((unused)); | 
|  1208 static void Java_MotionEvent_getPointerProperties(JNIEnv* env, jobject obj, |  1216 static void Java_MotionEvent_getPointerProperties(JNIEnv* env, jobject obj, | 
|  1209     JniIntWrapper p0, |  1217     JniIntWrapper p0, | 
|  1210     jobject p1) { |  1218     jobject p1) { | 
|  1211   /* Must call RegisterNativesImpl()  */ |  1219   /* Must call RegisterNativesImpl()  */ | 
|  1212   CHECK_CLAZZ(env, obj, |  1220   CHECK_CLAZZ(env, obj, | 
|  1213       g_MotionEvent_clazz); |  1221       MotionEvent_clazz(env)); | 
|  1214   jmethodID method_id = |  1222   jmethodID method_id = | 
|  1215       base::android::MethodID::LazyGet< |  1223       base::android::MethodID::LazyGet< | 
|  1216       base::android::MethodID::TYPE_INSTANCE>( |  1224       base::android::MethodID::TYPE_INSTANCE>( | 
|  1217       env, g_MotionEvent_clazz, |  1225       env, MotionEvent_clazz(env), | 
|  1218       "getPointerProperties", |  1226       "getPointerProperties", | 
|  1219       "(ILandroid/view/MotionEvent$PointerProperties;)V", |  1227       "(ILandroid/view/MotionEvent$PointerProperties;)V", | 
|  1220       &g_MotionEvent_getPointerProperties); |  1228       &g_MotionEvent_getPointerProperties); | 
|  1221  |  1229  | 
|  1222      env->CallVoidMethod(obj, |  1230      env->CallVoidMethod(obj, | 
|  1223           method_id, as_jint(p0), p1); |  1231           method_id, as_jint(p0), p1); | 
|  1224   jni_generator::CheckException(env); |  1232   jni_generator::CheckException(env); | 
|  1225  |  1233  | 
|  1226 } |  1234 } | 
|  1227  |  1235  | 
|  1228 static base::subtle::AtomicWord g_MotionEvent_getMetaState = 0; |  1236 static base::subtle::AtomicWord g_MotionEvent_getMetaState = 0; | 
|  1229 static jint Java_MotionEvent_getMetaState(JNIEnv* env, jobject obj) |  1237 static jint Java_MotionEvent_getMetaState(JNIEnv* env, jobject obj) | 
|  1230     __attribute__ ((unused)); |  1238     __attribute__ ((unused)); | 
|  1231 static jint Java_MotionEvent_getMetaState(JNIEnv* env, jobject obj) { |  1239 static jint Java_MotionEvent_getMetaState(JNIEnv* env, jobject obj) { | 
|  1232   /* Must call RegisterNativesImpl()  */ |  1240   /* Must call RegisterNativesImpl()  */ | 
|  1233   CHECK_CLAZZ(env, obj, |  1241   CHECK_CLAZZ(env, obj, | 
|  1234       g_MotionEvent_clazz, 0); |  1242       MotionEvent_clazz(env), 0); | 
|  1235   jmethodID method_id = |  1243   jmethodID method_id = | 
|  1236       base::android::MethodID::LazyGet< |  1244       base::android::MethodID::LazyGet< | 
|  1237       base::android::MethodID::TYPE_INSTANCE>( |  1245       base::android::MethodID::TYPE_INSTANCE>( | 
|  1238       env, g_MotionEvent_clazz, |  1246       env, MotionEvent_clazz(env), | 
|  1239       "getMetaState", |  1247       "getMetaState", | 
|  1240       "()I", |  1248       "()I", | 
|  1241       &g_MotionEvent_getMetaState); |  1249       &g_MotionEvent_getMetaState); | 
|  1242  |  1250  | 
|  1243   jint ret = |  1251   jint ret = | 
|  1244       env->CallIntMethod(obj, |  1252       env->CallIntMethod(obj, | 
|  1245           method_id); |  1253           method_id); | 
|  1246   jni_generator::CheckException(env); |  1254   jni_generator::CheckException(env); | 
|  1247   return ret; |  1255   return ret; | 
|  1248 } |  1256 } | 
|  1249  |  1257  | 
|  1250 static base::subtle::AtomicWord g_MotionEvent_getButtonState = 0; |  1258 static base::subtle::AtomicWord g_MotionEvent_getButtonState = 0; | 
|  1251 static jint Java_MotionEvent_getButtonState(JNIEnv* env, jobject obj) |  1259 static jint Java_MotionEvent_getButtonState(JNIEnv* env, jobject obj) | 
|  1252     __attribute__ ((unused)); |  1260     __attribute__ ((unused)); | 
|  1253 static jint Java_MotionEvent_getButtonState(JNIEnv* env, jobject obj) { |  1261 static jint Java_MotionEvent_getButtonState(JNIEnv* env, jobject obj) { | 
|  1254   /* Must call RegisterNativesImpl()  */ |  1262   /* Must call RegisterNativesImpl()  */ | 
|  1255   CHECK_CLAZZ(env, obj, |  1263   CHECK_CLAZZ(env, obj, | 
|  1256       g_MotionEvent_clazz, 0); |  1264       MotionEvent_clazz(env), 0); | 
|  1257   jmethodID method_id = |  1265   jmethodID method_id = | 
|  1258       base::android::MethodID::LazyGet< |  1266       base::android::MethodID::LazyGet< | 
|  1259       base::android::MethodID::TYPE_INSTANCE>( |  1267       base::android::MethodID::TYPE_INSTANCE>( | 
|  1260       env, g_MotionEvent_clazz, |  1268       env, MotionEvent_clazz(env), | 
|  1261       "getButtonState", |  1269       "getButtonState", | 
|  1262       "()I", |  1270       "()I", | 
|  1263       &g_MotionEvent_getButtonState); |  1271       &g_MotionEvent_getButtonState); | 
|  1264  |  1272  | 
|  1265   jint ret = |  1273   jint ret = | 
|  1266       env->CallIntMethod(obj, |  1274       env->CallIntMethod(obj, | 
|  1267           method_id); |  1275           method_id); | 
|  1268   jni_generator::CheckException(env); |  1276   jni_generator::CheckException(env); | 
|  1269   return ret; |  1277   return ret; | 
|  1270 } |  1278 } | 
|  1271  |  1279  | 
|  1272 static base::subtle::AtomicWord g_MotionEvent_getRawX = 0; |  1280 static base::subtle::AtomicWord g_MotionEvent_getRawX = 0; | 
|  1273 static jfloat Java_MotionEvent_getRawX(JNIEnv* env, jobject obj) __attribute__ |  1281 static jfloat Java_MotionEvent_getRawX(JNIEnv* env, jobject obj) __attribute__ | 
|  1274     ((unused)); |  1282     ((unused)); | 
|  1275 static jfloat Java_MotionEvent_getRawX(JNIEnv* env, jobject obj) { |  1283 static jfloat Java_MotionEvent_getRawX(JNIEnv* env, jobject obj) { | 
|  1276   /* Must call RegisterNativesImpl()  */ |  1284   /* Must call RegisterNativesImpl()  */ | 
|  1277   CHECK_CLAZZ(env, obj, |  1285   CHECK_CLAZZ(env, obj, | 
|  1278       g_MotionEvent_clazz, 0); |  1286       MotionEvent_clazz(env), 0); | 
|  1279   jmethodID method_id = |  1287   jmethodID method_id = | 
|  1280       base::android::MethodID::LazyGet< |  1288       base::android::MethodID::LazyGet< | 
|  1281       base::android::MethodID::TYPE_INSTANCE>( |  1289       base::android::MethodID::TYPE_INSTANCE>( | 
|  1282       env, g_MotionEvent_clazz, |  1290       env, MotionEvent_clazz(env), | 
|  1283       "getRawX", |  1291       "getRawX", | 
|  1284       "()F", |  1292       "()F", | 
|  1285       &g_MotionEvent_getRawX); |  1293       &g_MotionEvent_getRawX); | 
|  1286  |  1294  | 
|  1287   jfloat ret = |  1295   jfloat ret = | 
|  1288       env->CallFloatMethod(obj, |  1296       env->CallFloatMethod(obj, | 
|  1289           method_id); |  1297           method_id); | 
|  1290   jni_generator::CheckException(env); |  1298   jni_generator::CheckException(env); | 
|  1291   return ret; |  1299   return ret; | 
|  1292 } |  1300 } | 
|  1293  |  1301  | 
|  1294 static base::subtle::AtomicWord g_MotionEvent_getRawY = 0; |  1302 static base::subtle::AtomicWord g_MotionEvent_getRawY = 0; | 
|  1295 static jfloat Java_MotionEvent_getRawY(JNIEnv* env, jobject obj) __attribute__ |  1303 static jfloat Java_MotionEvent_getRawY(JNIEnv* env, jobject obj) __attribute__ | 
|  1296     ((unused)); |  1304     ((unused)); | 
|  1297 static jfloat Java_MotionEvent_getRawY(JNIEnv* env, jobject obj) { |  1305 static jfloat Java_MotionEvent_getRawY(JNIEnv* env, jobject obj) { | 
|  1298   /* Must call RegisterNativesImpl()  */ |  1306   /* Must call RegisterNativesImpl()  */ | 
|  1299   CHECK_CLAZZ(env, obj, |  1307   CHECK_CLAZZ(env, obj, | 
|  1300       g_MotionEvent_clazz, 0); |  1308       MotionEvent_clazz(env), 0); | 
|  1301   jmethodID method_id = |  1309   jmethodID method_id = | 
|  1302       base::android::MethodID::LazyGet< |  1310       base::android::MethodID::LazyGet< | 
|  1303       base::android::MethodID::TYPE_INSTANCE>( |  1311       base::android::MethodID::TYPE_INSTANCE>( | 
|  1304       env, g_MotionEvent_clazz, |  1312       env, MotionEvent_clazz(env), | 
|  1305       "getRawY", |  1313       "getRawY", | 
|  1306       "()F", |  1314       "()F", | 
|  1307       &g_MotionEvent_getRawY); |  1315       &g_MotionEvent_getRawY); | 
|  1308  |  1316  | 
|  1309   jfloat ret = |  1317   jfloat ret = | 
|  1310       env->CallFloatMethod(obj, |  1318       env->CallFloatMethod(obj, | 
|  1311           method_id); |  1319           method_id); | 
|  1312   jni_generator::CheckException(env); |  1320   jni_generator::CheckException(env); | 
|  1313   return ret; |  1321   return ret; | 
|  1314 } |  1322 } | 
|  1315  |  1323  | 
|  1316 static base::subtle::AtomicWord g_MotionEvent_getXPrecision = 0; |  1324 static base::subtle::AtomicWord g_MotionEvent_getXPrecision = 0; | 
|  1317 static jfloat Java_MotionEvent_getXPrecision(JNIEnv* env, jobject obj) |  1325 static jfloat Java_MotionEvent_getXPrecision(JNIEnv* env, jobject obj) | 
|  1318     __attribute__ ((unused)); |  1326     __attribute__ ((unused)); | 
|  1319 static jfloat Java_MotionEvent_getXPrecision(JNIEnv* env, jobject obj) { |  1327 static jfloat Java_MotionEvent_getXPrecision(JNIEnv* env, jobject obj) { | 
|  1320   /* Must call RegisterNativesImpl()  */ |  1328   /* Must call RegisterNativesImpl()  */ | 
|  1321   CHECK_CLAZZ(env, obj, |  1329   CHECK_CLAZZ(env, obj, | 
|  1322       g_MotionEvent_clazz, 0); |  1330       MotionEvent_clazz(env), 0); | 
|  1323   jmethodID method_id = |  1331   jmethodID method_id = | 
|  1324       base::android::MethodID::LazyGet< |  1332       base::android::MethodID::LazyGet< | 
|  1325       base::android::MethodID::TYPE_INSTANCE>( |  1333       base::android::MethodID::TYPE_INSTANCE>( | 
|  1326       env, g_MotionEvent_clazz, |  1334       env, MotionEvent_clazz(env), | 
|  1327       "getXPrecision", |  1335       "getXPrecision", | 
|  1328       "()F", |  1336       "()F", | 
|  1329       &g_MotionEvent_getXPrecision); |  1337       &g_MotionEvent_getXPrecision); | 
|  1330  |  1338  | 
|  1331   jfloat ret = |  1339   jfloat ret = | 
|  1332       env->CallFloatMethod(obj, |  1340       env->CallFloatMethod(obj, | 
|  1333           method_id); |  1341           method_id); | 
|  1334   jni_generator::CheckException(env); |  1342   jni_generator::CheckException(env); | 
|  1335   return ret; |  1343   return ret; | 
|  1336 } |  1344 } | 
|  1337  |  1345  | 
|  1338 static base::subtle::AtomicWord g_MotionEvent_getYPrecision = 0; |  1346 static base::subtle::AtomicWord g_MotionEvent_getYPrecision = 0; | 
|  1339 static jfloat Java_MotionEvent_getYPrecision(JNIEnv* env, jobject obj) |  1347 static jfloat Java_MotionEvent_getYPrecision(JNIEnv* env, jobject obj) | 
|  1340     __attribute__ ((unused)); |  1348     __attribute__ ((unused)); | 
|  1341 static jfloat Java_MotionEvent_getYPrecision(JNIEnv* env, jobject obj) { |  1349 static jfloat Java_MotionEvent_getYPrecision(JNIEnv* env, jobject obj) { | 
|  1342   /* Must call RegisterNativesImpl()  */ |  1350   /* Must call RegisterNativesImpl()  */ | 
|  1343   CHECK_CLAZZ(env, obj, |  1351   CHECK_CLAZZ(env, obj, | 
|  1344       g_MotionEvent_clazz, 0); |  1352       MotionEvent_clazz(env), 0); | 
|  1345   jmethodID method_id = |  1353   jmethodID method_id = | 
|  1346       base::android::MethodID::LazyGet< |  1354       base::android::MethodID::LazyGet< | 
|  1347       base::android::MethodID::TYPE_INSTANCE>( |  1355       base::android::MethodID::TYPE_INSTANCE>( | 
|  1348       env, g_MotionEvent_clazz, |  1356       env, MotionEvent_clazz(env), | 
|  1349       "getYPrecision", |  1357       "getYPrecision", | 
|  1350       "()F", |  1358       "()F", | 
|  1351       &g_MotionEvent_getYPrecision); |  1359       &g_MotionEvent_getYPrecision); | 
|  1352  |  1360  | 
|  1353   jfloat ret = |  1361   jfloat ret = | 
|  1354       env->CallFloatMethod(obj, |  1362       env->CallFloatMethod(obj, | 
|  1355           method_id); |  1363           method_id); | 
|  1356   jni_generator::CheckException(env); |  1364   jni_generator::CheckException(env); | 
|  1357   return ret; |  1365   return ret; | 
|  1358 } |  1366 } | 
|  1359  |  1367  | 
|  1360 static base::subtle::AtomicWord g_MotionEvent_getHistorySize = 0; |  1368 static base::subtle::AtomicWord g_MotionEvent_getHistorySize = 0; | 
|  1361 static jint Java_MotionEvent_getHistorySize(JNIEnv* env, jobject obj) |  1369 static jint Java_MotionEvent_getHistorySize(JNIEnv* env, jobject obj) | 
|  1362     __attribute__ ((unused)); |  1370     __attribute__ ((unused)); | 
|  1363 static jint Java_MotionEvent_getHistorySize(JNIEnv* env, jobject obj) { |  1371 static jint Java_MotionEvent_getHistorySize(JNIEnv* env, jobject obj) { | 
|  1364   /* Must call RegisterNativesImpl()  */ |  1372   /* Must call RegisterNativesImpl()  */ | 
|  1365   CHECK_CLAZZ(env, obj, |  1373   CHECK_CLAZZ(env, obj, | 
|  1366       g_MotionEvent_clazz, 0); |  1374       MotionEvent_clazz(env), 0); | 
|  1367   jmethodID method_id = |  1375   jmethodID method_id = | 
|  1368       base::android::MethodID::LazyGet< |  1376       base::android::MethodID::LazyGet< | 
|  1369       base::android::MethodID::TYPE_INSTANCE>( |  1377       base::android::MethodID::TYPE_INSTANCE>( | 
|  1370       env, g_MotionEvent_clazz, |  1378       env, MotionEvent_clazz(env), | 
|  1371       "getHistorySize", |  1379       "getHistorySize", | 
|  1372       "()I", |  1380       "()I", | 
|  1373       &g_MotionEvent_getHistorySize); |  1381       &g_MotionEvent_getHistorySize); | 
|  1374  |  1382  | 
|  1375   jint ret = |  1383   jint ret = | 
|  1376       env->CallIntMethod(obj, |  1384       env->CallIntMethod(obj, | 
|  1377           method_id); |  1385           method_id); | 
|  1378   jni_generator::CheckException(env); |  1386   jni_generator::CheckException(env); | 
|  1379   return ret; |  1387   return ret; | 
|  1380 } |  1388 } | 
|  1381  |  1389  | 
|  1382 static base::subtle::AtomicWord g_MotionEvent_getHistoricalEventTime = 0; |  1390 static base::subtle::AtomicWord g_MotionEvent_getHistoricalEventTime = 0; | 
|  1383 static jlong Java_MotionEvent_getHistoricalEventTime(JNIEnv* env, jobject obj, |  1391 static jlong Java_MotionEvent_getHistoricalEventTime(JNIEnv* env, jobject obj, | 
|  1384     JniIntWrapper p0) __attribute__ ((unused)); |  1392     JniIntWrapper p0) __attribute__ ((unused)); | 
|  1385 static jlong Java_MotionEvent_getHistoricalEventTime(JNIEnv* env, jobject obj, |  1393 static jlong Java_MotionEvent_getHistoricalEventTime(JNIEnv* env, jobject obj, | 
|  1386     JniIntWrapper p0) { |  1394     JniIntWrapper p0) { | 
|  1387   /* Must call RegisterNativesImpl()  */ |  1395   /* Must call RegisterNativesImpl()  */ | 
|  1388   CHECK_CLAZZ(env, obj, |  1396   CHECK_CLAZZ(env, obj, | 
|  1389       g_MotionEvent_clazz, 0); |  1397       MotionEvent_clazz(env), 0); | 
|  1390   jmethodID method_id = |  1398   jmethodID method_id = | 
|  1391       base::android::MethodID::LazyGet< |  1399       base::android::MethodID::LazyGet< | 
|  1392       base::android::MethodID::TYPE_INSTANCE>( |  1400       base::android::MethodID::TYPE_INSTANCE>( | 
|  1393       env, g_MotionEvent_clazz, |  1401       env, MotionEvent_clazz(env), | 
|  1394       "getHistoricalEventTime", |  1402       "getHistoricalEventTime", | 
|  1395       "(I)J", |  1403       "(I)J", | 
|  1396       &g_MotionEvent_getHistoricalEventTime); |  1404       &g_MotionEvent_getHistoricalEventTime); | 
|  1397  |  1405  | 
|  1398   jlong ret = |  1406   jlong ret = | 
|  1399       env->CallLongMethod(obj, |  1407       env->CallLongMethod(obj, | 
|  1400           method_id, as_jint(p0)); |  1408           method_id, as_jint(p0)); | 
|  1401   jni_generator::CheckException(env); |  1409   jni_generator::CheckException(env); | 
|  1402   return ret; |  1410   return ret; | 
|  1403 } |  1411 } | 
|  1404  |  1412  | 
|  1405 static base::subtle::AtomicWord g_MotionEvent_getHistoricalXF_I = 0; |  1413 static base::subtle::AtomicWord g_MotionEvent_getHistoricalXF_I = 0; | 
|  1406 static jfloat Java_MotionEvent_getHistoricalXF_I(JNIEnv* env, jobject obj, |  1414 static jfloat Java_MotionEvent_getHistoricalXF_I(JNIEnv* env, jobject obj, | 
|  1407     JniIntWrapper p0) __attribute__ ((unused)); |  1415     JniIntWrapper p0) __attribute__ ((unused)); | 
|  1408 static jfloat Java_MotionEvent_getHistoricalXF_I(JNIEnv* env, jobject obj, |  1416 static jfloat Java_MotionEvent_getHistoricalXF_I(JNIEnv* env, jobject obj, | 
|  1409     JniIntWrapper p0) { |  1417     JniIntWrapper p0) { | 
|  1410   /* Must call RegisterNativesImpl()  */ |  1418   /* Must call RegisterNativesImpl()  */ | 
|  1411   CHECK_CLAZZ(env, obj, |  1419   CHECK_CLAZZ(env, obj, | 
|  1412       g_MotionEvent_clazz, 0); |  1420       MotionEvent_clazz(env), 0); | 
|  1413   jmethodID method_id = |  1421   jmethodID method_id = | 
|  1414       base::android::MethodID::LazyGet< |  1422       base::android::MethodID::LazyGet< | 
|  1415       base::android::MethodID::TYPE_INSTANCE>( |  1423       base::android::MethodID::TYPE_INSTANCE>( | 
|  1416       env, g_MotionEvent_clazz, |  1424       env, MotionEvent_clazz(env), | 
|  1417       "getHistoricalX", |  1425       "getHistoricalX", | 
|  1418       "(I)F", |  1426       "(I)F", | 
|  1419       &g_MotionEvent_getHistoricalXF_I); |  1427       &g_MotionEvent_getHistoricalXF_I); | 
|  1420  |  1428  | 
|  1421   jfloat ret = |  1429   jfloat ret = | 
|  1422       env->CallFloatMethod(obj, |  1430       env->CallFloatMethod(obj, | 
|  1423           method_id, as_jint(p0)); |  1431           method_id, as_jint(p0)); | 
|  1424   jni_generator::CheckException(env); |  1432   jni_generator::CheckException(env); | 
|  1425   return ret; |  1433   return ret; | 
|  1426 } |  1434 } | 
|  1427  |  1435  | 
|  1428 static base::subtle::AtomicWord g_MotionEvent_getHistoricalYF_I = 0; |  1436 static base::subtle::AtomicWord g_MotionEvent_getHistoricalYF_I = 0; | 
|  1429 static jfloat Java_MotionEvent_getHistoricalYF_I(JNIEnv* env, jobject obj, |  1437 static jfloat Java_MotionEvent_getHistoricalYF_I(JNIEnv* env, jobject obj, | 
|  1430     JniIntWrapper p0) __attribute__ ((unused)); |  1438     JniIntWrapper p0) __attribute__ ((unused)); | 
|  1431 static jfloat Java_MotionEvent_getHistoricalYF_I(JNIEnv* env, jobject obj, |  1439 static jfloat Java_MotionEvent_getHistoricalYF_I(JNIEnv* env, jobject obj, | 
|  1432     JniIntWrapper p0) { |  1440     JniIntWrapper p0) { | 
|  1433   /* Must call RegisterNativesImpl()  */ |  1441   /* Must call RegisterNativesImpl()  */ | 
|  1434   CHECK_CLAZZ(env, obj, |  1442   CHECK_CLAZZ(env, obj, | 
|  1435       g_MotionEvent_clazz, 0); |  1443       MotionEvent_clazz(env), 0); | 
|  1436   jmethodID method_id = |  1444   jmethodID method_id = | 
|  1437       base::android::MethodID::LazyGet< |  1445       base::android::MethodID::LazyGet< | 
|  1438       base::android::MethodID::TYPE_INSTANCE>( |  1446       base::android::MethodID::TYPE_INSTANCE>( | 
|  1439       env, g_MotionEvent_clazz, |  1447       env, MotionEvent_clazz(env), | 
|  1440       "getHistoricalY", |  1448       "getHistoricalY", | 
|  1441       "(I)F", |  1449       "(I)F", | 
|  1442       &g_MotionEvent_getHistoricalYF_I); |  1450       &g_MotionEvent_getHistoricalYF_I); | 
|  1443  |  1451  | 
|  1444   jfloat ret = |  1452   jfloat ret = | 
|  1445       env->CallFloatMethod(obj, |  1453       env->CallFloatMethod(obj, | 
|  1446           method_id, as_jint(p0)); |  1454           method_id, as_jint(p0)); | 
|  1447   jni_generator::CheckException(env); |  1455   jni_generator::CheckException(env); | 
|  1448   return ret; |  1456   return ret; | 
|  1449 } |  1457 } | 
|  1450  |  1458  | 
|  1451 static base::subtle::AtomicWord g_MotionEvent_getHistoricalPressureF_I = 0; |  1459 static base::subtle::AtomicWord g_MotionEvent_getHistoricalPressureF_I = 0; | 
|  1452 static jfloat Java_MotionEvent_getHistoricalPressureF_I(JNIEnv* env, jobject |  1460 static jfloat Java_MotionEvent_getHistoricalPressureF_I(JNIEnv* env, jobject | 
|  1453     obj, JniIntWrapper p0) __attribute__ ((unused)); |  1461     obj, JniIntWrapper p0) __attribute__ ((unused)); | 
|  1454 static jfloat Java_MotionEvent_getHistoricalPressureF_I(JNIEnv* env, jobject |  1462 static jfloat Java_MotionEvent_getHistoricalPressureF_I(JNIEnv* env, jobject | 
|  1455     obj, JniIntWrapper p0) { |  1463     obj, JniIntWrapper p0) { | 
|  1456   /* Must call RegisterNativesImpl()  */ |  1464   /* Must call RegisterNativesImpl()  */ | 
|  1457   CHECK_CLAZZ(env, obj, |  1465   CHECK_CLAZZ(env, obj, | 
|  1458       g_MotionEvent_clazz, 0); |  1466       MotionEvent_clazz(env), 0); | 
|  1459   jmethodID method_id = |  1467   jmethodID method_id = | 
|  1460       base::android::MethodID::LazyGet< |  1468       base::android::MethodID::LazyGet< | 
|  1461       base::android::MethodID::TYPE_INSTANCE>( |  1469       base::android::MethodID::TYPE_INSTANCE>( | 
|  1462       env, g_MotionEvent_clazz, |  1470       env, MotionEvent_clazz(env), | 
|  1463       "getHistoricalPressure", |  1471       "getHistoricalPressure", | 
|  1464       "(I)F", |  1472       "(I)F", | 
|  1465       &g_MotionEvent_getHistoricalPressureF_I); |  1473       &g_MotionEvent_getHistoricalPressureF_I); | 
|  1466  |  1474  | 
|  1467   jfloat ret = |  1475   jfloat ret = | 
|  1468       env->CallFloatMethod(obj, |  1476       env->CallFloatMethod(obj, | 
|  1469           method_id, as_jint(p0)); |  1477           method_id, as_jint(p0)); | 
|  1470   jni_generator::CheckException(env); |  1478   jni_generator::CheckException(env); | 
|  1471   return ret; |  1479   return ret; | 
|  1472 } |  1480 } | 
|  1473  |  1481  | 
|  1474 static base::subtle::AtomicWord g_MotionEvent_getHistoricalSizeF_I = 0; |  1482 static base::subtle::AtomicWord g_MotionEvent_getHistoricalSizeF_I = 0; | 
|  1475 static jfloat Java_MotionEvent_getHistoricalSizeF_I(JNIEnv* env, jobject obj, |  1483 static jfloat Java_MotionEvent_getHistoricalSizeF_I(JNIEnv* env, jobject obj, | 
|  1476     JniIntWrapper p0) __attribute__ ((unused)); |  1484     JniIntWrapper p0) __attribute__ ((unused)); | 
|  1477 static jfloat Java_MotionEvent_getHistoricalSizeF_I(JNIEnv* env, jobject obj, |  1485 static jfloat Java_MotionEvent_getHistoricalSizeF_I(JNIEnv* env, jobject obj, | 
|  1478     JniIntWrapper p0) { |  1486     JniIntWrapper p0) { | 
|  1479   /* Must call RegisterNativesImpl()  */ |  1487   /* Must call RegisterNativesImpl()  */ | 
|  1480   CHECK_CLAZZ(env, obj, |  1488   CHECK_CLAZZ(env, obj, | 
|  1481       g_MotionEvent_clazz, 0); |  1489       MotionEvent_clazz(env), 0); | 
|  1482   jmethodID method_id = |  1490   jmethodID method_id = | 
|  1483       base::android::MethodID::LazyGet< |  1491       base::android::MethodID::LazyGet< | 
|  1484       base::android::MethodID::TYPE_INSTANCE>( |  1492       base::android::MethodID::TYPE_INSTANCE>( | 
|  1485       env, g_MotionEvent_clazz, |  1493       env, MotionEvent_clazz(env), | 
|  1486       "getHistoricalSize", |  1494       "getHistoricalSize", | 
|  1487       "(I)F", |  1495       "(I)F", | 
|  1488       &g_MotionEvent_getHistoricalSizeF_I); |  1496       &g_MotionEvent_getHistoricalSizeF_I); | 
|  1489  |  1497  | 
|  1490   jfloat ret = |  1498   jfloat ret = | 
|  1491       env->CallFloatMethod(obj, |  1499       env->CallFloatMethod(obj, | 
|  1492           method_id, as_jint(p0)); |  1500           method_id, as_jint(p0)); | 
|  1493   jni_generator::CheckException(env); |  1501   jni_generator::CheckException(env); | 
|  1494   return ret; |  1502   return ret; | 
|  1495 } |  1503 } | 
|  1496  |  1504  | 
|  1497 static base::subtle::AtomicWord g_MotionEvent_getHistoricalTouchMajorF_I = 0; |  1505 static base::subtle::AtomicWord g_MotionEvent_getHistoricalTouchMajorF_I = 0; | 
|  1498 static jfloat Java_MotionEvent_getHistoricalTouchMajorF_I(JNIEnv* env, jobject |  1506 static jfloat Java_MotionEvent_getHistoricalTouchMajorF_I(JNIEnv* env, jobject | 
|  1499     obj, JniIntWrapper p0) __attribute__ ((unused)); |  1507     obj, JniIntWrapper p0) __attribute__ ((unused)); | 
|  1500 static jfloat Java_MotionEvent_getHistoricalTouchMajorF_I(JNIEnv* env, jobject |  1508 static jfloat Java_MotionEvent_getHistoricalTouchMajorF_I(JNIEnv* env, jobject | 
|  1501     obj, JniIntWrapper p0) { |  1509     obj, JniIntWrapper p0) { | 
|  1502   /* Must call RegisterNativesImpl()  */ |  1510   /* Must call RegisterNativesImpl()  */ | 
|  1503   CHECK_CLAZZ(env, obj, |  1511   CHECK_CLAZZ(env, obj, | 
|  1504       g_MotionEvent_clazz, 0); |  1512       MotionEvent_clazz(env), 0); | 
|  1505   jmethodID method_id = |  1513   jmethodID method_id = | 
|  1506       base::android::MethodID::LazyGet< |  1514       base::android::MethodID::LazyGet< | 
|  1507       base::android::MethodID::TYPE_INSTANCE>( |  1515       base::android::MethodID::TYPE_INSTANCE>( | 
|  1508       env, g_MotionEvent_clazz, |  1516       env, MotionEvent_clazz(env), | 
|  1509       "getHistoricalTouchMajor", |  1517       "getHistoricalTouchMajor", | 
|  1510       "(I)F", |  1518       "(I)F", | 
|  1511       &g_MotionEvent_getHistoricalTouchMajorF_I); |  1519       &g_MotionEvent_getHistoricalTouchMajorF_I); | 
|  1512  |  1520  | 
|  1513   jfloat ret = |  1521   jfloat ret = | 
|  1514       env->CallFloatMethod(obj, |  1522       env->CallFloatMethod(obj, | 
|  1515           method_id, as_jint(p0)); |  1523           method_id, as_jint(p0)); | 
|  1516   jni_generator::CheckException(env); |  1524   jni_generator::CheckException(env); | 
|  1517   return ret; |  1525   return ret; | 
|  1518 } |  1526 } | 
|  1519  |  1527  | 
|  1520 static base::subtle::AtomicWord g_MotionEvent_getHistoricalTouchMinorF_I = 0; |  1528 static base::subtle::AtomicWord g_MotionEvent_getHistoricalTouchMinorF_I = 0; | 
|  1521 static jfloat Java_MotionEvent_getHistoricalTouchMinorF_I(JNIEnv* env, jobject |  1529 static jfloat Java_MotionEvent_getHistoricalTouchMinorF_I(JNIEnv* env, jobject | 
|  1522     obj, JniIntWrapper p0) __attribute__ ((unused)); |  1530     obj, JniIntWrapper p0) __attribute__ ((unused)); | 
|  1523 static jfloat Java_MotionEvent_getHistoricalTouchMinorF_I(JNIEnv* env, jobject |  1531 static jfloat Java_MotionEvent_getHistoricalTouchMinorF_I(JNIEnv* env, jobject | 
|  1524     obj, JniIntWrapper p0) { |  1532     obj, JniIntWrapper p0) { | 
|  1525   /* Must call RegisterNativesImpl()  */ |  1533   /* Must call RegisterNativesImpl()  */ | 
|  1526   CHECK_CLAZZ(env, obj, |  1534   CHECK_CLAZZ(env, obj, | 
|  1527       g_MotionEvent_clazz, 0); |  1535       MotionEvent_clazz(env), 0); | 
|  1528   jmethodID method_id = |  1536   jmethodID method_id = | 
|  1529       base::android::MethodID::LazyGet< |  1537       base::android::MethodID::LazyGet< | 
|  1530       base::android::MethodID::TYPE_INSTANCE>( |  1538       base::android::MethodID::TYPE_INSTANCE>( | 
|  1531       env, g_MotionEvent_clazz, |  1539       env, MotionEvent_clazz(env), | 
|  1532       "getHistoricalTouchMinor", |  1540       "getHistoricalTouchMinor", | 
|  1533       "(I)F", |  1541       "(I)F", | 
|  1534       &g_MotionEvent_getHistoricalTouchMinorF_I); |  1542       &g_MotionEvent_getHistoricalTouchMinorF_I); | 
|  1535  |  1543  | 
|  1536   jfloat ret = |  1544   jfloat ret = | 
|  1537       env->CallFloatMethod(obj, |  1545       env->CallFloatMethod(obj, | 
|  1538           method_id, as_jint(p0)); |  1546           method_id, as_jint(p0)); | 
|  1539   jni_generator::CheckException(env); |  1547   jni_generator::CheckException(env); | 
|  1540   return ret; |  1548   return ret; | 
|  1541 } |  1549 } | 
|  1542  |  1550  | 
|  1543 static base::subtle::AtomicWord g_MotionEvent_getHistoricalToolMajorF_I = 0; |  1551 static base::subtle::AtomicWord g_MotionEvent_getHistoricalToolMajorF_I = 0; | 
|  1544 static jfloat Java_MotionEvent_getHistoricalToolMajorF_I(JNIEnv* env, jobject |  1552 static jfloat Java_MotionEvent_getHistoricalToolMajorF_I(JNIEnv* env, jobject | 
|  1545     obj, JniIntWrapper p0) __attribute__ ((unused)); |  1553     obj, JniIntWrapper p0) __attribute__ ((unused)); | 
|  1546 static jfloat Java_MotionEvent_getHistoricalToolMajorF_I(JNIEnv* env, jobject |  1554 static jfloat Java_MotionEvent_getHistoricalToolMajorF_I(JNIEnv* env, jobject | 
|  1547     obj, JniIntWrapper p0) { |  1555     obj, JniIntWrapper p0) { | 
|  1548   /* Must call RegisterNativesImpl()  */ |  1556   /* Must call RegisterNativesImpl()  */ | 
|  1549   CHECK_CLAZZ(env, obj, |  1557   CHECK_CLAZZ(env, obj, | 
|  1550       g_MotionEvent_clazz, 0); |  1558       MotionEvent_clazz(env), 0); | 
|  1551   jmethodID method_id = |  1559   jmethodID method_id = | 
|  1552       base::android::MethodID::LazyGet< |  1560       base::android::MethodID::LazyGet< | 
|  1553       base::android::MethodID::TYPE_INSTANCE>( |  1561       base::android::MethodID::TYPE_INSTANCE>( | 
|  1554       env, g_MotionEvent_clazz, |  1562       env, MotionEvent_clazz(env), | 
|  1555       "getHistoricalToolMajor", |  1563       "getHistoricalToolMajor", | 
|  1556       "(I)F", |  1564       "(I)F", | 
|  1557       &g_MotionEvent_getHistoricalToolMajorF_I); |  1565       &g_MotionEvent_getHistoricalToolMajorF_I); | 
|  1558  |  1566  | 
|  1559   jfloat ret = |  1567   jfloat ret = | 
|  1560       env->CallFloatMethod(obj, |  1568       env->CallFloatMethod(obj, | 
|  1561           method_id, as_jint(p0)); |  1569           method_id, as_jint(p0)); | 
|  1562   jni_generator::CheckException(env); |  1570   jni_generator::CheckException(env); | 
|  1563   return ret; |  1571   return ret; | 
|  1564 } |  1572 } | 
|  1565  |  1573  | 
|  1566 static base::subtle::AtomicWord g_MotionEvent_getHistoricalToolMinorF_I = 0; |  1574 static base::subtle::AtomicWord g_MotionEvent_getHistoricalToolMinorF_I = 0; | 
|  1567 static jfloat Java_MotionEvent_getHistoricalToolMinorF_I(JNIEnv* env, jobject |  1575 static jfloat Java_MotionEvent_getHistoricalToolMinorF_I(JNIEnv* env, jobject | 
|  1568     obj, JniIntWrapper p0) __attribute__ ((unused)); |  1576     obj, JniIntWrapper p0) __attribute__ ((unused)); | 
|  1569 static jfloat Java_MotionEvent_getHistoricalToolMinorF_I(JNIEnv* env, jobject |  1577 static jfloat Java_MotionEvent_getHistoricalToolMinorF_I(JNIEnv* env, jobject | 
|  1570     obj, JniIntWrapper p0) { |  1578     obj, JniIntWrapper p0) { | 
|  1571   /* Must call RegisterNativesImpl()  */ |  1579   /* Must call RegisterNativesImpl()  */ | 
|  1572   CHECK_CLAZZ(env, obj, |  1580   CHECK_CLAZZ(env, obj, | 
|  1573       g_MotionEvent_clazz, 0); |  1581       MotionEvent_clazz(env), 0); | 
|  1574   jmethodID method_id = |  1582   jmethodID method_id = | 
|  1575       base::android::MethodID::LazyGet< |  1583       base::android::MethodID::LazyGet< | 
|  1576       base::android::MethodID::TYPE_INSTANCE>( |  1584       base::android::MethodID::TYPE_INSTANCE>( | 
|  1577       env, g_MotionEvent_clazz, |  1585       env, MotionEvent_clazz(env), | 
|  1578       "getHistoricalToolMinor", |  1586       "getHistoricalToolMinor", | 
|  1579       "(I)F", |  1587       "(I)F", | 
|  1580       &g_MotionEvent_getHistoricalToolMinorF_I); |  1588       &g_MotionEvent_getHistoricalToolMinorF_I); | 
|  1581  |  1589  | 
|  1582   jfloat ret = |  1590   jfloat ret = | 
|  1583       env->CallFloatMethod(obj, |  1591       env->CallFloatMethod(obj, | 
|  1584           method_id, as_jint(p0)); |  1592           method_id, as_jint(p0)); | 
|  1585   jni_generator::CheckException(env); |  1593   jni_generator::CheckException(env); | 
|  1586   return ret; |  1594   return ret; | 
|  1587 } |  1595 } | 
|  1588  |  1596  | 
|  1589 static base::subtle::AtomicWord g_MotionEvent_getHistoricalOrientationF_I = 0; |  1597 static base::subtle::AtomicWord g_MotionEvent_getHistoricalOrientationF_I = 0; | 
|  1590 static jfloat Java_MotionEvent_getHistoricalOrientationF_I(JNIEnv* env, jobject |  1598 static jfloat Java_MotionEvent_getHistoricalOrientationF_I(JNIEnv* env, jobject | 
|  1591     obj, JniIntWrapper p0) __attribute__ ((unused)); |  1599     obj, JniIntWrapper p0) __attribute__ ((unused)); | 
|  1592 static jfloat Java_MotionEvent_getHistoricalOrientationF_I(JNIEnv* env, jobject |  1600 static jfloat Java_MotionEvent_getHistoricalOrientationF_I(JNIEnv* env, jobject | 
|  1593     obj, JniIntWrapper p0) { |  1601     obj, JniIntWrapper p0) { | 
|  1594   /* Must call RegisterNativesImpl()  */ |  1602   /* Must call RegisterNativesImpl()  */ | 
|  1595   CHECK_CLAZZ(env, obj, |  1603   CHECK_CLAZZ(env, obj, | 
|  1596       g_MotionEvent_clazz, 0); |  1604       MotionEvent_clazz(env), 0); | 
|  1597   jmethodID method_id = |  1605   jmethodID method_id = | 
|  1598       base::android::MethodID::LazyGet< |  1606       base::android::MethodID::LazyGet< | 
|  1599       base::android::MethodID::TYPE_INSTANCE>( |  1607       base::android::MethodID::TYPE_INSTANCE>( | 
|  1600       env, g_MotionEvent_clazz, |  1608       env, MotionEvent_clazz(env), | 
|  1601       "getHistoricalOrientation", |  1609       "getHistoricalOrientation", | 
|  1602       "(I)F", |  1610       "(I)F", | 
|  1603       &g_MotionEvent_getHistoricalOrientationF_I); |  1611       &g_MotionEvent_getHistoricalOrientationF_I); | 
|  1604  |  1612  | 
|  1605   jfloat ret = |  1613   jfloat ret = | 
|  1606       env->CallFloatMethod(obj, |  1614       env->CallFloatMethod(obj, | 
|  1607           method_id, as_jint(p0)); |  1615           method_id, as_jint(p0)); | 
|  1608   jni_generator::CheckException(env); |  1616   jni_generator::CheckException(env); | 
|  1609   return ret; |  1617   return ret; | 
|  1610 } |  1618 } | 
|  1611  |  1619  | 
|  1612 static base::subtle::AtomicWord g_MotionEvent_getHistoricalAxisValueF_I_I = 0; |  1620 static base::subtle::AtomicWord g_MotionEvent_getHistoricalAxisValueF_I_I = 0; | 
|  1613 static jfloat Java_MotionEvent_getHistoricalAxisValueF_I_I(JNIEnv* env, jobject |  1621 static jfloat Java_MotionEvent_getHistoricalAxisValueF_I_I(JNIEnv* env, jobject | 
|  1614     obj, JniIntWrapper p0, |  1622     obj, JniIntWrapper p0, | 
|  1615     JniIntWrapper p1) __attribute__ ((unused)); |  1623     JniIntWrapper p1) __attribute__ ((unused)); | 
|  1616 static jfloat Java_MotionEvent_getHistoricalAxisValueF_I_I(JNIEnv* env, jobject |  1624 static jfloat Java_MotionEvent_getHistoricalAxisValueF_I_I(JNIEnv* env, jobject | 
|  1617     obj, JniIntWrapper p0, |  1625     obj, JniIntWrapper p0, | 
|  1618     JniIntWrapper p1) { |  1626     JniIntWrapper p1) { | 
|  1619   /* Must call RegisterNativesImpl()  */ |  1627   /* Must call RegisterNativesImpl()  */ | 
|  1620   CHECK_CLAZZ(env, obj, |  1628   CHECK_CLAZZ(env, obj, | 
|  1621       g_MotionEvent_clazz, 0); |  1629       MotionEvent_clazz(env), 0); | 
|  1622   jmethodID method_id = |  1630   jmethodID method_id = | 
|  1623       base::android::MethodID::LazyGet< |  1631       base::android::MethodID::LazyGet< | 
|  1624       base::android::MethodID::TYPE_INSTANCE>( |  1632       base::android::MethodID::TYPE_INSTANCE>( | 
|  1625       env, g_MotionEvent_clazz, |  1633       env, MotionEvent_clazz(env), | 
|  1626       "getHistoricalAxisValue", |  1634       "getHistoricalAxisValue", | 
|  1627       "(II)F", |  1635       "(II)F", | 
|  1628       &g_MotionEvent_getHistoricalAxisValueF_I_I); |  1636       &g_MotionEvent_getHistoricalAxisValueF_I_I); | 
|  1629  |  1637  | 
|  1630   jfloat ret = |  1638   jfloat ret = | 
|  1631       env->CallFloatMethod(obj, |  1639       env->CallFloatMethod(obj, | 
|  1632           method_id, as_jint(p0), as_jint(p1)); |  1640           method_id, as_jint(p0), as_jint(p1)); | 
|  1633   jni_generator::CheckException(env); |  1641   jni_generator::CheckException(env); | 
|  1634   return ret; |  1642   return ret; | 
|  1635 } |  1643 } | 
|  1636  |  1644  | 
|  1637 static base::subtle::AtomicWord g_MotionEvent_getHistoricalXF_I_I = 0; |  1645 static base::subtle::AtomicWord g_MotionEvent_getHistoricalXF_I_I = 0; | 
|  1638 static jfloat Java_MotionEvent_getHistoricalXF_I_I(JNIEnv* env, jobject obj, |  1646 static jfloat Java_MotionEvent_getHistoricalXF_I_I(JNIEnv* env, jobject obj, | 
|  1639     JniIntWrapper p0, |  1647     JniIntWrapper p0, | 
|  1640     JniIntWrapper p1) __attribute__ ((unused)); |  1648     JniIntWrapper p1) __attribute__ ((unused)); | 
|  1641 static jfloat Java_MotionEvent_getHistoricalXF_I_I(JNIEnv* env, jobject obj, |  1649 static jfloat Java_MotionEvent_getHistoricalXF_I_I(JNIEnv* env, jobject obj, | 
|  1642     JniIntWrapper p0, |  1650     JniIntWrapper p0, | 
|  1643     JniIntWrapper p1) { |  1651     JniIntWrapper p1) { | 
|  1644   /* Must call RegisterNativesImpl()  */ |  1652   /* Must call RegisterNativesImpl()  */ | 
|  1645   CHECK_CLAZZ(env, obj, |  1653   CHECK_CLAZZ(env, obj, | 
|  1646       g_MotionEvent_clazz, 0); |  1654       MotionEvent_clazz(env), 0); | 
|  1647   jmethodID method_id = |  1655   jmethodID method_id = | 
|  1648       base::android::MethodID::LazyGet< |  1656       base::android::MethodID::LazyGet< | 
|  1649       base::android::MethodID::TYPE_INSTANCE>( |  1657       base::android::MethodID::TYPE_INSTANCE>( | 
|  1650       env, g_MotionEvent_clazz, |  1658       env, MotionEvent_clazz(env), | 
|  1651       "getHistoricalX", |  1659       "getHistoricalX", | 
|  1652       "(II)F", |  1660       "(II)F", | 
|  1653       &g_MotionEvent_getHistoricalXF_I_I); |  1661       &g_MotionEvent_getHistoricalXF_I_I); | 
|  1654  |  1662  | 
|  1655   jfloat ret = |  1663   jfloat ret = | 
|  1656       env->CallFloatMethod(obj, |  1664       env->CallFloatMethod(obj, | 
|  1657           method_id, as_jint(p0), as_jint(p1)); |  1665           method_id, as_jint(p0), as_jint(p1)); | 
|  1658   jni_generator::CheckException(env); |  1666   jni_generator::CheckException(env); | 
|  1659   return ret; |  1667   return ret; | 
|  1660 } |  1668 } | 
|  1661  |  1669  | 
|  1662 static base::subtle::AtomicWord g_MotionEvent_getHistoricalYF_I_I = 0; |  1670 static base::subtle::AtomicWord g_MotionEvent_getHistoricalYF_I_I = 0; | 
|  1663 static jfloat Java_MotionEvent_getHistoricalYF_I_I(JNIEnv* env, jobject obj, |  1671 static jfloat Java_MotionEvent_getHistoricalYF_I_I(JNIEnv* env, jobject obj, | 
|  1664     JniIntWrapper p0, |  1672     JniIntWrapper p0, | 
|  1665     JniIntWrapper p1) __attribute__ ((unused)); |  1673     JniIntWrapper p1) __attribute__ ((unused)); | 
|  1666 static jfloat Java_MotionEvent_getHistoricalYF_I_I(JNIEnv* env, jobject obj, |  1674 static jfloat Java_MotionEvent_getHistoricalYF_I_I(JNIEnv* env, jobject obj, | 
|  1667     JniIntWrapper p0, |  1675     JniIntWrapper p0, | 
|  1668     JniIntWrapper p1) { |  1676     JniIntWrapper p1) { | 
|  1669   /* Must call RegisterNativesImpl()  */ |  1677   /* Must call RegisterNativesImpl()  */ | 
|  1670   CHECK_CLAZZ(env, obj, |  1678   CHECK_CLAZZ(env, obj, | 
|  1671       g_MotionEvent_clazz, 0); |  1679       MotionEvent_clazz(env), 0); | 
|  1672   jmethodID method_id = |  1680   jmethodID method_id = | 
|  1673       base::android::MethodID::LazyGet< |  1681       base::android::MethodID::LazyGet< | 
|  1674       base::android::MethodID::TYPE_INSTANCE>( |  1682       base::android::MethodID::TYPE_INSTANCE>( | 
|  1675       env, g_MotionEvent_clazz, |  1683       env, MotionEvent_clazz(env), | 
|  1676       "getHistoricalY", |  1684       "getHistoricalY", | 
|  1677       "(II)F", |  1685       "(II)F", | 
|  1678       &g_MotionEvent_getHistoricalYF_I_I); |  1686       &g_MotionEvent_getHistoricalYF_I_I); | 
|  1679  |  1687  | 
|  1680   jfloat ret = |  1688   jfloat ret = | 
|  1681       env->CallFloatMethod(obj, |  1689       env->CallFloatMethod(obj, | 
|  1682           method_id, as_jint(p0), as_jint(p1)); |  1690           method_id, as_jint(p0), as_jint(p1)); | 
|  1683   jni_generator::CheckException(env); |  1691   jni_generator::CheckException(env); | 
|  1684   return ret; |  1692   return ret; | 
|  1685 } |  1693 } | 
|  1686  |  1694  | 
|  1687 static base::subtle::AtomicWord g_MotionEvent_getHistoricalPressureF_I_I = 0; |  1695 static base::subtle::AtomicWord g_MotionEvent_getHistoricalPressureF_I_I = 0; | 
|  1688 static jfloat Java_MotionEvent_getHistoricalPressureF_I_I(JNIEnv* env, jobject |  1696 static jfloat Java_MotionEvent_getHistoricalPressureF_I_I(JNIEnv* env, jobject | 
|  1689     obj, JniIntWrapper p0, |  1697     obj, JniIntWrapper p0, | 
|  1690     JniIntWrapper p1) __attribute__ ((unused)); |  1698     JniIntWrapper p1) __attribute__ ((unused)); | 
|  1691 static jfloat Java_MotionEvent_getHistoricalPressureF_I_I(JNIEnv* env, jobject |  1699 static jfloat Java_MotionEvent_getHistoricalPressureF_I_I(JNIEnv* env, jobject | 
|  1692     obj, JniIntWrapper p0, |  1700     obj, JniIntWrapper p0, | 
|  1693     JniIntWrapper p1) { |  1701     JniIntWrapper p1) { | 
|  1694   /* Must call RegisterNativesImpl()  */ |  1702   /* Must call RegisterNativesImpl()  */ | 
|  1695   CHECK_CLAZZ(env, obj, |  1703   CHECK_CLAZZ(env, obj, | 
|  1696       g_MotionEvent_clazz, 0); |  1704       MotionEvent_clazz(env), 0); | 
|  1697   jmethodID method_id = |  1705   jmethodID method_id = | 
|  1698       base::android::MethodID::LazyGet< |  1706       base::android::MethodID::LazyGet< | 
|  1699       base::android::MethodID::TYPE_INSTANCE>( |  1707       base::android::MethodID::TYPE_INSTANCE>( | 
|  1700       env, g_MotionEvent_clazz, |  1708       env, MotionEvent_clazz(env), | 
|  1701       "getHistoricalPressure", |  1709       "getHistoricalPressure", | 
|  1702       "(II)F", |  1710       "(II)F", | 
|  1703       &g_MotionEvent_getHistoricalPressureF_I_I); |  1711       &g_MotionEvent_getHistoricalPressureF_I_I); | 
|  1704  |  1712  | 
|  1705   jfloat ret = |  1713   jfloat ret = | 
|  1706       env->CallFloatMethod(obj, |  1714       env->CallFloatMethod(obj, | 
|  1707           method_id, as_jint(p0), as_jint(p1)); |  1715           method_id, as_jint(p0), as_jint(p1)); | 
|  1708   jni_generator::CheckException(env); |  1716   jni_generator::CheckException(env); | 
|  1709   return ret; |  1717   return ret; | 
|  1710 } |  1718 } | 
|  1711  |  1719  | 
|  1712 static base::subtle::AtomicWord g_MotionEvent_getHistoricalSizeF_I_I = 0; |  1720 static base::subtle::AtomicWord g_MotionEvent_getHistoricalSizeF_I_I = 0; | 
|  1713 static jfloat Java_MotionEvent_getHistoricalSizeF_I_I(JNIEnv* env, jobject obj, |  1721 static jfloat Java_MotionEvent_getHistoricalSizeF_I_I(JNIEnv* env, jobject obj, | 
|  1714     JniIntWrapper p0, |  1722     JniIntWrapper p0, | 
|  1715     JniIntWrapper p1) __attribute__ ((unused)); |  1723     JniIntWrapper p1) __attribute__ ((unused)); | 
|  1716 static jfloat Java_MotionEvent_getHistoricalSizeF_I_I(JNIEnv* env, jobject obj, |  1724 static jfloat Java_MotionEvent_getHistoricalSizeF_I_I(JNIEnv* env, jobject obj, | 
|  1717     JniIntWrapper p0, |  1725     JniIntWrapper p0, | 
|  1718     JniIntWrapper p1) { |  1726     JniIntWrapper p1) { | 
|  1719   /* Must call RegisterNativesImpl()  */ |  1727   /* Must call RegisterNativesImpl()  */ | 
|  1720   CHECK_CLAZZ(env, obj, |  1728   CHECK_CLAZZ(env, obj, | 
|  1721       g_MotionEvent_clazz, 0); |  1729       MotionEvent_clazz(env), 0); | 
|  1722   jmethodID method_id = |  1730   jmethodID method_id = | 
|  1723       base::android::MethodID::LazyGet< |  1731       base::android::MethodID::LazyGet< | 
|  1724       base::android::MethodID::TYPE_INSTANCE>( |  1732       base::android::MethodID::TYPE_INSTANCE>( | 
|  1725       env, g_MotionEvent_clazz, |  1733       env, MotionEvent_clazz(env), | 
|  1726       "getHistoricalSize", |  1734       "getHistoricalSize", | 
|  1727       "(II)F", |  1735       "(II)F", | 
|  1728       &g_MotionEvent_getHistoricalSizeF_I_I); |  1736       &g_MotionEvent_getHistoricalSizeF_I_I); | 
|  1729  |  1737  | 
|  1730   jfloat ret = |  1738   jfloat ret = | 
|  1731       env->CallFloatMethod(obj, |  1739       env->CallFloatMethod(obj, | 
|  1732           method_id, as_jint(p0), as_jint(p1)); |  1740           method_id, as_jint(p0), as_jint(p1)); | 
|  1733   jni_generator::CheckException(env); |  1741   jni_generator::CheckException(env); | 
|  1734   return ret; |  1742   return ret; | 
|  1735 } |  1743 } | 
|  1736  |  1744  | 
|  1737 static base::subtle::AtomicWord g_MotionEvent_getHistoricalTouchMajorF_I_I = 0; |  1745 static base::subtle::AtomicWord g_MotionEvent_getHistoricalTouchMajorF_I_I = 0; | 
|  1738 static jfloat Java_MotionEvent_getHistoricalTouchMajorF_I_I(JNIEnv* env, jobject |  1746 static jfloat Java_MotionEvent_getHistoricalTouchMajorF_I_I(JNIEnv* env, jobject | 
|  1739     obj, JniIntWrapper p0, |  1747     obj, JniIntWrapper p0, | 
|  1740     JniIntWrapper p1) __attribute__ ((unused)); |  1748     JniIntWrapper p1) __attribute__ ((unused)); | 
|  1741 static jfloat Java_MotionEvent_getHistoricalTouchMajorF_I_I(JNIEnv* env, jobject |  1749 static jfloat Java_MotionEvent_getHistoricalTouchMajorF_I_I(JNIEnv* env, jobject | 
|  1742     obj, JniIntWrapper p0, |  1750     obj, JniIntWrapper p0, | 
|  1743     JniIntWrapper p1) { |  1751     JniIntWrapper p1) { | 
|  1744   /* Must call RegisterNativesImpl()  */ |  1752   /* Must call RegisterNativesImpl()  */ | 
|  1745   CHECK_CLAZZ(env, obj, |  1753   CHECK_CLAZZ(env, obj, | 
|  1746       g_MotionEvent_clazz, 0); |  1754       MotionEvent_clazz(env), 0); | 
|  1747   jmethodID method_id = |  1755   jmethodID method_id = | 
|  1748       base::android::MethodID::LazyGet< |  1756       base::android::MethodID::LazyGet< | 
|  1749       base::android::MethodID::TYPE_INSTANCE>( |  1757       base::android::MethodID::TYPE_INSTANCE>( | 
|  1750       env, g_MotionEvent_clazz, |  1758       env, MotionEvent_clazz(env), | 
|  1751       "getHistoricalTouchMajor", |  1759       "getHistoricalTouchMajor", | 
|  1752       "(II)F", |  1760       "(II)F", | 
|  1753       &g_MotionEvent_getHistoricalTouchMajorF_I_I); |  1761       &g_MotionEvent_getHistoricalTouchMajorF_I_I); | 
|  1754  |  1762  | 
|  1755   jfloat ret = |  1763   jfloat ret = | 
|  1756       env->CallFloatMethod(obj, |  1764       env->CallFloatMethod(obj, | 
|  1757           method_id, as_jint(p0), as_jint(p1)); |  1765           method_id, as_jint(p0), as_jint(p1)); | 
|  1758   jni_generator::CheckException(env); |  1766   jni_generator::CheckException(env); | 
|  1759   return ret; |  1767   return ret; | 
|  1760 } |  1768 } | 
|  1761  |  1769  | 
|  1762 static base::subtle::AtomicWord g_MotionEvent_getHistoricalTouchMinorF_I_I = 0; |  1770 static base::subtle::AtomicWord g_MotionEvent_getHistoricalTouchMinorF_I_I = 0; | 
|  1763 static jfloat Java_MotionEvent_getHistoricalTouchMinorF_I_I(JNIEnv* env, jobject |  1771 static jfloat Java_MotionEvent_getHistoricalTouchMinorF_I_I(JNIEnv* env, jobject | 
|  1764     obj, JniIntWrapper p0, |  1772     obj, JniIntWrapper p0, | 
|  1765     JniIntWrapper p1) __attribute__ ((unused)); |  1773     JniIntWrapper p1) __attribute__ ((unused)); | 
|  1766 static jfloat Java_MotionEvent_getHistoricalTouchMinorF_I_I(JNIEnv* env, jobject |  1774 static jfloat Java_MotionEvent_getHistoricalTouchMinorF_I_I(JNIEnv* env, jobject | 
|  1767     obj, JniIntWrapper p0, |  1775     obj, JniIntWrapper p0, | 
|  1768     JniIntWrapper p1) { |  1776     JniIntWrapper p1) { | 
|  1769   /* Must call RegisterNativesImpl()  */ |  1777   /* Must call RegisterNativesImpl()  */ | 
|  1770   CHECK_CLAZZ(env, obj, |  1778   CHECK_CLAZZ(env, obj, | 
|  1771       g_MotionEvent_clazz, 0); |  1779       MotionEvent_clazz(env), 0); | 
|  1772   jmethodID method_id = |  1780   jmethodID method_id = | 
|  1773       base::android::MethodID::LazyGet< |  1781       base::android::MethodID::LazyGet< | 
|  1774       base::android::MethodID::TYPE_INSTANCE>( |  1782       base::android::MethodID::TYPE_INSTANCE>( | 
|  1775       env, g_MotionEvent_clazz, |  1783       env, MotionEvent_clazz(env), | 
|  1776       "getHistoricalTouchMinor", |  1784       "getHistoricalTouchMinor", | 
|  1777       "(II)F", |  1785       "(II)F", | 
|  1778       &g_MotionEvent_getHistoricalTouchMinorF_I_I); |  1786       &g_MotionEvent_getHistoricalTouchMinorF_I_I); | 
|  1779  |  1787  | 
|  1780   jfloat ret = |  1788   jfloat ret = | 
|  1781       env->CallFloatMethod(obj, |  1789       env->CallFloatMethod(obj, | 
|  1782           method_id, as_jint(p0), as_jint(p1)); |  1790           method_id, as_jint(p0), as_jint(p1)); | 
|  1783   jni_generator::CheckException(env); |  1791   jni_generator::CheckException(env); | 
|  1784   return ret; |  1792   return ret; | 
|  1785 } |  1793 } | 
|  1786  |  1794  | 
|  1787 static base::subtle::AtomicWord g_MotionEvent_getHistoricalToolMajorF_I_I = 0; |  1795 static base::subtle::AtomicWord g_MotionEvent_getHistoricalToolMajorF_I_I = 0; | 
|  1788 static jfloat Java_MotionEvent_getHistoricalToolMajorF_I_I(JNIEnv* env, jobject |  1796 static jfloat Java_MotionEvent_getHistoricalToolMajorF_I_I(JNIEnv* env, jobject | 
|  1789     obj, JniIntWrapper p0, |  1797     obj, JniIntWrapper p0, | 
|  1790     JniIntWrapper p1) __attribute__ ((unused)); |  1798     JniIntWrapper p1) __attribute__ ((unused)); | 
|  1791 static jfloat Java_MotionEvent_getHistoricalToolMajorF_I_I(JNIEnv* env, jobject |  1799 static jfloat Java_MotionEvent_getHistoricalToolMajorF_I_I(JNIEnv* env, jobject | 
|  1792     obj, JniIntWrapper p0, |  1800     obj, JniIntWrapper p0, | 
|  1793     JniIntWrapper p1) { |  1801     JniIntWrapper p1) { | 
|  1794   /* Must call RegisterNativesImpl()  */ |  1802   /* Must call RegisterNativesImpl()  */ | 
|  1795   CHECK_CLAZZ(env, obj, |  1803   CHECK_CLAZZ(env, obj, | 
|  1796       g_MotionEvent_clazz, 0); |  1804       MotionEvent_clazz(env), 0); | 
|  1797   jmethodID method_id = |  1805   jmethodID method_id = | 
|  1798       base::android::MethodID::LazyGet< |  1806       base::android::MethodID::LazyGet< | 
|  1799       base::android::MethodID::TYPE_INSTANCE>( |  1807       base::android::MethodID::TYPE_INSTANCE>( | 
|  1800       env, g_MotionEvent_clazz, |  1808       env, MotionEvent_clazz(env), | 
|  1801       "getHistoricalToolMajor", |  1809       "getHistoricalToolMajor", | 
|  1802       "(II)F", |  1810       "(II)F", | 
|  1803       &g_MotionEvent_getHistoricalToolMajorF_I_I); |  1811       &g_MotionEvent_getHistoricalToolMajorF_I_I); | 
|  1804  |  1812  | 
|  1805   jfloat ret = |  1813   jfloat ret = | 
|  1806       env->CallFloatMethod(obj, |  1814       env->CallFloatMethod(obj, | 
|  1807           method_id, as_jint(p0), as_jint(p1)); |  1815           method_id, as_jint(p0), as_jint(p1)); | 
|  1808   jni_generator::CheckException(env); |  1816   jni_generator::CheckException(env); | 
|  1809   return ret; |  1817   return ret; | 
|  1810 } |  1818 } | 
|  1811  |  1819  | 
|  1812 static base::subtle::AtomicWord g_MotionEvent_getHistoricalToolMinorF_I_I = 0; |  1820 static base::subtle::AtomicWord g_MotionEvent_getHistoricalToolMinorF_I_I = 0; | 
|  1813 static jfloat Java_MotionEvent_getHistoricalToolMinorF_I_I(JNIEnv* env, jobject |  1821 static jfloat Java_MotionEvent_getHistoricalToolMinorF_I_I(JNIEnv* env, jobject | 
|  1814     obj, JniIntWrapper p0, |  1822     obj, JniIntWrapper p0, | 
|  1815     JniIntWrapper p1) __attribute__ ((unused)); |  1823     JniIntWrapper p1) __attribute__ ((unused)); | 
|  1816 static jfloat Java_MotionEvent_getHistoricalToolMinorF_I_I(JNIEnv* env, jobject |  1824 static jfloat Java_MotionEvent_getHistoricalToolMinorF_I_I(JNIEnv* env, jobject | 
|  1817     obj, JniIntWrapper p0, |  1825     obj, JniIntWrapper p0, | 
|  1818     JniIntWrapper p1) { |  1826     JniIntWrapper p1) { | 
|  1819   /* Must call RegisterNativesImpl()  */ |  1827   /* Must call RegisterNativesImpl()  */ | 
|  1820   CHECK_CLAZZ(env, obj, |  1828   CHECK_CLAZZ(env, obj, | 
|  1821       g_MotionEvent_clazz, 0); |  1829       MotionEvent_clazz(env), 0); | 
|  1822   jmethodID method_id = |  1830   jmethodID method_id = | 
|  1823       base::android::MethodID::LazyGet< |  1831       base::android::MethodID::LazyGet< | 
|  1824       base::android::MethodID::TYPE_INSTANCE>( |  1832       base::android::MethodID::TYPE_INSTANCE>( | 
|  1825       env, g_MotionEvent_clazz, |  1833       env, MotionEvent_clazz(env), | 
|  1826       "getHistoricalToolMinor", |  1834       "getHistoricalToolMinor", | 
|  1827       "(II)F", |  1835       "(II)F", | 
|  1828       &g_MotionEvent_getHistoricalToolMinorF_I_I); |  1836       &g_MotionEvent_getHistoricalToolMinorF_I_I); | 
|  1829  |  1837  | 
|  1830   jfloat ret = |  1838   jfloat ret = | 
|  1831       env->CallFloatMethod(obj, |  1839       env->CallFloatMethod(obj, | 
|  1832           method_id, as_jint(p0), as_jint(p1)); |  1840           method_id, as_jint(p0), as_jint(p1)); | 
|  1833   jni_generator::CheckException(env); |  1841   jni_generator::CheckException(env); | 
|  1834   return ret; |  1842   return ret; | 
|  1835 } |  1843 } | 
|  1836  |  1844  | 
|  1837 static base::subtle::AtomicWord g_MotionEvent_getHistoricalOrientationF_I_I = 0; |  1845 static base::subtle::AtomicWord g_MotionEvent_getHistoricalOrientationF_I_I = 0; | 
|  1838 static jfloat Java_MotionEvent_getHistoricalOrientationF_I_I(JNIEnv* env, |  1846 static jfloat Java_MotionEvent_getHistoricalOrientationF_I_I(JNIEnv* env, | 
|  1839     jobject obj, JniIntWrapper p0, |  1847     jobject obj, JniIntWrapper p0, | 
|  1840     JniIntWrapper p1) __attribute__ ((unused)); |  1848     JniIntWrapper p1) __attribute__ ((unused)); | 
|  1841 static jfloat Java_MotionEvent_getHistoricalOrientationF_I_I(JNIEnv* env, |  1849 static jfloat Java_MotionEvent_getHistoricalOrientationF_I_I(JNIEnv* env, | 
|  1842     jobject obj, JniIntWrapper p0, |  1850     jobject obj, JniIntWrapper p0, | 
|  1843     JniIntWrapper p1) { |  1851     JniIntWrapper p1) { | 
|  1844   /* Must call RegisterNativesImpl()  */ |  1852   /* Must call RegisterNativesImpl()  */ | 
|  1845   CHECK_CLAZZ(env, obj, |  1853   CHECK_CLAZZ(env, obj, | 
|  1846       g_MotionEvent_clazz, 0); |  1854       MotionEvent_clazz(env), 0); | 
|  1847   jmethodID method_id = |  1855   jmethodID method_id = | 
|  1848       base::android::MethodID::LazyGet< |  1856       base::android::MethodID::LazyGet< | 
|  1849       base::android::MethodID::TYPE_INSTANCE>( |  1857       base::android::MethodID::TYPE_INSTANCE>( | 
|  1850       env, g_MotionEvent_clazz, |  1858       env, MotionEvent_clazz(env), | 
|  1851       "getHistoricalOrientation", |  1859       "getHistoricalOrientation", | 
|  1852       "(II)F", |  1860       "(II)F", | 
|  1853       &g_MotionEvent_getHistoricalOrientationF_I_I); |  1861       &g_MotionEvent_getHistoricalOrientationF_I_I); | 
|  1854  |  1862  | 
|  1855   jfloat ret = |  1863   jfloat ret = | 
|  1856       env->CallFloatMethod(obj, |  1864       env->CallFloatMethod(obj, | 
|  1857           method_id, as_jint(p0), as_jint(p1)); |  1865           method_id, as_jint(p0), as_jint(p1)); | 
|  1858   jni_generator::CheckException(env); |  1866   jni_generator::CheckException(env); | 
|  1859   return ret; |  1867   return ret; | 
|  1860 } |  1868 } | 
|  1861  |  1869  | 
|  1862 static base::subtle::AtomicWord g_MotionEvent_getHistoricalAxisValueF_I_I_I = 0; |  1870 static base::subtle::AtomicWord g_MotionEvent_getHistoricalAxisValueF_I_I_I = 0; | 
|  1863 static jfloat Java_MotionEvent_getHistoricalAxisValueF_I_I_I(JNIEnv* env, |  1871 static jfloat Java_MotionEvent_getHistoricalAxisValueF_I_I_I(JNIEnv* env, | 
|  1864     jobject obj, JniIntWrapper p0, |  1872     jobject obj, JniIntWrapper p0, | 
|  1865     JniIntWrapper p1, |  1873     JniIntWrapper p1, | 
|  1866     JniIntWrapper p2) __attribute__ ((unused)); |  1874     JniIntWrapper p2) __attribute__ ((unused)); | 
|  1867 static jfloat Java_MotionEvent_getHistoricalAxisValueF_I_I_I(JNIEnv* env, |  1875 static jfloat Java_MotionEvent_getHistoricalAxisValueF_I_I_I(JNIEnv* env, | 
|  1868     jobject obj, JniIntWrapper p0, |  1876     jobject obj, JniIntWrapper p0, | 
|  1869     JniIntWrapper p1, |  1877     JniIntWrapper p1, | 
|  1870     JniIntWrapper p2) { |  1878     JniIntWrapper p2) { | 
|  1871   /* Must call RegisterNativesImpl()  */ |  1879   /* Must call RegisterNativesImpl()  */ | 
|  1872   CHECK_CLAZZ(env, obj, |  1880   CHECK_CLAZZ(env, obj, | 
|  1873       g_MotionEvent_clazz, 0); |  1881       MotionEvent_clazz(env), 0); | 
|  1874   jmethodID method_id = |  1882   jmethodID method_id = | 
|  1875       base::android::MethodID::LazyGet< |  1883       base::android::MethodID::LazyGet< | 
|  1876       base::android::MethodID::TYPE_INSTANCE>( |  1884       base::android::MethodID::TYPE_INSTANCE>( | 
|  1877       env, g_MotionEvent_clazz, |  1885       env, MotionEvent_clazz(env), | 
|  1878       "getHistoricalAxisValue", |  1886       "getHistoricalAxisValue", | 
|  1879       "(III)F", |  1887       "(III)F", | 
|  1880       &g_MotionEvent_getHistoricalAxisValueF_I_I_I); |  1888       &g_MotionEvent_getHistoricalAxisValueF_I_I_I); | 
|  1881  |  1889  | 
|  1882   jfloat ret = |  1890   jfloat ret = | 
|  1883       env->CallFloatMethod(obj, |  1891       env->CallFloatMethod(obj, | 
|  1884           method_id, as_jint(p0), as_jint(p1), as_jint(p2)); |  1892           method_id, as_jint(p0), as_jint(p1), as_jint(p2)); | 
|  1885   jni_generator::CheckException(env); |  1893   jni_generator::CheckException(env); | 
|  1886   return ret; |  1894   return ret; | 
|  1887 } |  1895 } | 
|  1888  |  1896  | 
|  1889 static base::subtle::AtomicWord g_MotionEvent_getHistoricalPointerCoords = 0; |  1897 static base::subtle::AtomicWord g_MotionEvent_getHistoricalPointerCoords = 0; | 
|  1890 static void Java_MotionEvent_getHistoricalPointerCoords(JNIEnv* env, jobject |  1898 static void Java_MotionEvent_getHistoricalPointerCoords(JNIEnv* env, jobject | 
|  1891     obj, JniIntWrapper p0, |  1899     obj, JniIntWrapper p0, | 
|  1892     JniIntWrapper p1, |  1900     JniIntWrapper p1, | 
|  1893     jobject p2) __attribute__ ((unused)); |  1901     jobject p2) __attribute__ ((unused)); | 
|  1894 static void Java_MotionEvent_getHistoricalPointerCoords(JNIEnv* env, jobject |  1902 static void Java_MotionEvent_getHistoricalPointerCoords(JNIEnv* env, jobject | 
|  1895     obj, JniIntWrapper p0, |  1903     obj, JniIntWrapper p0, | 
|  1896     JniIntWrapper p1, |  1904     JniIntWrapper p1, | 
|  1897     jobject p2) { |  1905     jobject p2) { | 
|  1898   /* Must call RegisterNativesImpl()  */ |  1906   /* Must call RegisterNativesImpl()  */ | 
|  1899   CHECK_CLAZZ(env, obj, |  1907   CHECK_CLAZZ(env, obj, | 
|  1900       g_MotionEvent_clazz); |  1908       MotionEvent_clazz(env)); | 
|  1901   jmethodID method_id = |  1909   jmethodID method_id = | 
|  1902       base::android::MethodID::LazyGet< |  1910       base::android::MethodID::LazyGet< | 
|  1903       base::android::MethodID::TYPE_INSTANCE>( |  1911       base::android::MethodID::TYPE_INSTANCE>( | 
|  1904       env, g_MotionEvent_clazz, |  1912       env, MotionEvent_clazz(env), | 
|  1905       "getHistoricalPointerCoords", |  1913       "getHistoricalPointerCoords", | 
|  1906       "(IILandroid/view/MotionEvent$PointerCoords;)V", |  1914       "(IILandroid/view/MotionEvent$PointerCoords;)V", | 
|  1907       &g_MotionEvent_getHistoricalPointerCoords); |  1915       &g_MotionEvent_getHistoricalPointerCoords); | 
|  1908  |  1916  | 
|  1909      env->CallVoidMethod(obj, |  1917      env->CallVoidMethod(obj, | 
|  1910           method_id, as_jint(p0), as_jint(p1), p2); |  1918           method_id, as_jint(p0), as_jint(p1), p2); | 
|  1911   jni_generator::CheckException(env); |  1919   jni_generator::CheckException(env); | 
|  1912  |  1920  | 
|  1913 } |  1921 } | 
|  1914  |  1922  | 
|  1915 static base::subtle::AtomicWord g_MotionEvent_getEdgeFlags = 0; |  1923 static base::subtle::AtomicWord g_MotionEvent_getEdgeFlags = 0; | 
|  1916 static jint Java_MotionEvent_getEdgeFlags(JNIEnv* env, jobject obj) |  1924 static jint Java_MotionEvent_getEdgeFlags(JNIEnv* env, jobject obj) | 
|  1917     __attribute__ ((unused)); |  1925     __attribute__ ((unused)); | 
|  1918 static jint Java_MotionEvent_getEdgeFlags(JNIEnv* env, jobject obj) { |  1926 static jint Java_MotionEvent_getEdgeFlags(JNIEnv* env, jobject obj) { | 
|  1919   /* Must call RegisterNativesImpl()  */ |  1927   /* Must call RegisterNativesImpl()  */ | 
|  1920   CHECK_CLAZZ(env, obj, |  1928   CHECK_CLAZZ(env, obj, | 
|  1921       g_MotionEvent_clazz, 0); |  1929       MotionEvent_clazz(env), 0); | 
|  1922   jmethodID method_id = |  1930   jmethodID method_id = | 
|  1923       base::android::MethodID::LazyGet< |  1931       base::android::MethodID::LazyGet< | 
|  1924       base::android::MethodID::TYPE_INSTANCE>( |  1932       base::android::MethodID::TYPE_INSTANCE>( | 
|  1925       env, g_MotionEvent_clazz, |  1933       env, MotionEvent_clazz(env), | 
|  1926       "getEdgeFlags", |  1934       "getEdgeFlags", | 
|  1927       "()I", |  1935       "()I", | 
|  1928       &g_MotionEvent_getEdgeFlags); |  1936       &g_MotionEvent_getEdgeFlags); | 
|  1929  |  1937  | 
|  1930   jint ret = |  1938   jint ret = | 
|  1931       env->CallIntMethod(obj, |  1939       env->CallIntMethod(obj, | 
|  1932           method_id); |  1940           method_id); | 
|  1933   jni_generator::CheckException(env); |  1941   jni_generator::CheckException(env); | 
|  1934   return ret; |  1942   return ret; | 
|  1935 } |  1943 } | 
|  1936  |  1944  | 
|  1937 static base::subtle::AtomicWord g_MotionEvent_setEdgeFlags = 0; |  1945 static base::subtle::AtomicWord g_MotionEvent_setEdgeFlags = 0; | 
|  1938 static void Java_MotionEvent_setEdgeFlags(JNIEnv* env, jobject obj, |  1946 static void Java_MotionEvent_setEdgeFlags(JNIEnv* env, jobject obj, | 
|  1939     JniIntWrapper p0) __attribute__ ((unused)); |  1947     JniIntWrapper p0) __attribute__ ((unused)); | 
|  1940 static void Java_MotionEvent_setEdgeFlags(JNIEnv* env, jobject obj, |  1948 static void Java_MotionEvent_setEdgeFlags(JNIEnv* env, jobject obj, | 
|  1941     JniIntWrapper p0) { |  1949     JniIntWrapper p0) { | 
|  1942   /* Must call RegisterNativesImpl()  */ |  1950   /* Must call RegisterNativesImpl()  */ | 
|  1943   CHECK_CLAZZ(env, obj, |  1951   CHECK_CLAZZ(env, obj, | 
|  1944       g_MotionEvent_clazz); |  1952       MotionEvent_clazz(env)); | 
|  1945   jmethodID method_id = |  1953   jmethodID method_id = | 
|  1946       base::android::MethodID::LazyGet< |  1954       base::android::MethodID::LazyGet< | 
|  1947       base::android::MethodID::TYPE_INSTANCE>( |  1955       base::android::MethodID::TYPE_INSTANCE>( | 
|  1948       env, g_MotionEvent_clazz, |  1956       env, MotionEvent_clazz(env), | 
|  1949       "setEdgeFlags", |  1957       "setEdgeFlags", | 
|  1950       "(I)V", |  1958       "(I)V", | 
|  1951       &g_MotionEvent_setEdgeFlags); |  1959       &g_MotionEvent_setEdgeFlags); | 
|  1952  |  1960  | 
|  1953      env->CallVoidMethod(obj, |  1961      env->CallVoidMethod(obj, | 
|  1954           method_id, as_jint(p0)); |  1962           method_id, as_jint(p0)); | 
|  1955   jni_generator::CheckException(env); |  1963   jni_generator::CheckException(env); | 
|  1956  |  1964  | 
|  1957 } |  1965 } | 
|  1958  |  1966  | 
|  1959 static base::subtle::AtomicWord g_MotionEvent_setAction = 0; |  1967 static base::subtle::AtomicWord g_MotionEvent_setAction = 0; | 
|  1960 static void Java_MotionEvent_setAction(JNIEnv* env, jobject obj, JniIntWrapper |  1968 static void Java_MotionEvent_setAction(JNIEnv* env, jobject obj, JniIntWrapper | 
|  1961     p0) __attribute__ ((unused)); |  1969     p0) __attribute__ ((unused)); | 
|  1962 static void Java_MotionEvent_setAction(JNIEnv* env, jobject obj, JniIntWrapper |  1970 static void Java_MotionEvent_setAction(JNIEnv* env, jobject obj, JniIntWrapper | 
|  1963     p0) { |  1971     p0) { | 
|  1964   /* Must call RegisterNativesImpl()  */ |  1972   /* Must call RegisterNativesImpl()  */ | 
|  1965   CHECK_CLAZZ(env, obj, |  1973   CHECK_CLAZZ(env, obj, | 
|  1966       g_MotionEvent_clazz); |  1974       MotionEvent_clazz(env)); | 
|  1967   jmethodID method_id = |  1975   jmethodID method_id = | 
|  1968       base::android::MethodID::LazyGet< |  1976       base::android::MethodID::LazyGet< | 
|  1969       base::android::MethodID::TYPE_INSTANCE>( |  1977       base::android::MethodID::TYPE_INSTANCE>( | 
|  1970       env, g_MotionEvent_clazz, |  1978       env, MotionEvent_clazz(env), | 
|  1971       "setAction", |  1979       "setAction", | 
|  1972       "(I)V", |  1980       "(I)V", | 
|  1973       &g_MotionEvent_setAction); |  1981       &g_MotionEvent_setAction); | 
|  1974  |  1982  | 
|  1975      env->CallVoidMethod(obj, |  1983      env->CallVoidMethod(obj, | 
|  1976           method_id, as_jint(p0)); |  1984           method_id, as_jint(p0)); | 
|  1977   jni_generator::CheckException(env); |  1985   jni_generator::CheckException(env); | 
|  1978  |  1986  | 
|  1979 } |  1987 } | 
|  1980  |  1988  | 
|  1981 static base::subtle::AtomicWord g_MotionEvent_offsetLocation = 0; |  1989 static base::subtle::AtomicWord g_MotionEvent_offsetLocation = 0; | 
|  1982 static void Java_MotionEvent_offsetLocation(JNIEnv* env, jobject obj, jfloat p0, |  1990 static void Java_MotionEvent_offsetLocation(JNIEnv* env, jobject obj, jfloat p0, | 
|  1983     jfloat p1) __attribute__ ((unused)); |  1991     jfloat p1) __attribute__ ((unused)); | 
|  1984 static void Java_MotionEvent_offsetLocation(JNIEnv* env, jobject obj, jfloat p0, |  1992 static void Java_MotionEvent_offsetLocation(JNIEnv* env, jobject obj, jfloat p0, | 
|  1985     jfloat p1) { |  1993     jfloat p1) { | 
|  1986   /* Must call RegisterNativesImpl()  */ |  1994   /* Must call RegisterNativesImpl()  */ | 
|  1987   CHECK_CLAZZ(env, obj, |  1995   CHECK_CLAZZ(env, obj, | 
|  1988       g_MotionEvent_clazz); |  1996       MotionEvent_clazz(env)); | 
|  1989   jmethodID method_id = |  1997   jmethodID method_id = | 
|  1990       base::android::MethodID::LazyGet< |  1998       base::android::MethodID::LazyGet< | 
|  1991       base::android::MethodID::TYPE_INSTANCE>( |  1999       base::android::MethodID::TYPE_INSTANCE>( | 
|  1992       env, g_MotionEvent_clazz, |  2000       env, MotionEvent_clazz(env), | 
|  1993       "offsetLocation", |  2001       "offsetLocation", | 
|  1994       "(FF)V", |  2002       "(FF)V", | 
|  1995       &g_MotionEvent_offsetLocation); |  2003       &g_MotionEvent_offsetLocation); | 
|  1996  |  2004  | 
|  1997      env->CallVoidMethod(obj, |  2005      env->CallVoidMethod(obj, | 
|  1998           method_id, p0, p1); |  2006           method_id, p0, p1); | 
|  1999   jni_generator::CheckException(env); |  2007   jni_generator::CheckException(env); | 
|  2000  |  2008  | 
|  2001 } |  2009 } | 
|  2002  |  2010  | 
|  2003 static base::subtle::AtomicWord g_MotionEvent_setLocation = 0; |  2011 static base::subtle::AtomicWord g_MotionEvent_setLocation = 0; | 
|  2004 static void Java_MotionEvent_setLocation(JNIEnv* env, jobject obj, jfloat p0, |  2012 static void Java_MotionEvent_setLocation(JNIEnv* env, jobject obj, jfloat p0, | 
|  2005     jfloat p1) __attribute__ ((unused)); |  2013     jfloat p1) __attribute__ ((unused)); | 
|  2006 static void Java_MotionEvent_setLocation(JNIEnv* env, jobject obj, jfloat p0, |  2014 static void Java_MotionEvent_setLocation(JNIEnv* env, jobject obj, jfloat p0, | 
|  2007     jfloat p1) { |  2015     jfloat p1) { | 
|  2008   /* Must call RegisterNativesImpl()  */ |  2016   /* Must call RegisterNativesImpl()  */ | 
|  2009   CHECK_CLAZZ(env, obj, |  2017   CHECK_CLAZZ(env, obj, | 
|  2010       g_MotionEvent_clazz); |  2018       MotionEvent_clazz(env)); | 
|  2011   jmethodID method_id = |  2019   jmethodID method_id = | 
|  2012       base::android::MethodID::LazyGet< |  2020       base::android::MethodID::LazyGet< | 
|  2013       base::android::MethodID::TYPE_INSTANCE>( |  2021       base::android::MethodID::TYPE_INSTANCE>( | 
|  2014       env, g_MotionEvent_clazz, |  2022       env, MotionEvent_clazz(env), | 
|  2015       "setLocation", |  2023       "setLocation", | 
|  2016       "(FF)V", |  2024       "(FF)V", | 
|  2017       &g_MotionEvent_setLocation); |  2025       &g_MotionEvent_setLocation); | 
|  2018  |  2026  | 
|  2019      env->CallVoidMethod(obj, |  2027      env->CallVoidMethod(obj, | 
|  2020           method_id, p0, p1); |  2028           method_id, p0, p1); | 
|  2021   jni_generator::CheckException(env); |  2029   jni_generator::CheckException(env); | 
|  2022  |  2030  | 
|  2023 } |  2031 } | 
|  2024  |  2032  | 
|  2025 static base::subtle::AtomicWord g_MotionEvent_transform = 0; |  2033 static base::subtle::AtomicWord g_MotionEvent_transform = 0; | 
|  2026 static void Java_MotionEvent_transform(JNIEnv* env, jobject obj, jobject p0) |  2034 static void Java_MotionEvent_transform(JNIEnv* env, jobject obj, jobject p0) | 
|  2027     __attribute__ ((unused)); |  2035     __attribute__ ((unused)); | 
|  2028 static void Java_MotionEvent_transform(JNIEnv* env, jobject obj, jobject p0) { |  2036 static void Java_MotionEvent_transform(JNIEnv* env, jobject obj, jobject p0) { | 
|  2029   /* Must call RegisterNativesImpl()  */ |  2037   /* Must call RegisterNativesImpl()  */ | 
|  2030   CHECK_CLAZZ(env, obj, |  2038   CHECK_CLAZZ(env, obj, | 
|  2031       g_MotionEvent_clazz); |  2039       MotionEvent_clazz(env)); | 
|  2032   jmethodID method_id = |  2040   jmethodID method_id = | 
|  2033       base::android::MethodID::LazyGet< |  2041       base::android::MethodID::LazyGet< | 
|  2034       base::android::MethodID::TYPE_INSTANCE>( |  2042       base::android::MethodID::TYPE_INSTANCE>( | 
|  2035       env, g_MotionEvent_clazz, |  2043       env, MotionEvent_clazz(env), | 
|  2036       "transform", |  2044       "transform", | 
|  2037       "(Landroid/graphics/Matrix;)V", |  2045       "(Landroid/graphics/Matrix;)V", | 
|  2038       &g_MotionEvent_transform); |  2046       &g_MotionEvent_transform); | 
|  2039  |  2047  | 
|  2040      env->CallVoidMethod(obj, |  2048      env->CallVoidMethod(obj, | 
|  2041           method_id, p0); |  2049           method_id, p0); | 
|  2042   jni_generator::CheckException(env); |  2050   jni_generator::CheckException(env); | 
|  2043  |  2051  | 
|  2044 } |  2052 } | 
|  2045  |  2053  | 
|  2046 static base::subtle::AtomicWord g_MotionEvent_addBatchV_J_F_F_F_F_I = 0; |  2054 static base::subtle::AtomicWord g_MotionEvent_addBatchV_J_F_F_F_F_I = 0; | 
|  2047 static void Java_MotionEvent_addBatchV_J_F_F_F_F_I(JNIEnv* env, jobject obj, |  2055 static void Java_MotionEvent_addBatchV_J_F_F_F_F_I(JNIEnv* env, jobject obj, | 
|  2048     jlong p0, |  2056     jlong p0, | 
|  2049     jfloat p1, |  2057     jfloat p1, | 
|  2050     jfloat p2, |  2058     jfloat p2, | 
|  2051     jfloat p3, |  2059     jfloat p3, | 
|  2052     jfloat p4, |  2060     jfloat p4, | 
|  2053     JniIntWrapper p5) __attribute__ ((unused)); |  2061     JniIntWrapper p5) __attribute__ ((unused)); | 
|  2054 static void Java_MotionEvent_addBatchV_J_F_F_F_F_I(JNIEnv* env, jobject obj, |  2062 static void Java_MotionEvent_addBatchV_J_F_F_F_F_I(JNIEnv* env, jobject obj, | 
|  2055     jlong p0, |  2063     jlong p0, | 
|  2056     jfloat p1, |  2064     jfloat p1, | 
|  2057     jfloat p2, |  2065     jfloat p2, | 
|  2058     jfloat p3, |  2066     jfloat p3, | 
|  2059     jfloat p4, |  2067     jfloat p4, | 
|  2060     JniIntWrapper p5) { |  2068     JniIntWrapper p5) { | 
|  2061   /* Must call RegisterNativesImpl()  */ |  2069   /* Must call RegisterNativesImpl()  */ | 
|  2062   CHECK_CLAZZ(env, obj, |  2070   CHECK_CLAZZ(env, obj, | 
|  2063       g_MotionEvent_clazz); |  2071       MotionEvent_clazz(env)); | 
|  2064   jmethodID method_id = |  2072   jmethodID method_id = | 
|  2065       base::android::MethodID::LazyGet< |  2073       base::android::MethodID::LazyGet< | 
|  2066       base::android::MethodID::TYPE_INSTANCE>( |  2074       base::android::MethodID::TYPE_INSTANCE>( | 
|  2067       env, g_MotionEvent_clazz, |  2075       env, MotionEvent_clazz(env), | 
|  2068       "addBatch", |  2076       "addBatch", | 
|  2069       "(JFFFFI)V", |  2077       "(JFFFFI)V", | 
|  2070       &g_MotionEvent_addBatchV_J_F_F_F_F_I); |  2078       &g_MotionEvent_addBatchV_J_F_F_F_F_I); | 
|  2071  |  2079  | 
|  2072      env->CallVoidMethod(obj, |  2080      env->CallVoidMethod(obj, | 
|  2073           method_id, p0, p1, p2, p3, p4, as_jint(p5)); |  2081           method_id, p0, p1, p2, p3, p4, as_jint(p5)); | 
|  2074   jni_generator::CheckException(env); |  2082   jni_generator::CheckException(env); | 
|  2075  |  2083  | 
|  2076 } |  2084 } | 
|  2077  |  2085  | 
|  2078 static base::subtle::AtomicWord g_MotionEvent_addBatchV_J_LAVMEPC_I = 0; |  2086 static base::subtle::AtomicWord g_MotionEvent_addBatchV_J_LAVMEPC_I = 0; | 
|  2079 static void Java_MotionEvent_addBatchV_J_LAVMEPC_I(JNIEnv* env, jobject obj, |  2087 static void Java_MotionEvent_addBatchV_J_LAVMEPC_I(JNIEnv* env, jobject obj, | 
|  2080     jlong p0, |  2088     jlong p0, | 
|  2081     jobjectArray p1, |  2089     jobjectArray p1, | 
|  2082     JniIntWrapper p2) __attribute__ ((unused)); |  2090     JniIntWrapper p2) __attribute__ ((unused)); | 
|  2083 static void Java_MotionEvent_addBatchV_J_LAVMEPC_I(JNIEnv* env, jobject obj, |  2091 static void Java_MotionEvent_addBatchV_J_LAVMEPC_I(JNIEnv* env, jobject obj, | 
|  2084     jlong p0, |  2092     jlong p0, | 
|  2085     jobjectArray p1, |  2093     jobjectArray p1, | 
|  2086     JniIntWrapper p2) { |  2094     JniIntWrapper p2) { | 
|  2087   /* Must call RegisterNativesImpl()  */ |  2095   /* Must call RegisterNativesImpl()  */ | 
|  2088   CHECK_CLAZZ(env, obj, |  2096   CHECK_CLAZZ(env, obj, | 
|  2089       g_MotionEvent_clazz); |  2097       MotionEvent_clazz(env)); | 
|  2090   jmethodID method_id = |  2098   jmethodID method_id = | 
|  2091       base::android::MethodID::LazyGet< |  2099       base::android::MethodID::LazyGet< | 
|  2092       base::android::MethodID::TYPE_INSTANCE>( |  2100       base::android::MethodID::TYPE_INSTANCE>( | 
|  2093       env, g_MotionEvent_clazz, |  2101       env, MotionEvent_clazz(env), | 
|  2094       "addBatch", |  2102       "addBatch", | 
|  2095       "(J[Landroid/view/MotionEvent$PointerCoords;I)V", |  2103       "(J[Landroid/view/MotionEvent$PointerCoords;I)V", | 
|  2096       &g_MotionEvent_addBatchV_J_LAVMEPC_I); |  2104       &g_MotionEvent_addBatchV_J_LAVMEPC_I); | 
|  2097  |  2105  | 
|  2098      env->CallVoidMethod(obj, |  2106      env->CallVoidMethod(obj, | 
|  2099           method_id, p0, p1, as_jint(p2)); |  2107           method_id, p0, p1, as_jint(p2)); | 
|  2100   jni_generator::CheckException(env); |  2108   jni_generator::CheckException(env); | 
|  2101  |  2109  | 
|  2102 } |  2110 } | 
|  2103  |  2111  | 
|  2104 static base::subtle::AtomicWord g_MotionEvent_toString = 0; |  2112 static base::subtle::AtomicWord g_MotionEvent_toString = 0; | 
|  2105 static base::android::ScopedJavaLocalRef<jstring> |  2113 static base::android::ScopedJavaLocalRef<jstring> | 
|  2106     Java_MotionEvent_toString(JNIEnv* env, jobject obj) __attribute__ |  2114     Java_MotionEvent_toString(JNIEnv* env, jobject obj) __attribute__ | 
|  2107     ((unused)); |  2115     ((unused)); | 
|  2108 static base::android::ScopedJavaLocalRef<jstring> |  2116 static base::android::ScopedJavaLocalRef<jstring> | 
|  2109     Java_MotionEvent_toString(JNIEnv* env, jobject obj) { |  2117     Java_MotionEvent_toString(JNIEnv* env, jobject obj) { | 
|  2110   /* Must call RegisterNativesImpl()  */ |  2118   /* Must call RegisterNativesImpl()  */ | 
|  2111   CHECK_CLAZZ(env, obj, |  2119   CHECK_CLAZZ(env, obj, | 
|  2112       g_MotionEvent_clazz, NULL); |  2120       MotionEvent_clazz(env), NULL); | 
|  2113   jmethodID method_id = |  2121   jmethodID method_id = | 
|  2114       base::android::MethodID::LazyGet< |  2122       base::android::MethodID::LazyGet< | 
|  2115       base::android::MethodID::TYPE_INSTANCE>( |  2123       base::android::MethodID::TYPE_INSTANCE>( | 
|  2116       env, g_MotionEvent_clazz, |  2124       env, MotionEvent_clazz(env), | 
|  2117       "toString", |  2125       "toString", | 
|  2118       "()Ljava/lang/String;", |  2126       "()Ljava/lang/String;", | 
|  2119       &g_MotionEvent_toString); |  2127       &g_MotionEvent_toString); | 
|  2120  |  2128  | 
|  2121   jstring ret = |  2129   jstring ret = | 
|  2122       static_cast<jstring>(env->CallObjectMethod(obj, |  2130       static_cast<jstring>(env->CallObjectMethod(obj, | 
|  2123           method_id)); |  2131           method_id)); | 
|  2124   jni_generator::CheckException(env); |  2132   jni_generator::CheckException(env); | 
|  2125   return base::android::ScopedJavaLocalRef<jstring>(env, ret); |  2133   return base::android::ScopedJavaLocalRef<jstring>(env, ret); | 
|  2126 } |  2134 } | 
|  2127  |  2135  | 
|  2128 static base::subtle::AtomicWord g_MotionEvent_actionToString = 0; |  2136 static base::subtle::AtomicWord g_MotionEvent_actionToString = 0; | 
|  2129 static base::android::ScopedJavaLocalRef<jstring> |  2137 static base::android::ScopedJavaLocalRef<jstring> | 
|  2130     Java_MotionEvent_actionToString(JNIEnv* env, JniIntWrapper p0) __attribute__ |  2138     Java_MotionEvent_actionToString(JNIEnv* env, JniIntWrapper p0) __attribute__ | 
|  2131     ((unused)); |  2139     ((unused)); | 
|  2132 static base::android::ScopedJavaLocalRef<jstring> |  2140 static base::android::ScopedJavaLocalRef<jstring> | 
|  2133     Java_MotionEvent_actionToString(JNIEnv* env, JniIntWrapper p0) { |  2141     Java_MotionEvent_actionToString(JNIEnv* env, JniIntWrapper p0) { | 
|  2134   /* Must call RegisterNativesImpl()  */ |  2142   /* Must call RegisterNativesImpl()  */ | 
|  2135   CHECK_CLAZZ(env, g_MotionEvent_clazz, |  2143   CHECK_CLAZZ(env, MotionEvent_clazz(env), | 
|  2136       g_MotionEvent_clazz, NULL); |  2144       MotionEvent_clazz(env), NULL); | 
|  2137   jmethodID method_id = |  2145   jmethodID method_id = | 
|  2138       base::android::MethodID::LazyGet< |  2146       base::android::MethodID::LazyGet< | 
|  2139       base::android::MethodID::TYPE_STATIC>( |  2147       base::android::MethodID::TYPE_STATIC>( | 
|  2140       env, g_MotionEvent_clazz, |  2148       env, MotionEvent_clazz(env), | 
|  2141       "actionToString", |  2149       "actionToString", | 
|  2142       "(I)Ljava/lang/String;", |  2150       "(I)Ljava/lang/String;", | 
|  2143       &g_MotionEvent_actionToString); |  2151       &g_MotionEvent_actionToString); | 
|  2144  |  2152  | 
|  2145   jstring ret = |  2153   jstring ret = | 
|  2146       static_cast<jstring>(env->CallStaticObjectMethod(g_MotionEvent_clazz, |  2154       static_cast<jstring>(env->CallStaticObjectMethod(MotionEvent_clazz(env), | 
|  2147           method_id, as_jint(p0))); |  2155           method_id, as_jint(p0))); | 
|  2148   jni_generator::CheckException(env); |  2156   jni_generator::CheckException(env); | 
|  2149   return base::android::ScopedJavaLocalRef<jstring>(env, ret); |  2157   return base::android::ScopedJavaLocalRef<jstring>(env, ret); | 
|  2150 } |  2158 } | 
|  2151  |  2159  | 
|  2152 static base::subtle::AtomicWord g_MotionEvent_axisToString = 0; |  2160 static base::subtle::AtomicWord g_MotionEvent_axisToString = 0; | 
|  2153 static base::android::ScopedJavaLocalRef<jstring> |  2161 static base::android::ScopedJavaLocalRef<jstring> | 
|  2154     Java_MotionEvent_axisToString(JNIEnv* env, JniIntWrapper p0) __attribute__ |  2162     Java_MotionEvent_axisToString(JNIEnv* env, JniIntWrapper p0) __attribute__ | 
|  2155     ((unused)); |  2163     ((unused)); | 
|  2156 static base::android::ScopedJavaLocalRef<jstring> |  2164 static base::android::ScopedJavaLocalRef<jstring> | 
|  2157     Java_MotionEvent_axisToString(JNIEnv* env, JniIntWrapper p0) { |  2165     Java_MotionEvent_axisToString(JNIEnv* env, JniIntWrapper p0) { | 
|  2158   /* Must call RegisterNativesImpl()  */ |  2166   /* Must call RegisterNativesImpl()  */ | 
|  2159   CHECK_CLAZZ(env, g_MotionEvent_clazz, |  2167   CHECK_CLAZZ(env, MotionEvent_clazz(env), | 
|  2160       g_MotionEvent_clazz, NULL); |  2168       MotionEvent_clazz(env), NULL); | 
|  2161   jmethodID method_id = |  2169   jmethodID method_id = | 
|  2162       base::android::MethodID::LazyGet< |  2170       base::android::MethodID::LazyGet< | 
|  2163       base::android::MethodID::TYPE_STATIC>( |  2171       base::android::MethodID::TYPE_STATIC>( | 
|  2164       env, g_MotionEvent_clazz, |  2172       env, MotionEvent_clazz(env), | 
|  2165       "axisToString", |  2173       "axisToString", | 
|  2166       "(I)Ljava/lang/String;", |  2174       "(I)Ljava/lang/String;", | 
|  2167       &g_MotionEvent_axisToString); |  2175       &g_MotionEvent_axisToString); | 
|  2168  |  2176  | 
|  2169   jstring ret = |  2177   jstring ret = | 
|  2170       static_cast<jstring>(env->CallStaticObjectMethod(g_MotionEvent_clazz, |  2178       static_cast<jstring>(env->CallStaticObjectMethod(MotionEvent_clazz(env), | 
|  2171           method_id, as_jint(p0))); |  2179           method_id, as_jint(p0))); | 
|  2172   jni_generator::CheckException(env); |  2180   jni_generator::CheckException(env); | 
|  2173   return base::android::ScopedJavaLocalRef<jstring>(env, ret); |  2181   return base::android::ScopedJavaLocalRef<jstring>(env, ret); | 
|  2174 } |  2182 } | 
|  2175  |  2183  | 
|  2176 static base::subtle::AtomicWord g_MotionEvent_axisFromString = 0; |  2184 static base::subtle::AtomicWord g_MotionEvent_axisFromString = 0; | 
|  2177 static jint Java_MotionEvent_axisFromString(JNIEnv* env, jstring p0) |  2185 static jint Java_MotionEvent_axisFromString(JNIEnv* env, jstring p0) | 
|  2178     __attribute__ ((unused)); |  2186     __attribute__ ((unused)); | 
|  2179 static jint Java_MotionEvent_axisFromString(JNIEnv* env, jstring p0) { |  2187 static jint Java_MotionEvent_axisFromString(JNIEnv* env, jstring p0) { | 
|  2180   /* Must call RegisterNativesImpl()  */ |  2188   /* Must call RegisterNativesImpl()  */ | 
|  2181   CHECK_CLAZZ(env, g_MotionEvent_clazz, |  2189   CHECK_CLAZZ(env, MotionEvent_clazz(env), | 
|  2182       g_MotionEvent_clazz, 0); |  2190       MotionEvent_clazz(env), 0); | 
|  2183   jmethodID method_id = |  2191   jmethodID method_id = | 
|  2184       base::android::MethodID::LazyGet< |  2192       base::android::MethodID::LazyGet< | 
|  2185       base::android::MethodID::TYPE_STATIC>( |  2193       base::android::MethodID::TYPE_STATIC>( | 
|  2186       env, g_MotionEvent_clazz, |  2194       env, MotionEvent_clazz(env), | 
|  2187       "axisFromString", |  2195       "axisFromString", | 
|  2188       "(Ljava/lang/String;)I", |  2196       "(Ljava/lang/String;)I", | 
|  2189       &g_MotionEvent_axisFromString); |  2197       &g_MotionEvent_axisFromString); | 
|  2190  |  2198  | 
|  2191   jint ret = |  2199   jint ret = | 
|  2192       env->CallStaticIntMethod(g_MotionEvent_clazz, |  2200       env->CallStaticIntMethod(MotionEvent_clazz(env), | 
|  2193           method_id, p0); |  2201           method_id, p0); | 
|  2194   jni_generator::CheckException(env); |  2202   jni_generator::CheckException(env); | 
|  2195   return ret; |  2203   return ret; | 
|  2196 } |  2204 } | 
|  2197  |  2205  | 
|  2198 static base::subtle::AtomicWord g_MotionEvent_writeToParcel = 0; |  2206 static base::subtle::AtomicWord g_MotionEvent_writeToParcel = 0; | 
|  2199 static void Java_MotionEvent_writeToParcel(JNIEnv* env, jobject obj, jobject p0, |  2207 static void Java_MotionEvent_writeToParcel(JNIEnv* env, jobject obj, jobject p0, | 
|  2200     JniIntWrapper p1) __attribute__ ((unused)); |  2208     JniIntWrapper p1) __attribute__ ((unused)); | 
|  2201 static void Java_MotionEvent_writeToParcel(JNIEnv* env, jobject obj, jobject p0, |  2209 static void Java_MotionEvent_writeToParcel(JNIEnv* env, jobject obj, jobject p0, | 
|  2202     JniIntWrapper p1) { |  2210     JniIntWrapper p1) { | 
|  2203   /* Must call RegisterNativesImpl()  */ |  2211   /* Must call RegisterNativesImpl()  */ | 
|  2204   CHECK_CLAZZ(env, obj, |  2212   CHECK_CLAZZ(env, obj, | 
|  2205       g_MotionEvent_clazz); |  2213       MotionEvent_clazz(env)); | 
|  2206   jmethodID method_id = |  2214   jmethodID method_id = | 
|  2207       base::android::MethodID::LazyGet< |  2215       base::android::MethodID::LazyGet< | 
|  2208       base::android::MethodID::TYPE_INSTANCE>( |  2216       base::android::MethodID::TYPE_INSTANCE>( | 
|  2209       env, g_MotionEvent_clazz, |  2217       env, MotionEvent_clazz(env), | 
|  2210       "writeToParcel", |  2218       "writeToParcel", | 
|  2211       "(Landroid/os/Parcel;I)V", |  2219       "(Landroid/os/Parcel;I)V", | 
|  2212       &g_MotionEvent_writeToParcel); |  2220       &g_MotionEvent_writeToParcel); | 
|  2213  |  2221  | 
|  2214      env->CallVoidMethod(obj, |  2222      env->CallVoidMethod(obj, | 
|  2215           method_id, p0, as_jint(p1)); |  2223           method_id, p0, as_jint(p1)); | 
|  2216   jni_generator::CheckException(env); |  2224   jni_generator::CheckException(env); | 
|  2217  |  2225  | 
|  2218 } |  2226 } | 
|  2219  |  2227  | 
|  2220 // Step 3: RegisterNatives. |  2228 // Step 3: RegisterNatives. | 
|  2221  |  2229  | 
|  2222 static bool RegisterNativesImpl(JNIEnv* env) { |  2230 static bool RegisterNativesImpl(JNIEnv* env) { | 
|  2223   g_MotionEvent_clazz = reinterpret_cast<jclass>(env->NewGlobalRef( |  2231   g_MotionEvent_clazz = reinterpret_cast<jclass>(env->NewGlobalRef( | 
|  2224       base::android::GetClass(env, kMotionEventClassPath).obj())); |  2232       base::android::GetClass(env, kMotionEventClassPath).obj())); | 
|  2225  |  2233  | 
|  2226   return true; |  2234   return true; | 
|  2227 } |  2235 } | 
|  2228  |  2236  | 
|  2229 }  // namespace JNI_MotionEvent |  2237 }  // namespace JNI_MotionEvent | 
|  2230  |  2238  | 
|  2231 #endif  // android_view_MotionEvent_JNI |  2239 #endif  // android_view_MotionEvent_JNI | 
| OLD | NEW |