From c410a2cb9f7120b5c1e6a83ff54b53b19cae79d3 Mon Sep 17 00:00:00 2001 From: "bulach@chromium.org" Date: Tue, 16 Oct 2012 18:35:10 +0000 Subject: [PATCH] Android: lazy initialization for method id. Rather than requiring early registration for all method id, we can initialize them lazily as required. This solves the problem of building against SDK X but running against X - 1. Also adds a microbenchmark to ensure there are no considerable regressions. Results are a bit variable, but it hovers over: [ERROR:jni_android_unittest.cc(125)] JNI LazyMethodIDCall (us) 1983 [ERROR:jni_android_unittest.cc(127)] JNI MethodIDCall (us) 1862 BUG=152987 TEST=JNIAndroidMicrobenchmark.MethodId TBR=akalin Review URL: https://chromiumcodereview.appspot.com/11038015 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@162186 0039d316-1c4b-4281-b951-d872f2087c98 --- base/android/jni_android.cc | 148 ++--- base/android/jni_android.h | 75 +-- base/android/jni_android_unittest.cc | 47 ++ .../golden_sample_for_tests_jni.h | 164 +++--- base/android/jni_generator/jni_generator.py | 38 +- .../jni_generator/jni_generator_tests.py | 531 +++++++++--------- base/android/locale_utils.cc | 9 +- .../chrome_web_contents_delegate_android.cc | 16 +- .../provider/chrome_browser_provider.cc | 12 +- .../browser/history/android/sqlite_cursor.cc | 10 +- .../browser/android/content_view_core_impl.cc | 5 +- .../download_controller_android_impl.cc | 4 +- .../surface_texture_peer_browser_impl.cc | 13 +- .../data_fetcher_impl_android.cc | 1 - .../location_api_adapter_android.cc | 1 - .../browser/renderer_host/java/java_method.cc | 16 +- content/common/android/surface_callback.cc | 13 +- .../common/android/surface_texture_bridge.cc | 1 - media/base/android/media_player_bridge.cc | 10 +- net/proxy/proxy_config_service_android.cc | 1 - sync/util/session_utils_android.cc | 12 +- ui/base/clipboard/clipboard_android.cc | 23 +- ui/base/clipboard/clipboard_unittest.cc | 10 +- webkit/glue/fling_animator_impl_android.cc | 26 +- 24 files changed, 588 insertions(+), 598 deletions(-) diff --git a/base/android/jni_android.cc b/base/android/jni_android.cc index 01737938b9ab11..fdc217049166dc 100644 --- a/base/android/jni_android.cc +++ b/base/android/jni_android.cc @@ -8,14 +8,13 @@ #include "base/android/build_info.h" #include "base/android/jni_string.h" -#include "base/atomicops.h" #include "base/lazy_instance.h" #include "base/logging.h" #include "base/threading/platform_thread.h" namespace { using base::android::GetClass; -using base::android::GetMethodID; +using base::android::MethodID; using base::android::ScopedJavaLocalRef; struct MethodIdentifier { @@ -58,17 +57,20 @@ std::string GetJavaExceptionInfo(JNIEnv* env, jthrowable java_throwable) { ScopedJavaLocalRef throwable_clazz = GetClass(env, "java/lang/Throwable"); jmethodID throwable_printstacktrace = - GetMethodID(env, throwable_clazz, "printStackTrace", - "(Ljava/io/PrintStream;)V"); + MethodID::Get( + env, throwable_clazz.obj(), "printStackTrace", + "(Ljava/io/PrintStream;)V"); // Create an instance of ByteArrayOutputStream. ScopedJavaLocalRef bytearray_output_stream_clazz = GetClass(env, "java/io/ByteArrayOutputStream"); jmethodID bytearray_output_stream_constructor = - GetMethodID(env, bytearray_output_stream_clazz, "", "()V"); + MethodID::Get( + env, bytearray_output_stream_clazz.obj(), "", "()V"); jmethodID bytearray_output_stream_tostring = - GetMethodID(env, bytearray_output_stream_clazz, "toString", - "()Ljava/lang/String;"); + MethodID::Get( + env, bytearray_output_stream_clazz.obj(), "toString", + "()Ljava/lang/String;"); ScopedJavaLocalRef bytearray_output_stream(env, env->NewObject(bytearray_output_stream_clazz.obj(), bytearray_output_stream_constructor)); @@ -77,8 +79,9 @@ std::string GetJavaExceptionInfo(JNIEnv* env, jthrowable java_throwable) { ScopedJavaLocalRef printstream_clazz = GetClass(env, "java/io/PrintStream"); jmethodID printstream_constructor = - GetMethodID(env, printstream_clazz, "", - "(Ljava/io/OutputStream;)V"); + MethodID::Get( + env, printstream_clazz.obj(), "", + "(Ljava/io/OutputStream;)V"); ScopedJavaLocalRef printstream(env, env->NewObject(printstream_clazz.obj(), printstream_constructor, bytearray_output_stream.obj())); @@ -96,35 +99,6 @@ std::string GetJavaExceptionInfo(JNIEnv* env, jthrowable java_throwable) { return ConvertJavaStringToUTF8(exception_string); } -enum MethodType { - METHODTYPE_STATIC, - METHODTYPE_NORMAL, -}; - -enum ExceptionCheck { - EXCEPTIONCHECK_YES, - EXCEPTIONCHECK_NO, -}; - -template -jmethodID GetMethodIDInternal(JNIEnv* env, - jclass clazz, - const char* method_name, - const char* jni_signature) { - jmethodID method_id = method_type == METHODTYPE_STATIC ? - env->GetStaticMethodID(clazz, method_name, jni_signature) : - env->GetMethodID(clazz, method_name, jni_signature); - if (exception_check == EXCEPTIONCHECK_YES) { - CHECK(!base::android::ClearException(env) && method_id) << - "Failed to find " << - (method_type == METHODTYPE_STATIC ? "static " : "") << - "method " << method_name << " " << jni_signature; - } else if (base::android::HasException(env)) { - env->ExceptionClear(); - } - return method_id; -} - } // namespace namespace base { @@ -181,68 +155,57 @@ bool HasClass(JNIEnv* env, const char* class_name) { return true; } -jmethodID GetMethodID(JNIEnv* env, - const JavaRef& clazz, - const char* method_name, - const char* jni_signature) { - // clazz.env() can not be used as that may be from a different thread. - return GetMethodID(env, clazz.obj(), method_name, jni_signature); -} - -jmethodID GetMethodID(JNIEnv* env, - jclass clazz, - const char* method_name, - const char* jni_signature) { - return GetMethodIDInternal( - env, clazz, method_name, jni_signature); +template +jmethodID MethodID::Get(JNIEnv* env, + jclass clazz, + const char* method_name, + const char* jni_signature) { + jmethodID id = type == TYPE_STATIC ? + env->GetStaticMethodID(clazz, method_name, jni_signature) : + env->GetMethodID(clazz, method_name, jni_signature); + CHECK(base::android::ClearException(env) || id) << + "Failed to find " << + (type == TYPE_STATIC ? "static " : "") << + "method " << method_name << " " << jni_signature; + return id; } -jmethodID GetMethodIDOrNull(JNIEnv* env, +// If |atomic_method_id| set, it'll return immediately. Otherwise, it'll call +// into ::Get() above. If there's a race, it's ok since the values are the same +// (and the duplicated effort will happen only once). +template +jmethodID MethodID::LazyGet(JNIEnv* env, jclass clazz, const char* method_name, - const char* jni_signature) { - return GetMethodIDInternal( - env, clazz, method_name, jni_signature); + const char* jni_signature, + base::subtle::AtomicWord* atomic_method_id) { + COMPILE_ASSERT(sizeof(subtle::AtomicWord) >= sizeof(jmethodID), + AtomicWord_SmallerThan_jMethodID); + subtle::AtomicWord value = base::subtle::Acquire_Load(atomic_method_id); + if (value) + return reinterpret_cast(value); + jmethodID id = MethodID::Get(env, clazz, method_name, jni_signature); + base::subtle::Release_Store( + atomic_method_id, reinterpret_cast(id)); + return id; } -jmethodID GetStaticMethodID(JNIEnv* env, - const JavaRef& clazz, - const char* method_name, - const char* jni_signature) { - return GetStaticMethodID(env, clazz.obj(), method_name, - jni_signature); -} +// Various template instantiations. +template jmethodID MethodID::Get( + JNIEnv* env, jclass clazz, const char* method_name, + const char* jni_signature); -jmethodID GetStaticMethodID(JNIEnv* env, - jclass clazz, - const char* method_name, - const char* jni_signature) { - return GetMethodIDInternal( - env, clazz, method_name, jni_signature); -} +template jmethodID MethodID::Get( + JNIEnv* env, jclass clazz, const char* method_name, + const char* jni_signature); -jmethodID GetStaticMethodIDOrNull(JNIEnv* env, - jclass clazz, - const char* method_name, - const char* jni_signature) { - return GetMethodIDInternal( - env, clazz, method_name, jni_signature); -} +template jmethodID MethodID::LazyGet( + JNIEnv* env, jclass clazz, const char* method_name, + const char* jni_signature, base::subtle::AtomicWord* atomic_method_id); -bool HasMethod(JNIEnv* env, - const JavaRef& clazz, - const char* method_name, - const char* jni_signature) { - jmethodID method_id = - env->GetMethodID(clazz.obj(), method_name, jni_signature); - if (!method_id) { - ClearException(env); - return false; - } - bool error = ClearException(env); - DCHECK(!error); - return true; -} +template jmethodID MethodID::LazyGet( + JNIEnv* env, jclass clazz, const char* method_name, + const char* jni_signature, base::subtle::AtomicWord* atomic_method_id); jfieldID GetFieldID(JNIEnv* env, const JavaRef& clazz, @@ -308,7 +271,8 @@ jmethodID GetMethodIDFromClassName(JNIEnv* env, } ScopedJavaLocalRef clazz(env, env->FindClass(class_name)); - jmethodID id = GetMethodID(env, clazz, method, jni_signature); + jmethodID id = MethodID::Get( + env, clazz.obj(), method, jni_signature); while (base::subtle::Acquire_CompareAndSwap(&g_method_id_map_lock, kUnlocked, diff --git a/base/android/jni_android.h b/base/android/jni_android.h index 40e235943c64b8..a3ac18a164e95d 100644 --- a/base/android/jni_android.h +++ b/base/android/jni_android.h @@ -9,6 +9,7 @@ #include #include "base/android/scoped_java_ref.h" +#include "base/atomicops.h" #include "base/compiler_specific.h" namespace base { @@ -57,56 +58,36 @@ jclass GetUnscopedClass(JNIEnv* env, const char* class_name) WARN_UNUSED_RESULT; // Returns true iff the class |class_name| could be found. bool HasClass(JNIEnv* env, const char* class_name); -// Returns the method ID for the method with the specified name and signature. -// This method triggers a fatal assertion if the method could not be found. -// Use HasMethod if you need to check whether a method exists. -jmethodID GetMethodID(JNIEnv* env, - const JavaRef& clazz, - const char* method_name, - const char* jni_signature); - -// Similar to GetMethodID, but takes a raw jclass. -jmethodID GetMethodID(JNIEnv* env, - jclass clazz, - const char* method_name, - const char* jni_signature); - -// Unlike GetMethodID, returns NULL if the method could not be found. -jmethodID GetMethodIDOrNull(JNIEnv* env, - jclass clazz, - const char* method_name, - const char* jni_signature); - -// Returns the method ID for the static method with the specified name and -// signature. -// This method triggers a fatal assertion if the method could not be found. -// Use HasMethod if you need to check whether a method exists. -jmethodID GetStaticMethodID(JNIEnv* env, - const JavaRef& clazz, - const char* method_name, - const char* jni_signature); - -// Similar to the GetStaticMethodID, but takes a raw jclass. -jmethodID GetStaticMethodID(JNIEnv* env, - jclass clazz, - const char* method_name, - const char* jni_signature); - -// Unlike GetStaticMethodID, returns NULL if the method could not be found. -jmethodID GetStaticMethodIDOrNull(JNIEnv* env, - jclass clazz, - const char* method_name, - const char* jni_signature); - -// Returns true iff |clazz| has a method with the specified name and signature. -bool HasMethod(JNIEnv* env, - const JavaRef& clazz, - const char* method_name, - const char* jni_signature); +// This class is a wrapper for JNIEnv Get(Static)MethodID. +class MethodID { + public: + enum Type { + TYPE_STATIC, + TYPE_INSTANCE, + }; + + // Returns the method ID for the method with the specified name and signature. + // This method triggers a fatal assertion if the method could not be found. + template + static jmethodID Get(JNIEnv* env, + jclass clazz, + const char* method_name, + const char* jni_signature); + + // The caller is responsible to zero-initialize |atomic_method_id|. + // It's fine to simultaneously call this on multiple threads referencing the + // same |atomic_method_id|. + template + static jmethodID LazyGet(JNIEnv* env, + jclass clazz, + const char* method_name, + const char* jni_signature, + base::subtle::AtomicWord* atomic_method_id); +}; // Gets the method ID from the class name. Clears the pending Java exception // and returns NULL if the method is not found. Caches results. Note that -// GetMethodID() below avoids a class lookup, but does not cache results. +// MethodID::Get() above avoids a class lookup, but does not cache results. // Strings passed to this function are held in the cache and MUST remain valid // beyond the duration of all future calls to this function, across all // threads. In practice, this means that the function should only be used with diff --git a/base/android/jni_android_unittest.cc b/base/android/jni_android_unittest.cc index abecad778b47c7..920b395659025c 100644 --- a/base/android/jni_android_unittest.cc +++ b/base/android/jni_android_unittest.cc @@ -5,6 +5,7 @@ #include "base/android/jni_android.h" #include "base/at_exit.h" +#include "base/logging.h" #include "testing/gtest/include/gtest/gtest.h" namespace base { @@ -90,5 +91,51 @@ TEST_F(JNIAndroidTest, GetMethodIDFromClassNameCaching) { EXPECT_EQ(g_last_method_id, id3); } +namespace { + +base::subtle::AtomicWord g_atomic_id = 0; +int LazyMethodIDCall(JNIEnv* env, jclass clazz, int p) { + jmethodID id = base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_STATIC>( + env, clazz, + "abs", + "(I)I", + &g_atomic_id); + + return env->CallStaticIntMethod(clazz, id, p); +} + +int MethodIDCall(JNIEnv* env, jclass clazz, jmethodID id, int p) { + return env->CallStaticIntMethod(clazz, id, p); +} + +} // namespace + +TEST(JNIAndroidMicrobenchmark, MethodId) { + JNIEnv* env = AttachCurrentThread(); + ScopedJavaLocalRef clazz(GetClass(env, "java/lang/Math")); + base::Time start_lazy = base::Time::Now(); + int o = 0; + for (int i = 0; i < 1024; ++i) + o += LazyMethodIDCall(env, clazz.obj(), i); + base::Time end_lazy = base::Time::Now(); + + jmethodID id = reinterpret_cast(g_atomic_id); + base::Time start = base::Time::Now(); + for (int i = 0; i < 1024; ++i) + o += MethodIDCall(env, clazz.obj(), id, i); + base::Time end = base::Time::Now(); + + // On a Galaxy Nexus, results were in the range of: + // JNI LazyMethodIDCall (us) 1984 + // JNI MethodIDCall (us) 1861 + LOG(ERROR) << "JNI LazyMethodIDCall (us) " << + base::TimeDelta(end_lazy - start_lazy).InMicroseconds(); + LOG(ERROR) << "JNI MethodIDCall (us) " << + base::TimeDelta(end - start).InMicroseconds(); + LOG(ERROR) << "JNI " << o; +} + + } // namespace android } // namespace base diff --git a/base/android/jni_generator/golden_sample_for_tests_jni.h b/base/android/jni_generator/golden_sample_for_tests_jni.h index b80f8f4609c900..08f25a73bc3f78 100644 --- a/base/android/jni_generator/golden_sample_for_tests_jni.h +++ b/base/android/jni_generator/golden_sample_for_tests_jni.h @@ -66,7 +66,7 @@ static jdouble MethodOtherP0(JNIEnv* env, jobject obj, jint nativePtr) { DCHECK(nativePtr) << "MethodOtherP0"; CPPClass::InnerClass* native = - reinterpret_cast(nativePtr); + reinterpret_cast(nativePtr); return native->MethodOtherP0(env, obj); } @@ -77,147 +77,147 @@ static jstring InnerMethod(JNIEnv* env, jobject obj, return native->InnerMethod(env, obj).Release(); } -static jmethodID g_SampleForTests_javaMethod = 0; +static base::subtle::AtomicWord g_SampleForTests_javaMethod = 0; static jint Java_SampleForTests_javaMethod(JNIEnv* env, jobject obj, jint foo, jint bar) { /* Must call RegisterNativesImpl() */ DCHECK(g_SampleForTests_clazz); - DCHECK(g_SampleForTests_javaMethod); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_SampleForTests_clazz, + "javaMethod", + +"(" +"I" +"I" +")" +"I", + &g_SampleForTests_javaMethod); + jint ret = env->CallIntMethod(obj, - g_SampleForTests_javaMethod, foo, bar); + method_id, foo, bar); base::android::CheckException(env); return ret; } -static jmethodID g_SampleForTests_staticJavaMethod = 0; +static base::subtle::AtomicWord g_SampleForTests_staticJavaMethod = 0; static jboolean Java_SampleForTests_staticJavaMethod(JNIEnv* env) { /* Must call RegisterNativesImpl() */ DCHECK(g_SampleForTests_clazz); - DCHECK(g_SampleForTests_staticJavaMethod); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_STATIC>( + env, g_SampleForTests_clazz, + "staticJavaMethod", + +"(" +")" +"Z", + &g_SampleForTests_staticJavaMethod); + jboolean ret = env->CallStaticBooleanMethod(g_SampleForTests_clazz, - g_SampleForTests_staticJavaMethod); + method_id); base::android::CheckException(env); return ret; } -static jmethodID g_SampleForTests_packagePrivateJavaMethod = 0; +static base::subtle::AtomicWord g_SampleForTests_packagePrivateJavaMethod = 0; static void Java_SampleForTests_packagePrivateJavaMethod(JNIEnv* env, jobject obj) { /* Must call RegisterNativesImpl() */ DCHECK(g_SampleForTests_clazz); - DCHECK(g_SampleForTests_packagePrivateJavaMethod); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_SampleForTests_clazz, + "packagePrivateJavaMethod", + +"(" +")" +"V", + &g_SampleForTests_packagePrivateJavaMethod); env->CallVoidMethod(obj, - g_SampleForTests_packagePrivateJavaMethod); + method_id); base::android::CheckException(env); } -static jmethodID g_SampleForTests_methodThatThrowsException = 0; +static base::subtle::AtomicWord g_SampleForTests_methodThatThrowsException = 0; static void Java_SampleForTests_methodThatThrowsException(JNIEnv* env, jobject obj) { /* Must call RegisterNativesImpl() */ DCHECK(g_SampleForTests_clazz); - DCHECK(g_SampleForTests_methodThatThrowsException); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_SampleForTests_clazz, + "methodThatThrowsException", + +"(" +")" +"V", + &g_SampleForTests_methodThatThrowsException); env->CallVoidMethod(obj, - g_SampleForTests_methodThatThrowsException); + method_id); } -static jmethodID g_InnerClass_JavaInnerMethod = 0; +static base::subtle::AtomicWord g_InnerClass_JavaInnerMethod = 0; static jfloat Java_InnerClass_JavaInnerMethod(JNIEnv* env, jobject obj) { /* Must call RegisterNativesImpl() */ DCHECK(g_InnerClass_clazz); - DCHECK(g_InnerClass_JavaInnerMethod); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_InnerClass_clazz, + "JavaInnerMethod", + +"(" +")" +"F", + &g_InnerClass_JavaInnerMethod); + jfloat ret = env->CallFloatMethod(obj, - g_InnerClass_JavaInnerMethod); + method_id); base::android::CheckException(env); return ret; } -static jmethodID g_InnerClass_javaInnerFunction = 0; +static base::subtle::AtomicWord g_InnerClass_javaInnerFunction = 0; static void Java_InnerClass_javaInnerFunction(JNIEnv* env) { /* Must call RegisterNativesImpl() */ DCHECK(g_InnerClass_clazz); - DCHECK(g_InnerClass_javaInnerFunction); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_STATIC>( + env, g_InnerClass_clazz, + "javaInnerFunction", + +"(" +")" +"V", + &g_InnerClass_javaInnerFunction); env->CallStaticVoidMethod(g_InnerClass_clazz, - g_InnerClass_javaInnerFunction); + method_id); base::android::CheckException(env); } -// Step 3: GetMethodIDs and RegisterNatives. -static void GetMethodIDsImpl(JNIEnv* env) { +// Step 3: RegisterNatives. + +static bool RegisterNativesImpl(JNIEnv* env) { + g_InnerClass_clazz = reinterpret_cast(env->NewGlobalRef( base::android::GetUnscopedClass(env, kInnerClassClassPath))); g_SampleForTests_clazz = reinterpret_cast(env->NewGlobalRef( base::android::GetUnscopedClass(env, kSampleForTestsClassPath))); - g_SampleForTests_javaMethod = - base::android::GetMethodID( - env, g_SampleForTests_clazz, - "javaMethod", - -"(" -"I" -"I" -")" -"I"); - - g_SampleForTests_staticJavaMethod = - base::android::GetStaticMethodID( - env, g_SampleForTests_clazz, - "staticJavaMethod", - -"(" -")" -"Z"); - - g_SampleForTests_packagePrivateJavaMethod = - base::android::GetMethodID( - env, g_SampleForTests_clazz, - "packagePrivateJavaMethod", - -"(" -")" -"V"); - - g_SampleForTests_methodThatThrowsException = - base::android::GetMethodID( - env, g_SampleForTests_clazz, - "methodThatThrowsException", - -"(" -")" -"V"); - - g_InnerClass_JavaInnerMethod = - base::android::GetMethodID( - env, g_InnerClass_clazz, - "JavaInnerMethod", - -"(" -")" -"F"); - - g_InnerClass_javaInnerFunction = - base::android::GetStaticMethodID( - env, g_InnerClass_clazz, - "javaInnerFunction", - -"(" -")" -"V"); - -} - -static bool RegisterNativesImpl(JNIEnv* env) { - GetMethodIDsImpl(env); - static const JNINativeMethod kMethodsInnerClass[] = { { "nativeInnerFunction", "(" diff --git a/base/android/jni_generator/jni_generator.py b/base/android/jni_generator/jni_generator.py index f8df00ad3e8694..afc23893eb699b 100755 --- a/base/android/jni_generator/jni_generator.py +++ b/base/android/jni_generator/jni_generator.py @@ -603,13 +603,9 @@ def GetContent(self): // Step 2: method stubs. $METHOD_STUBS -// Step 3: GetMethodIDs and RegisterNatives. -static void GetMethodIDsImpl(JNIEnv* env) { -$GET_METHOD_IDS_IMPL -} +// Step 3: RegisterNatives. static bool RegisterNativesImpl(JNIEnv* env) { - GetMethodIDsImpl(env); $REGISTER_NATIVES_IMPL return true; } @@ -626,7 +622,6 @@ def GetContent(self): 'FORWARD_DECLARATIONS': self.GetForwardDeclarationsString(), 'METHOD_STUBS': self.GetMethodStubsString(), 'OPEN_NAMESPACE': self.GetOpenNamespaceString(), - 'GET_METHOD_IDS_IMPL': self.GetMethodIDsImplString(), 'REGISTER_NATIVES_IMPL': self.GetRegisterNativesImplString(), 'CLOSE_NAMESPACE': self.GetCloseNamespaceString(), 'HEADER_GUARD': self.header_guard, @@ -662,13 +657,6 @@ def GetKMethodsString(self, clazz): ret += [self.GetKMethodArrayEntry(native)] return '\n'.join(ret) - def GetMethodIDsImplString(self): - ret = [] - ret += [self.GetFindClasses()] - for called_by_native in self.called_by_natives: - ret += [self.GetMethodIDImpl(called_by_native)] - return '\n'.join(ret) - def GetRegisterNativesImplString(self): """Returns the implementation for RegisterNatives.""" template = Template("""\ @@ -684,7 +672,7 @@ def GetRegisterNativesImplString(self): return false; } """) - ret = [] + ret = [self.GetFindClasses()] all_classes = self.GetUniqueClasses(self.natives) all_classes[self.class_name] = self.fully_qualified_class for clazz in all_classes: @@ -793,14 +781,15 @@ def GetCalledByNativeMethodStub(self, called_by_native): ${FUNCTION_SIGNATURE} __attribute__ ((unused)); ${FUNCTION_SIGNATURE} {""") template = Template(""" -static jmethodID g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME} = 0; +static base::subtle::AtomicWord g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME} = 0; ${FUNCTION_HEADER} /* Must call RegisterNativesImpl() */ DCHECK(g_${JAVA_CLASS}_clazz); - DCHECK(g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME}); + jmethodID method_id = + ${GET_METHOD_ID_IMPL} ${RETURN_DECLARATION} ${PRE_CALL}env->${ENV_CALL}(${FIRST_PARAM_IN_CALL}, - g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME}${PARAMS_IN_CALL})${POST_CALL}; + method_id${PARAMS_IN_CALL})${POST_CALL}; ${CHECK_EXCEPTION} ${RETURN_CLAUSE} }""") @@ -855,6 +844,7 @@ def GetCalledByNativeMethodStub(self, called_by_native): 'PARAMS_IN_CALL': params_for_call, 'METHOD_ID_VAR_NAME': called_by_native.method_id_var_name, 'CHECK_EXCEPTION': check_exception, + 'GET_METHOD_ID_IMPL': self.GetMethodIDImpl(called_by_native) } values['FUNCTION_SIGNATURE'] = ( function_signature_template.substitute(values)) @@ -924,11 +914,12 @@ def GetFindClasses(self): def GetMethodIDImpl(self, called_by_native): """Returns the implementation of GetMethodID.""" template = Template("""\ - g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME} = - base::android::Get${STATIC}MethodID${SUFFIX}( - env, g_${JAVA_CLASS}_clazz, - "${JNI_NAME}", - ${JNI_SIGNATURE}); + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_${STATIC}>( + env, g_${JAVA_CLASS}_clazz, + "${JNI_NAME}", + ${JNI_SIGNATURE}, + &g_${JAVA_CLASS}_${METHOD_ID_VAR_NAME}); """) jni_name = called_by_native.name jni_return_type = called_by_native.return_type @@ -939,8 +930,7 @@ def GetMethodIDImpl(self, called_by_native): 'JAVA_CLASS': called_by_native.java_class_name or self.class_name, 'JNI_NAME': jni_name, 'METHOD_ID_VAR_NAME': called_by_native.method_id_var_name, - 'STATIC': 'Static' if called_by_native.static else '', - 'SUFFIX': 'OrNull' if called_by_native.system_class else '', + 'STATIC': 'STATIC' if called_by_native.static else 'INSTANCE', 'JNI_SIGNATURE': JniSignature(called_by_native.params, jni_return_type, True) diff --git a/base/android/jni_generator/jni_generator_tests.py b/base/android/jni_generator/jni_generator_tests.py index 23efa022bd6bca..4c345ed08c4346 100755 --- a/base/android/jni_generator/jni_generator_tests.py +++ b/base/android/jni_generator/jni_generator_tests.py @@ -315,19 +315,16 @@ def testNatives(self): jdouble gamma) { DCHECK(nativeDataFetcherImplAndroid) << "GotOrientation"; DataFetcherImplAndroid* native = - reinterpret_cast(nativeDataFetcherImplAndroid); + reinterpret_cast(nativeDataFetcherImplAndroid); return native->GotOrientation(env, obj, alpha, beta, gamma); } -// Step 3: GetMethodIDs and RegisterNatives. -static void GetMethodIDsImpl(JNIEnv* env) { - g_TestJni_clazz = reinterpret_cast(env->NewGlobalRef( - base::android::GetUnscopedClass(env, kTestJniClassPath))); -} +// Step 3: RegisterNatives. static bool RegisterNativesImpl(JNIEnv* env) { - GetMethodIDsImpl(env); + g_TestJni_clazz = reinterpret_cast(env->NewGlobalRef( + base::android::GetUnscopedClass(env, kTestJniClassPath))); static const JNINativeMethod kMethodsTestJni[] = { { "nativeInit", "(" @@ -481,15 +478,12 @@ class MyInnerClass { // Step 2: method stubs. -// Step 3: GetMethodIDs and RegisterNatives. -static void GetMethodIDsImpl(JNIEnv* env) { - g_TestJni_clazz = reinterpret_cast(env->NewGlobalRef( - base::android::GetUnscopedClass(env, kTestJniClassPath))); -} +// Step 3: RegisterNatives. static bool RegisterNativesImpl(JNIEnv* env) { - GetMethodIDsImpl(env); + g_TestJni_clazz = reinterpret_cast(env->NewGlobalRef( + base::android::GetUnscopedClass(env, kTestJniClassPath))); static const JNINativeMethod kMethodsMyInnerClass[] = { { "nativeInit", "(" @@ -575,15 +569,12 @@ class MyOtherInnerClass { // Step 2: method stubs. -// Step 3: GetMethodIDs and RegisterNatives. -static void GetMethodIDsImpl(JNIEnv* env) { - g_TestJni_clazz = reinterpret_cast(env->NewGlobalRef( - base::android::GetUnscopedClass(env, kTestJniClassPath))); -} +// Step 3: RegisterNatives. static bool RegisterNativesImpl(JNIEnv* env) { - GetMethodIDsImpl(env); + g_TestJni_clazz = reinterpret_cast(env->NewGlobalRef( + base::android::GetUnscopedClass(env, kTestJniClassPath))); static const JNINativeMethod kMethodsMyOtherInnerClass[] = { { "nativeInit", "(" @@ -683,15 +674,12 @@ class MyOtherInnerClass { // Step 2: method stubs. -// Step 3: GetMethodIDs and RegisterNatives. -static void GetMethodIDsImpl(JNIEnv* env) { - g_TestJni_clazz = reinterpret_cast(env->NewGlobalRef( - base::android::GetUnscopedClass(env, kTestJniClassPath))); -} +// Step 3: RegisterNatives. static bool RegisterNativesImpl(JNIEnv* env) { - GetMethodIDsImpl(env); + g_TestJni_clazz = reinterpret_cast(env->NewGlobalRef( + base::android::GetUnscopedClass(env, kTestJniClassPath))); static const JNINativeMethod kMethodsMyOtherInnerClass[] = { { "nativeInit", "(" @@ -910,7 +898,7 @@ def testCalledByNatives(self): // Step 2: method stubs. -static jmethodID g_TestJni_showConfirmInfoBar = 0; +static base::subtle::AtomicWord g_TestJni_showConfirmInfoBar = 0; static ScopedJavaLocalRef Java_TestJni_showConfirmInfoBar(JNIEnv* env, jobject obj, jint nativeInfoBar, jstring buttonOk, @@ -919,16 +907,30 @@ def testCalledByNatives(self): jobject icon) { /* Must call RegisterNativesImpl() */ DCHECK(g_TestJni_clazz); - DCHECK(g_TestJni_showConfirmInfoBar); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_TestJni_clazz, + "showConfirmInfoBar", + +"(" +"I" +"Ljava/lang/String;" +"Ljava/lang/String;" +"Ljava/lang/String;" +"Landroid/graphics/Bitmap;" +")" +"Lcom/google/android/apps/chrome/infobar/InfoBarContainer$NativeInfoBar;", + &g_TestJni_showConfirmInfoBar); + jobject ret = env->CallObjectMethod(obj, - g_TestJni_showConfirmInfoBar, nativeInfoBar, buttonOk, buttonCancel, - title, icon); + method_id, nativeInfoBar, buttonOk, buttonCancel, title, icon); base::android::CheckException(env); return ScopedJavaLocalRef(env, ret); } -static jmethodID g_TestJni_showAutoLoginInfoBar = 0; +static base::subtle::AtomicWord g_TestJni_showAutoLoginInfoBar = 0; static ScopedJavaLocalRef Java_TestJni_showAutoLoginInfoBar(JNIEnv* env, jobject obj, jint nativeInfoBar, jstring realm, @@ -936,27 +938,50 @@ def testCalledByNatives(self): jstring args) { /* Must call RegisterNativesImpl() */ DCHECK(g_TestJni_clazz); - DCHECK(g_TestJni_showAutoLoginInfoBar); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_TestJni_clazz, + "showAutoLoginInfoBar", + +"(" +"I" +"Ljava/lang/String;" +"Ljava/lang/String;" +"Ljava/lang/String;" +")" +"Lcom/google/android/apps/chrome/infobar/InfoBarContainer$NativeInfoBar;", + &g_TestJni_showAutoLoginInfoBar); + jobject ret = env->CallObjectMethod(obj, - g_TestJni_showAutoLoginInfoBar, nativeInfoBar, realm, account, args); + method_id, nativeInfoBar, realm, account, args); base::android::CheckException(env); return ScopedJavaLocalRef(env, ret); } -static jmethodID g_InfoBar_dismiss = 0; +static base::subtle::AtomicWord g_InfoBar_dismiss = 0; static void Java_InfoBar_dismiss(JNIEnv* env, jobject obj) { /* Must call RegisterNativesImpl() */ DCHECK(g_InfoBar_clazz); - DCHECK(g_InfoBar_dismiss); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_InfoBar_clazz, + "dismiss", + +"(" +")" +"V", + &g_InfoBar_dismiss); env->CallVoidMethod(obj, - g_InfoBar_dismiss); + method_id); base::android::CheckException(env); } -static jmethodID g_TestJni_shouldShowAutoLogin = 0; +static base::subtle::AtomicWord g_TestJni_shouldShowAutoLogin = 0; static jboolean Java_TestJni_shouldShowAutoLogin(JNIEnv* env, jobject contentView, jstring realm, @@ -964,28 +989,53 @@ def testCalledByNatives(self): jstring args) { /* Must call RegisterNativesImpl() */ DCHECK(g_TestJni_clazz); - DCHECK(g_TestJni_shouldShowAutoLogin); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_STATIC>( + env, g_TestJni_clazz, + "shouldShowAutoLogin", + +"(" +"Lorg/chromium/content/browser/ContentViewCore;" +"Ljava/lang/String;" +"Ljava/lang/String;" +"Ljava/lang/String;" +")" +"Z", + &g_TestJni_shouldShowAutoLogin); + jboolean ret = env->CallStaticBooleanMethod(g_TestJni_clazz, - g_TestJni_shouldShowAutoLogin, contentView, realm, account, args); + method_id, contentView, realm, account, args); base::android::CheckException(env); return ret; } -static jmethodID g_TestJni_openUrl = 0; +static base::subtle::AtomicWord g_TestJni_openUrl = 0; static ScopedJavaLocalRef Java_TestJni_openUrl(JNIEnv* env, jstring url) { /* Must call RegisterNativesImpl() */ DCHECK(g_TestJni_clazz); - DCHECK(g_TestJni_openUrl); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_STATIC>( + env, g_TestJni_clazz, + "openUrl", + +"(" +"Ljava/lang/String;" +")" +"Ljava/io/InputStream;", + &g_TestJni_openUrl); + jobject ret = env->CallStaticObjectMethod(g_TestJni_clazz, - g_TestJni_openUrl, url); + method_id, url); base::android::CheckException(env); return ScopedJavaLocalRef(env, ret); } -static jmethodID g_TestJni_activateHardwareAcceleration = 0; +static base::subtle::AtomicWord g_TestJni_activateHardwareAcceleration = 0; static void Java_TestJni_activateHardwareAcceleration(JNIEnv* env, jobject obj, jboolean activated, jint iPid, @@ -994,120 +1044,57 @@ def testCalledByNatives(self): jint iSecondaryID) { /* Must call RegisterNativesImpl() */ DCHECK(g_TestJni_clazz); - DCHECK(g_TestJni_activateHardwareAcceleration); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_TestJni_clazz, + "activateHardwareAcceleration", + +"(" +"Z" +"I" +"I" +"I" +"I" +")" +"V", + &g_TestJni_activateHardwareAcceleration); env->CallVoidMethod(obj, - g_TestJni_activateHardwareAcceleration, activated, iPid, iType, - iPrimaryID, iSecondaryID); + method_id, activated, iPid, iType, iPrimaryID, iSecondaryID); base::android::CheckException(env); } -static jmethodID g_TestJni_uncheckedCall = 0; +static base::subtle::AtomicWord g_TestJni_uncheckedCall = 0; static void Java_TestJni_uncheckedCall(JNIEnv* env, jobject obj, jint iParam) { /* Must call RegisterNativesImpl() */ DCHECK(g_TestJni_clazz); - DCHECK(g_TestJni_uncheckedCall); - - env->CallVoidMethod(obj, - g_TestJni_uncheckedCall, iParam); - -} - -// Step 3: GetMethodIDs and RegisterNatives. -static void GetMethodIDsImpl(JNIEnv* env) { - g_TestJni_clazz = reinterpret_cast(env->NewGlobalRef( - base::android::GetUnscopedClass(env, kTestJniClassPath))); - g_InfoBar_clazz = reinterpret_cast(env->NewGlobalRef( - base::android::GetUnscopedClass(env, kInfoBarClassPath))); - g_TestJni_showConfirmInfoBar = - base::android::GetMethodID( - env, g_TestJni_clazz, - "showConfirmInfoBar", + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_TestJni_clazz, + "uncheckedCall", "(" "I" -"Ljava/lang/String;" -"Ljava/lang/String;" -"Ljava/lang/String;" -"Landroid/graphics/Bitmap;" ")" -"Lcom/google/android/apps/chrome/infobar/InfoBarContainer$NativeInfoBar;"); - - g_TestJni_showAutoLoginInfoBar = - base::android::GetMethodID( - env, g_TestJni_clazz, - "showAutoLoginInfoBar", +"V", + &g_TestJni_uncheckedCall); -"(" -"I" -"Ljava/lang/String;" -"Ljava/lang/String;" -"Ljava/lang/String;" -")" -"Lcom/google/android/apps/chrome/infobar/InfoBarContainer$NativeInfoBar;"); - - g_InfoBar_dismiss = - base::android::GetMethodID( - env, g_InfoBar_clazz, - "dismiss", - -"(" -")" -"V"); - - g_TestJni_shouldShowAutoLogin = - base::android::GetStaticMethodID( - env, g_TestJni_clazz, - "shouldShowAutoLogin", - -"(" -"Lorg/chromium/content/browser/ContentViewCore;" -"Ljava/lang/String;" -"Ljava/lang/String;" -"Ljava/lang/String;" -")" -"Z"); - - g_TestJni_openUrl = - base::android::GetStaticMethodID( - env, g_TestJni_clazz, - "openUrl", - -"(" -"Ljava/lang/String;" -")" -"Ljava/io/InputStream;"); - - g_TestJni_activateHardwareAcceleration = - base::android::GetMethodID( - env, g_TestJni_clazz, - "activateHardwareAcceleration", - -"(" -"Z" -"I" -"I" -"I" -"I" -")" -"V"); - - g_TestJni_uncheckedCall = - base::android::GetMethodID( - env, g_TestJni_clazz, - "uncheckedCall", - -"(" -"I" -")" -"V"); + env->CallVoidMethod(obj, + method_id, iParam); } +// Step 3: RegisterNatives. + static bool RegisterNativesImpl(JNIEnv* env) { - GetMethodIDsImpl(env); + g_TestJni_clazz = reinterpret_cast(env->NewGlobalRef( + base::android::GetUnscopedClass(env, kTestJniClassPath))); + g_InfoBar_clazz = reinterpret_cast(env->NewGlobalRef( + base::android::GetUnscopedClass(env, kInfoBarClassPath))); return true; } @@ -1217,91 +1204,151 @@ def testFromJavaP(self): // Step 2: method stubs. -static jmethodID g_InputStream_available = 0; +static base::subtle::AtomicWord g_InputStream_available = 0; static jint Java_InputStream_available(JNIEnv* env, jobject obj) __attribute__ ((unused)); static jint Java_InputStream_available(JNIEnv* env, jobject obj) { /* Must call RegisterNativesImpl() */ DCHECK(g_InputStream_clazz); - DCHECK(g_InputStream_available); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_InputStream_clazz, + "available", + +"(" +")" +"I", + &g_InputStream_available); + jint ret = env->CallIntMethod(obj, - g_InputStream_available); + method_id); base::android::CheckException(env); return ret; } -static jmethodID g_InputStream_close = 0; +static base::subtle::AtomicWord g_InputStream_close = 0; static void Java_InputStream_close(JNIEnv* env, jobject obj) __attribute__ ((unused)); static void Java_InputStream_close(JNIEnv* env, jobject obj) { /* Must call RegisterNativesImpl() */ DCHECK(g_InputStream_clazz); - DCHECK(g_InputStream_close); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_InputStream_clazz, + "close", + +"(" +")" +"V", + &g_InputStream_close); env->CallVoidMethod(obj, - g_InputStream_close); + method_id); base::android::CheckException(env); } -static jmethodID g_InputStream_mark = 0; +static base::subtle::AtomicWord g_InputStream_mark = 0; static void Java_InputStream_mark(JNIEnv* env, jobject obj, jint p0) __attribute__ ((unused)); static void Java_InputStream_mark(JNIEnv* env, jobject obj, jint p0) { /* Must call RegisterNativesImpl() */ DCHECK(g_InputStream_clazz); - DCHECK(g_InputStream_mark); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_InputStream_clazz, + "mark", + +"(" +"I" +")" +"V", + &g_InputStream_mark); env->CallVoidMethod(obj, - g_InputStream_mark, p0); + method_id, p0); base::android::CheckException(env); } -static jmethodID g_InputStream_markSupported = 0; +static base::subtle::AtomicWord g_InputStream_markSupported = 0; static jboolean Java_InputStream_markSupported(JNIEnv* env, jobject obj) __attribute__ ((unused)); static jboolean Java_InputStream_markSupported(JNIEnv* env, jobject obj) { /* Must call RegisterNativesImpl() */ DCHECK(g_InputStream_clazz); - DCHECK(g_InputStream_markSupported); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_InputStream_clazz, + "markSupported", + +"(" +")" +"Z", + &g_InputStream_markSupported); + jboolean ret = env->CallBooleanMethod(obj, - g_InputStream_markSupported); + method_id); base::android::CheckException(env); return ret; } -static jmethodID g_InputStream_readI = 0; +static base::subtle::AtomicWord g_InputStream_readI = 0; static jint Java_InputStream_readI(JNIEnv* env, jobject obj) __attribute__ ((unused)); static jint Java_InputStream_readI(JNIEnv* env, jobject obj) { /* Must call RegisterNativesImpl() */ DCHECK(g_InputStream_clazz); - DCHECK(g_InputStream_readI); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_InputStream_clazz, + "read", + +"(" +")" +"I", + &g_InputStream_readI); + jint ret = env->CallIntMethod(obj, - g_InputStream_readI); + method_id); base::android::CheckException(env); return ret; } -static jmethodID g_InputStream_readI_AB = 0; +static base::subtle::AtomicWord g_InputStream_readI_AB = 0; static jint Java_InputStream_readI_AB(JNIEnv* env, jobject obj, jbyteArray p0) __attribute__ ((unused)); static jint Java_InputStream_readI_AB(JNIEnv* env, jobject obj, jbyteArray p0) { /* Must call RegisterNativesImpl() */ DCHECK(g_InputStream_clazz); - DCHECK(g_InputStream_readI_AB); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_InputStream_clazz, + "read", + +"(" +"[B" +")" +"I", + &g_InputStream_readI_AB); + jint ret = env->CallIntMethod(obj, - g_InputStream_readI_AB, p0); + method_id, p0); base::android::CheckException(env); return ret; } -static jmethodID g_InputStream_readI_AB_I_I = 0; +static base::subtle::AtomicWord g_InputStream_readI_AB_I_I = 0; static jint Java_InputStream_readI_AB_I_I(JNIEnv* env, jobject obj, jbyteArray p0, jint p1, @@ -1312,161 +1359,105 @@ def testFromJavaP(self): jint p2) { /* Must call RegisterNativesImpl() */ DCHECK(g_InputStream_clazz); - DCHECK(g_InputStream_readI_AB_I_I); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_InputStream_clazz, + "read", + +"(" +"[B" +"I" +"I" +")" +"I", + &g_InputStream_readI_AB_I_I); + jint ret = env->CallIntMethod(obj, - g_InputStream_readI_AB_I_I, p0, p1, p2); + method_id, p0, p1, p2); base::android::CheckException(env); return ret; } -static jmethodID g_InputStream_reset = 0; +static base::subtle::AtomicWord g_InputStream_reset = 0; static void Java_InputStream_reset(JNIEnv* env, jobject obj) __attribute__ ((unused)); static void Java_InputStream_reset(JNIEnv* env, jobject obj) { /* Must call RegisterNativesImpl() */ DCHECK(g_InputStream_clazz); - DCHECK(g_InputStream_reset); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_InputStream_clazz, + "reset", + +"(" +")" +"V", + &g_InputStream_reset); env->CallVoidMethod(obj, - g_InputStream_reset); + method_id); base::android::CheckException(env); } -static jmethodID g_InputStream_skip = 0; +static base::subtle::AtomicWord g_InputStream_skip = 0; static jlong Java_InputStream_skip(JNIEnv* env, jobject obj, jlong p0) __attribute__ ((unused)); static jlong Java_InputStream_skip(JNIEnv* env, jobject obj, jlong p0) { /* Must call RegisterNativesImpl() */ DCHECK(g_InputStream_clazz); - DCHECK(g_InputStream_skip); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_InputStream_clazz, + "skip", + +"(" +"J" +")" +"J", + &g_InputStream_skip); + jlong ret = env->CallLongMethod(obj, - g_InputStream_skip, p0); + method_id, p0); base::android::CheckException(env); return ret; } -static jmethodID g_InputStream_Constructor = 0; +static base::subtle::AtomicWord g_InputStream_Constructor = 0; static ScopedJavaLocalRef Java_InputStream_Constructor(JNIEnv* env) -__attribute__ ((unused)); + __attribute__ ((unused)); static ScopedJavaLocalRef Java_InputStream_Constructor(JNIEnv* env) { /* Must call RegisterNativesImpl() */ DCHECK(g_InputStream_clazz); - DCHECK(g_InputStream_Constructor); + jmethodID method_id = + base::android::MethodID::LazyGet< + base::android::MethodID::TYPE_INSTANCE>( + env, g_InputStream_clazz, + "", + +"(" +")" +"V", + &g_InputStream_Constructor); + jobject ret = env->NewObject(g_InputStream_clazz, - g_InputStream_Constructor); + method_id); base::android::CheckException(env); return ScopedJavaLocalRef(env, ret); } -// Step 3: GetMethodIDs and RegisterNatives. -static void GetMethodIDsImpl(JNIEnv* env) { - g_InputStream_clazz = reinterpret_cast(env->NewGlobalRef( - base::android::GetUnscopedClass(env, kInputStreamClassPath))); - g_InputStream_available = - base::android::GetMethodIDOrNull( - env, g_InputStream_clazz, - "available", - -"(" -")" -"I"); - - g_InputStream_close = - base::android::GetMethodIDOrNull( - env, g_InputStream_clazz, - "close", - -"(" -")" -"V"); - - g_InputStream_mark = - base::android::GetMethodIDOrNull( - env, g_InputStream_clazz, - "mark", - -"(" -"I" -")" -"V"); - - g_InputStream_markSupported = - base::android::GetMethodIDOrNull( - env, g_InputStream_clazz, - "markSupported", - -"(" -")" -"Z"); - - g_InputStream_readI = - base::android::GetMethodIDOrNull( - env, g_InputStream_clazz, - "read", - -"(" -")" -"I"); - - g_InputStream_readI_AB = - base::android::GetMethodIDOrNull( - env, g_InputStream_clazz, - "read", - -"(" -"[B" -")" -"I"); - - g_InputStream_readI_AB_I_I = - base::android::GetMethodIDOrNull( - env, g_InputStream_clazz, - "read", - -"(" -"[B" -"I" -"I" -")" -"I"); - - g_InputStream_reset = - base::android::GetMethodIDOrNull( - env, g_InputStream_clazz, - "reset", - -"(" -")" -"V"); - - g_InputStream_skip = - base::android::GetMethodIDOrNull( - env, g_InputStream_clazz, - "skip", - -"(" -"J" -")" -"J"); - - g_InputStream_Constructor = - base::android::GetMethodIDOrNull( - env, g_InputStream_clazz, - "", - -"(" -")" -"V"); - -} +// Step 3: RegisterNatives. static bool RegisterNativesImpl(JNIEnv* env) { - GetMethodIDsImpl(env); + g_InputStream_clazz = reinterpret_cast(env->NewGlobalRef( + base::android::GetUnscopedClass(env, kInputStreamClassPath))); return true; } } // namespace JNI_InputStream diff --git a/base/android/locale_utils.cc b/base/android/locale_utils.cc index 2a7da8e8b94a99..60b8f8429ed39a 100644 --- a/base/android/locale_utils.cc +++ b/base/android/locale_utils.cc @@ -69,16 +69,17 @@ string16 GetDisplayNameForLocale(const std::string& locale, JNIEnv* env = AttachCurrentThread(); ScopedJavaLocalRef locale_class = GetClass(env, "java/util/Locale"); - jmethodID constructor_id = GetMethodID( - env, locale_class, "", + jmethodID constructor_id = MethodID::Get( + env, locale_class.obj(), "", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V"); ScopedJavaLocalRef java_locale = NewJavaLocale( env, locale_class, constructor_id, locale); ScopedJavaLocalRef java_display_locale = NewJavaLocale( env, locale_class, constructor_id, display_locale); - jmethodID method_id = GetMethodID(env, locale_class, "getDisplayName", - "(Ljava/util/Locale;)Ljava/lang/String;"); + jmethodID method_id = MethodID::Get( + env, locale_class.obj(), "getDisplayName", + "(Ljava/util/Locale;)Ljava/lang/String;"); ScopedJavaLocalRef java_result( env, static_cast(env->CallObjectMethod(java_locale.obj(), method_id, diff --git a/chrome/browser/android/chrome_web_contents_delegate_android.cc b/chrome/browser/android/chrome_web_contents_delegate_android.cc index a063d6d6512530..7ce880dfd7a2ff 100644 --- a/chrome/browser/android/chrome_web_contents_delegate_android.cc +++ b/chrome/browser/android/chrome_web_contents_delegate_android.cc @@ -24,6 +24,7 @@ using base::android::AttachCurrentThread; using base::android::GetClass; +using base::android::MethodID; using base::android::ScopedJavaLocalRef; using content::FileChooserParams; using content::WebContents; @@ -142,8 +143,8 @@ void ChromeWebContentsDelegateAndroid::OnFindResultAvailable( ScopedJavaLocalRef rect_clazz = GetClass(env, "android/graphics/Rect"); - jmethodID rect_constructor = - GetMethodID(env, rect_clazz, "", "(IIII)V"); + jmethodID rect_constructor = MethodID::Get( + env, rect_clazz.obj(), "", "(IIII)V"); ScopedJavaLocalRef selection_rect = CreateAndroidRect( env, rect_clazz, rect_constructor, find_result->selection_rect()); @@ -152,8 +153,8 @@ void ChromeWebContentsDelegateAndroid::OnFindResultAvailable( ScopedJavaLocalRef details_clazz = GetClass(env, "org/chromium/chrome/browser/FindNotificationDetails"); - jmethodID details_constructor = GetMethodID(env, details_clazz, "", - "(ILandroid/graphics/Rect;IZ)V"); + jmethodID details_constructor = MethodID::Get( + env, details_clazz.obj(), "", "(ILandroid/graphics/Rect;IZ)V"); ScopedJavaLocalRef details_object( env, @@ -191,8 +192,8 @@ void ChromeWebContentsDelegateAndroid::FindMatchRectsReply( ScopedJavaLocalRef rect_clazz = GetClass(env, "android/graphics/RectF"); - jmethodID rect_constructor = - GetMethodID(env, rect_clazz, "", "(FFFF)V"); + jmethodID rect_constructor = MethodID::Get( + env, rect_clazz.obj(), "", "(FFFF)V"); ScopedJavaLocalRef jrects(env, env->NewObjectArray( match_rects.rects().size(), rect_clazz.obj(), NULL)); @@ -213,7 +214,8 @@ void ChromeWebContentsDelegateAndroid::FindMatchRectsReply( ScopedJavaLocalRef details_clazz = GetClass(env, "org/chromium/chrome/browser/FindMatchRectsDetails"); - jmethodID details_constructor = GetMethodID(env, details_clazz, "", + jmethodID details_constructor = MethodID::Get( + env, details_clazz.obj(), "", "(I[Landroid/graphics/RectF;Landroid/graphics/RectF;)V"); ScopedJavaLocalRef details_object( diff --git a/chrome/browser/android/provider/chrome_browser_provider.cc b/chrome/browser/android/provider/chrome_browser_provider.cc index fd10a9fa9d2191..5cb9fa2d02fdac 100644 --- a/chrome/browser/android/provider/chrome_browser_provider.cc +++ b/chrome/browser/android/provider/chrome_browser_provider.cc @@ -48,7 +48,7 @@ using base::android::ConvertJavaStringToUTF8; using base::android::ConvertUTF8ToJavaString; using base::android::ConvertUTF16ToJavaString; using base::android::GetClass; -using base::android::GetMethodID; +using base::android::MethodID; using base::android::JavaRef; using base::android::ScopedJavaGlobalRef; using base::android::ScopedJavaLocalRef; @@ -119,15 +119,16 @@ void ConvertBookmarkNode( jlong ConvertJLongObjectToPrimitive(JNIEnv* env, jobject long_obj) { ScopedJavaLocalRef jlong_clazz = GetClass(env, "java/lang/Long"); - jmethodID long_value = GetMethodID(env, jlong_clazz, "longValue", "()J"); + jmethodID long_value = MethodID::Get( + env, jlong_clazz.obj(), "longValue", "()J"); return env->CallLongMethod(long_obj, long_value, NULL); } jboolean ConvertJBooleanObjectToPrimitive(JNIEnv* env, jobject boolean_object) { ScopedJavaLocalRef jboolean_clazz = GetClass(env, "java/lang/Boolean"); - jmethodID boolean_value = - GetMethodID(env, jboolean_clazz, "booleanValue", "()Z"); + jmethodID boolean_value = MethodID::Get( + env, jboolean_clazz.obj(), "booleanValue", "()Z"); return env->CallBooleanMethod(boolean_object, boolean_value, NULL); } @@ -139,7 +140,8 @@ base::Time ConvertJlongToTime(jlong value) { jint ConvertJIntegerToJint(JNIEnv* env, jobject integer_obj) { ScopedJavaLocalRef jinteger_clazz = GetClass(env, "java/lang/Integer"); - jmethodID int_value = GetMethodID(env, jinteger_clazz, "intValue", "()I"); + jmethodID int_value = MethodID::Get( + env, jinteger_clazz.obj(), "intValue", "()I"); return env->CallIntMethod(integer_obj, int_value, NULL); } diff --git a/chrome/browser/history/android/sqlite_cursor.cc b/chrome/browser/history/android/sqlite_cursor.cc index 786e157c7e0909..883b0999b61bd3 100644 --- a/chrome/browser/history/android/sqlite_cursor.cc +++ b/chrome/browser/history/android/sqlite_cursor.cc @@ -16,8 +16,7 @@ using base::android::ConvertUTF8ToJavaString; using base::android::GetClass; using base::android::HasClass; -using base::android::HasMethod; -using base::android::GetMethodID; +using base::android::MethodID; using base::android::ScopedJavaLocalRef; using content::BrowserThread; @@ -62,12 +61,9 @@ ScopedJavaLocalRef SQLiteCursor::NewJavaSqliteCursor( } ScopedJavaLocalRef sclass = GetClass(env, kSQLiteCursorClassPath); - if (!HasMethod(env, sclass, "", "(I)V")) { - LOG(ERROR) << "Can not find " << kSQLiteCursorClassPath << " Constructor"; - return ScopedJavaLocalRef(); - } + jmethodID method_id = MethodID::Get( + env, sclass.obj(), "", "(I)V"); - jmethodID method_id = GetMethodID(env, sclass, "", "(I)V"); SQLiteCursor* cursor = new SQLiteCursor(column_names, statement, service, favicon_service); ScopedJavaLocalRef obj(env, diff --git a/content/browser/android/content_view_core_impl.cc b/content/browser/android/content_view_core_impl.cc index 244a1068292220..9120e66bc572d0 100644 --- a/content/browser/android/content_view_core_impl.cc +++ b/content/browser/android/content_view_core_impl.cc @@ -50,6 +50,7 @@ using base::android::ConvertUTF16ToJavaString; using base::android::ConvertUTF8ToJavaString; using base::android::GetClass; using base::android::HasField; +using base::android::MethodID; using base::android::JavaByteArrayToByteVector; using base::android::ScopedJavaGlobalRef; using base::android::ScopedJavaLocalRef; @@ -228,8 +229,8 @@ void ContentViewCoreImpl::Observe(int type, void ContentViewCoreImpl::InitJNI(JNIEnv* env, jobject obj) { java_object_ = new JavaObject; java_object_->rect_clazz.Reset(GetClass(env, "android/graphics/Rect")); - java_object_->rect_constructor = - GetMethodID(env, java_object_->rect_clazz, "", "(IIII)V"); + java_object_->rect_constructor = MethodID::Get( + env, java_object_->rect_clazz.obj(), "", "(IIII)V"); } RenderWidgetHostViewAndroid* diff --git a/content/browser/android/download_controller_android_impl.cc b/content/browser/android/download_controller_android_impl.cc index 95eb567f997473..762f13bbc61094 100644 --- a/content/browser/android/download_controller_android_impl.cc +++ b/content/browser/android/download_controller_android_impl.cc @@ -29,6 +29,7 @@ using base::android::AttachCurrentThread; using base::android::CheckException; using base::android::ConvertUTF8ToJavaString; using base::android::GetClass; +using base::android::MethodID; using base::android::ScopedJavaLocalRef; namespace { @@ -310,7 +311,8 @@ DownloadControllerAndroidImpl::JavaObject* JNIEnv* env = AttachCurrentThread(); ScopedJavaLocalRef clazz = GetClass(env, kDownloadControllerClassPathName); - jmethodID get_instance = GetStaticMethodID(env, clazz, "getInstance", + jmethodID get_instance = MethodID::Get( + env, clazz.obj(), "getInstance", "()Lorg/chromium/content/browser/DownloadController;"); ScopedJavaLocalRef jobj(env, env->CallStaticObjectMethod(clazz.obj(), get_instance)); diff --git a/content/browser/android/surface_texture_peer_browser_impl.cc b/content/browser/android/surface_texture_peer_browser_impl.cc index 4a412592e1a15d..70dcf1a7ba83d7 100644 --- a/content/browser/android/surface_texture_peer_browser_impl.cc +++ b/content/browser/android/surface_texture_peer_browser_impl.cc @@ -12,6 +12,8 @@ #include "jni/BrowserProcessSurfaceTexture_jni.h" #include "media/base/android/media_player_bridge.h" +using base::android::MethodID; + namespace content { // Pass a java surface object to the MediaPlayerBridge object @@ -43,11 +45,12 @@ static void SetSurfacePeer( player != host->media_player_manager()->GetFullscreenPlayer()) { base::android::ScopedJavaLocalRef cls( base::android::GetClass(env, "android/view/Surface")); - jmethodID constructor = GetMethodID(env, cls, "", - "(Landroid/graphics/SurfaceTexture;)V"); - ScopedJavaLocalRef j_surface(env, - env->NewObject(cls.obj(), constructor, - surface_texture_bridge->j_surface_texture().obj())); + jmethodID constructor = MethodID::Get( + env, cls.obj(), "", "(Landroid/graphics/SurfaceTexture;)V"); + ScopedJavaLocalRef j_surface( + env, env->NewObject( + cls.obj(), constructor, + surface_texture_bridge->j_surface_texture().obj())); player->SetVideoSurface(j_surface.obj()); ReleaseSurface(j_surface.obj()); } diff --git a/content/browser/device_orientation/data_fetcher_impl_android.cc b/content/browser/device_orientation/data_fetcher_impl_android.cc index 12dc0f0d4181d4..7e432cf4412661 100644 --- a/content/browser/device_orientation/data_fetcher_impl_android.cc +++ b/content/browser/device_orientation/data_fetcher_impl_android.cc @@ -14,7 +14,6 @@ using base::android::AttachCurrentThread; using base::android::CheckException; using base::android::GetClass; -using base::android::GetMethodID; using base::android::ScopedJavaGlobalRef; using base::android::ScopedJavaLocalRef; diff --git a/content/browser/geolocation/location_api_adapter_android.cc b/content/browser/geolocation/location_api_adapter_android.cc index 6028a430526cc2..0e71a9f9f3ff57 100644 --- a/content/browser/geolocation/location_api_adapter_android.cc +++ b/content/browser/geolocation/location_api_adapter_android.cc @@ -14,7 +14,6 @@ using base::android::AttachCurrentThread; using base::android::CheckException; using base::android::ClearException; -using base::android::GetMethodID; static void NewLocationAvailable(JNIEnv* env, jclass, jdouble latitude, diff --git a/content/browser/renderer_host/java/java_method.cc b/content/browser/renderer_host/java/java_method.cc index 6f6878c790a94d..4d770f3196ffc8 100644 --- a/content/browser/renderer_host/java/java_method.cc +++ b/content/browser/renderer_host/java/java_method.cc @@ -13,9 +13,8 @@ using base::android::AttachCurrentThread; using base::android::ConvertJavaStringToUTF8; using base::android::GetClass; -using base::android::GetMethodID; using base::android::GetMethodIDFromClassName; -using base::android::GetStaticMethodID; +using base::android::MethodID; using base::android::ScopedJavaGlobalRef; using base::android::ScopedJavaLocalRef; @@ -214,9 +213,9 @@ void JavaMethod::EnsureTypesAndIDAreSetUp() const { kReturningInteger)); bool is_static = env->CallStaticBooleanMethod( g_java_lang_reflect_modifier_class.Get().obj(), - GetStaticMethodID(env, g_java_lang_reflect_modifier_class.Get(), - kIsStatic, - kIntegerReturningBoolean), + MethodID::Get( + env, g_java_lang_reflect_modifier_class.Get().obj(), kIsStatic, + kIntegerReturningBoolean), modifiers); // Get the ID for this method. @@ -227,8 +226,9 @@ void JavaMethod::EnsureTypesAndIDAreSetUp() const { kGetDeclaringClass, kReturningJavaLangClass)))); id_ = is_static ? - GetStaticMethodID(env, declaring_class, name_.c_str(), - signature.c_str()) : - GetMethodID(env, declaring_class, name_.c_str(), signature.c_str()); + MethodID::Get( + env, declaring_class.obj(), name_.c_str(), signature.c_str()) : + MethodID::Get( + env, declaring_class.obj(), name_.c_str(), signature.c_str()); java_method_.Reset(); } diff --git a/content/common/android/surface_callback.cc b/content/common/android/surface_callback.cc index 77757e99ec92d4..7bfd033f533471 100644 --- a/content/common/android/surface_callback.cc +++ b/content/common/android/surface_callback.cc @@ -19,7 +19,8 @@ using base::android::AttachCurrentThread; using base::android::CheckException; -using base::android::GetMethodID; +using base::android::GetClass; +using base::android::MethodID; using base::WaitableEvent; using content::SurfaceTexturePeer; @@ -76,16 +77,12 @@ void ReleaseSurface(jobject surface) { JNIEnv* env = AttachCurrentThread(); CHECK(env); - jclass cls = env->FindClass("android/view/Surface"); - DCHECK(cls); + ScopedJavaLocalRef cls(GetClass(env, "android/view/Surface")); - jmethodID method = env->GetMethodID(cls, "release", "()V"); - DCHECK(method); + jmethodID method = MethodID::Get( + env, cls.obj(), "release", "()V"); env->CallVoidMethod(surface, method); - DCHECK(env); - - env->DeleteLocalRef(cls); } void SetSurfaceAsync(JNIEnv* env, diff --git a/content/common/android/surface_texture_bridge.cc b/content/common/android/surface_texture_bridge.cc index bc17c13fff9952..8f640f8e22fd90 100644 --- a/content/common/android/surface_texture_bridge.cc +++ b/content/common/android/surface_texture_bridge.cc @@ -12,7 +12,6 @@ using base::android::AttachCurrentThread; using base::android::CheckException; using base::android::GetClass; -using base::android::GetMethodID; using base::android::ScopedJavaLocalRef; namespace { diff --git a/media/base/android/media_player_bridge.cc b/media/base/android/media_player_bridge.cc index 96b2005670ec80..af24c521a8f54e 100644 --- a/media/base/android/media_player_bridge.cc +++ b/media/base/android/media_player_bridge.cc @@ -19,7 +19,7 @@ using base::android::AttachCurrentThread; using base::android::CheckException; using base::android::ConvertUTF8ToJavaString; using base::android::GetClass; -using base::android::GetMethodID; +using base::android::MethodID; using base::android::JavaRef; using base::android::ScopedJavaLocalRef; @@ -318,8 +318,8 @@ void MediaPlayerBridge::GetMetadata() { ScopedJavaLocalRef media_player_class( GetClass(env, "android/media/MediaPlayer")); - jmethodID method = GetMethodID( - env, media_player_class, "getMetadata", + jmethodID method = MethodID::Get( + env, media_player_class.obj(), "getMetadata", "(ZZ)Landroid/media/Metadata;"); ScopedJavaLocalRef j_metadata( env, env->CallObjectMethod( @@ -330,8 +330,8 @@ void MediaPlayerBridge::GetMetadata() { ScopedJavaLocalRef metadata_class( GetClass(env, "android/media/Metadata")); - jmethodID get_boolean = GetMethodID( - env, metadata_class, "getBoolean", "(I)Z"); + jmethodID get_boolean = MethodID::Get( + env, metadata_class.obj(), "getBoolean", "(I)Z"); can_pause_ = env->CallBooleanMethod(j_metadata.obj(), get_boolean, kPauseAvailable); diff --git a/net/proxy/proxy_config_service_android.cc b/net/proxy/proxy_config_service_android.cc index 6a0be78d020561..6f23f7e85d59f2 100644 --- a/net/proxy/proxy_config_service_android.cc +++ b/net/proxy/proxy_config_service_android.cc @@ -28,7 +28,6 @@ using base::android::ConvertUTF8ToJavaString; using base::android::ConvertJavaStringToUTF8; using base::android::CheckException; using base::android::ClearException; -using base::android::GetMethodID; using base::android::ScopedJavaGlobalRef; namespace net { diff --git a/sync/util/session_utils_android.cc b/sync/util/session_utils_android.cc index 69f1ae448a2581..7be415d1b771cf 100644 --- a/sync/util/session_utils_android.cc +++ b/sync/util/session_utils_android.cc @@ -17,6 +17,7 @@ using base::android::CheckException; using base::android::ConvertUTF8ToJavaString; using base::android::GetApplicationContext; using base::android::GetClass; +using base::android::MethodID; using base::android::JavaRef; using base::android::ScopedJavaLocalRef; @@ -26,9 +27,10 @@ ScopedJavaLocalRef GetAndroidIdJNI( JNIEnv* env, const JavaRef& content_resolver) { ScopedJavaLocalRef clazz( GetClass(env, "android/provider/Settings$Secure")); - jmethodID j_get_string = GetStaticMethodID(env, clazz, "getString", + jmethodID j_get_string = MethodID::Get( + env, clazz.obj(), "getString", "(Landroid/content/ContentResolver;Ljava/lang/String;)" - "Ljava/lang/String;"); + "Ljava/lang/String;"); ScopedJavaLocalRef j_android_id = ConvertUTF8ToJavaString(env, "android_id"); jstring android_id = static_cast( @@ -41,8 +43,10 @@ ScopedJavaLocalRef GetAndroidIdJNI( ScopedJavaLocalRef GetContentResolver(JNIEnv* env) { ScopedJavaLocalRef clazz(GetClass(env, "android/content/Context")); - jmethodID j_get_content_resolver_method = GetMethodID( - env, clazz,"getContentResolver", "()Landroid/content/ContentResolver;"); + jmethodID j_get_content_resolver_method = MethodID::Get< + MethodID::TYPE_INSTANCE>( + env, clazz.obj(), "getContentResolver", + "()Landroid/content/ContentResolver;"); jobject content_resolver = env->CallObjectMethod( GetApplicationContext(), j_get_content_resolver_method); CheckException(env); diff --git a/ui/base/clipboard/clipboard_android.cc b/ui/base/clipboard/clipboard_android.cc index 19d57528bbcdef..4d310fbb940082 100644 --- a/ui/base/clipboard/clipboard_android.cc +++ b/ui/base/clipboard/clipboard_android.cc @@ -25,7 +25,7 @@ using base::android::ClearException; using base::android::ConvertJavaStringToUTF16; using base::android::ConvertJavaStringToUTF8; using base::android::GetClass; -using base::android::GetMethodID; +using base::android::MethodID; using base::android::ScopedJavaLocalRef; namespace ui { @@ -75,8 +75,9 @@ ClipboardMap::ClipboardMap() { GetClass(env, "android/content/Context"); // Get the system service method. - jmethodID get_system_service = GetMethodID(env, context_class, - "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;"); + jmethodID get_system_service = MethodID::Get( + env, context_class.obj(), "getSystemService", + "(Ljava/lang/String;)Ljava/lang/Object;"); // Retrieve the system service. ScopedJavaLocalRef service_name(env, env->NewStringUTF("clipboard")); @@ -87,18 +88,18 @@ ClipboardMap::ClipboardMap() { // Retain a few methods we'll keep using. ScopedJavaLocalRef clipboard_class = GetClass(env, "android/text/ClipboardManager"); - set_text_ = GetMethodID(env, clipboard_class, - "setText", "(Ljava/lang/CharSequence;)V"); - get_text_ = GetMethodID(env, clipboard_class, - "getText", "()Ljava/lang/CharSequence;"); - has_text_ = GetMethodID(env, clipboard_class, - "hasText", "()Z"); + set_text_ = MethodID::Get( + env, clipboard_class.obj(), "setText", "(Ljava/lang/CharSequence;)V"); + get_text_ = MethodID::Get( + env, clipboard_class.obj(), "getText", "()Ljava/lang/CharSequence;"); + has_text_ = MethodID::Get( + env, clipboard_class.obj(), "hasText", "()Z"); // Will need to call toString as CharSequence is not always a String. ScopedJavaLocalRef charsequence_class = GetClass(env, "java/lang/CharSequence"); - to_string_ = GetMethodID(env, charsequence_class, - "toString", "()Ljava/lang/String;"); + to_string_ = MethodID::Get( + env, charsequence_class.obj(), "toString", "()Ljava/lang/String;"); } std::string ClipboardMap::Get(const std::string& format) { diff --git a/ui/base/clipboard/clipboard_unittest.cc b/ui/base/clipboard/clipboard_unittest.cc index e8b3d39665348f..14a89154679bc8 100644 --- a/ui/base/clipboard/clipboard_unittest.cc +++ b/ui/base/clipboard/clipboard_unittest.cc @@ -646,6 +646,7 @@ TEST_F(ClipboardTest, InternalClipboardInvalidation) { // Simulate that another application copied something in the Clipboard // std::string new_value("Some text copied by some other app"); + using base::android::MethodID; using base::android::ScopedJavaLocalRef; JNIEnv* env = base::android::AttachCurrentThread(); @@ -657,8 +658,9 @@ TEST_F(ClipboardTest, InternalClipboardInvalidation) { ScopedJavaLocalRef context_class = base::android::GetClass(env, "android/content/Context"); - jmethodID get_system_service = base::android::GetMethodID(env, context_class, - "getSystemService", "(Ljava/lang/String;)Ljava/lang/Object;"); + jmethodID get_system_service = MethodID::Get( + env, context_class.obj(), "getSystemService", + "(Ljava/lang/String;)Ljava/lang/Object;"); // Retrieve the system service. ScopedJavaLocalRef service_name(env, env->NewStringUTF("clipboard")); @@ -669,8 +671,8 @@ TEST_F(ClipboardTest, InternalClipboardInvalidation) { ScopedJavaLocalRef clipboard_class = base::android::GetClass(env, "android/text/ClipboardManager"); - jmethodID set_text = base::android::GetMethodID(env, clipboard_class, - "setText", "(Ljava/lang/CharSequence;)V"); + jmethodID set_text = MethodID::Get( + env, clipboard_class.obj(), "setText", "(Ljava/lang/CharSequence;)V"); // Will need to call toString as CharSequence is not always a String. env->CallVoidMethod(clipboard_manager.obj(), diff --git a/webkit/glue/fling_animator_impl_android.cc b/webkit/glue/fling_animator_impl_android.cc index d663cb73d57f9d..56e7e8ba0ebc61 100644 --- a/webkit/glue/fling_animator_impl_android.cc +++ b/webkit/glue/fling_animator_impl_android.cc @@ -8,7 +8,12 @@ #include "base/android/scoped_java_ref.h" #include "base/logging.h" -using namespace base::android; +using base::android::AttachCurrentThread; +using base::android::CheckException; +using base::android::GetApplicationContext; +using base::android::GetClass; +using base::android::MethodID; +using base::android::ScopedJavaLocalRef; namespace webkit_glue { @@ -18,18 +23,23 @@ FlingAnimatorImpl::FlingAnimatorImpl() JNIEnv* env = AttachCurrentThread(); DCHECK(env); ScopedJavaLocalRef cls(GetClass(env, "android/widget/OverScroller")); - jmethodID constructor = GetMethodID(env, cls, "", - "(Landroid/content/Context;)V"); + jmethodID constructor = MethodID::Get( + env, cls.obj(), "", "(Landroid/content/Context;)V"); ScopedJavaLocalRef tmp(env, env->NewObject(cls.obj(), constructor, GetApplicationContext())); DCHECK(tmp.obj()); java_scroller_.Reset(tmp); - fling_method_id_ = GetMethodID(env, cls, "fling", "(IIIIIIII)V"); - abort_method_id_ = GetMethodID(env, cls, "abortAnimation", "()V"); - compute_method_id_ = GetMethodID(env, cls, "computeScrollOffset", "()Z"); - getX_method_id_ = GetMethodID(env, cls, "getCurrX", "()I"); - getY_method_id_ = GetMethodID(env, cls, "getCurrY", "()I"); + fling_method_id_ = MethodID::Get( + env, cls.obj(), "fling", "(IIIIIIII)V"); + abort_method_id_ = MethodID::Get( + env, cls.obj(), "abortAnimation", "()V"); + compute_method_id_ = MethodID::Get( + env, cls.obj(), "computeScrollOffset", "()Z"); + getX_method_id_ = MethodID::Get( + env, cls.obj(), "getCurrX", "()I"); + getY_method_id_ = MethodID::Get( + env, cls.obj(), "getCurrY", "()I"); } FlingAnimatorImpl::~FlingAnimatorImpl()