diff options
196 files changed, 1761 insertions, 1138 deletions
diff --git a/android_webview/native/android_protocol_handler.cc b/android_webview/native/android_protocol_handler.cc index e25b36d..a2a9f6d 100644 --- a/android_webview/native/android_protocol_handler.cc +++ b/android_webview/native/android_protocol_handler.cc @@ -272,8 +272,9 @@ scoped_ptr<net::URLRequestInterceptor> CreateAssetFileRequestInterceptor() { // // |context| should be a android.content.Context instance or NULL to enable // the use of the standard application context. -static void SetResourceContextForTesting(JNIEnv* env, jclass /*clazz*/, - jobject context) { +static void SetResourceContextForTesting(JNIEnv* env, + const JavaParamRef<jclass>& /*clazz*/, + const JavaParamRef<jobject>& context) { if (context) { ResetResourceContext(new JavaObjectWeakGlobalRef(env, context)); } else { @@ -281,13 +282,15 @@ static void SetResourceContextForTesting(JNIEnv* env, jclass /*clazz*/, } } -static ScopedJavaLocalRef<jstring> GetAndroidAssetPath(JNIEnv* env, - jclass /*clazz*/) { +static ScopedJavaLocalRef<jstring> GetAndroidAssetPath( + JNIEnv* env, + const JavaParamRef<jclass>& /*clazz*/) { return ConvertUTF8ToJavaString(env, android_webview::kAndroidAssetPath); } -static ScopedJavaLocalRef<jstring> GetAndroidResourcePath(JNIEnv* env, - jclass /*clazz*/) { +static ScopedJavaLocalRef<jstring> GetAndroidResourcePath( + JNIEnv* env, + const JavaParamRef<jclass>& /*clazz*/) { return ConvertUTF8ToJavaString(env, android_webview::kAndroidResourcePath); } diff --git a/android_webview/native/aw_contents.cc b/android_webview/native/aw_contents.cc index 10c21da..c89fe17 100644 --- a/android_webview/native/aw_contents.cc +++ b/android_webview/native/aw_contents.cc @@ -163,7 +163,9 @@ AwContents* AwContents::FromID(int render_process_id, int render_view_id) { } // static -void SetLocale(JNIEnv* env, jclass, jstring locale) { +void SetLocale(JNIEnv* env, + const JavaParamRef<jclass>&, + const JavaParamRef<jstring>& locale) { g_locale = ConvertJavaStringToUTF8(env, locale); } @@ -330,7 +332,9 @@ void AwContents::Destroy(JNIEnv* env, jobject obj) { delete this; } -static jlong Init(JNIEnv* env, jclass, jobject browser_context) { +static jlong Init(JNIEnv* env, + const JavaParamRef<jclass>&, + const JavaParamRef<jobject>& browser_context) { // TODO(joth): Use |browser_context| to get the native BrowserContext, rather // than hard-code the default instance lookup here. scoped_ptr<WebContents> web_contents(content::WebContents::Create( @@ -342,27 +346,28 @@ static jlong Init(JNIEnv* env, jclass, jobject browser_context) { static void SetForceAuxiliaryBitmapRendering( JNIEnv* env, - jclass, + const JavaParamRef<jclass>&, jboolean force_auxiliary_bitmap_rendering) { g_force_auxiliary_bitmap_rendering = force_auxiliary_bitmap_rendering; } -static void SetAwDrawSWFunctionTable(JNIEnv* env, jclass, +static void SetAwDrawSWFunctionTable(JNIEnv* env, + const JavaParamRef<jclass>&, jlong function_table) { RasterHelperSetAwDrawSWFunctionTable( reinterpret_cast<AwDrawSWFunctionTable*>(function_table)); } -static void SetAwDrawGLFunctionTable(JNIEnv* env, jclass, - jlong function_table) { -} +static void SetAwDrawGLFunctionTable(JNIEnv* env, + const JavaParamRef<jclass>&, + jlong function_table) {} -static jlong GetAwDrawGLFunction(JNIEnv* env, jclass) { +static jlong GetAwDrawGLFunction(JNIEnv* env, const JavaParamRef<jclass>&) { return reinterpret_cast<intptr_t>(&DrawGLFunction); } // static -jint GetNativeInstanceCount(JNIEnv* env, jclass) { +jint GetNativeInstanceCount(JNIEnv* env, const JavaParamRef<jclass>&) { return base::subtle::NoBarrier_Load(&g_instance_count); } @@ -1215,7 +1220,8 @@ void AwContents::GrantFileSchemeAccesstoChildProcess(JNIEnv* env, jobject obj) { web_contents_->GetRenderProcessHost()->GetID(), url::kFileScheme); } -void SetShouldDownloadFavicons(JNIEnv* env, jclass jclazz) { +void SetShouldDownloadFavicons(JNIEnv* env, + const JavaParamRef<jclass>& jclazz) { g_should_download_favicons = true; } diff --git a/android_webview/native/aw_contents_statics.cc b/android_webview/native/aw_contents_statics.cc index 11e39b5..50bb9bf 100644 --- a/android_webview/native/aw_contents_statics.cc +++ b/android_webview/native/aw_contents_statics.cc @@ -39,7 +39,9 @@ void NotifyClientCertificatesChanged() { } // namespace // static -void ClearClientCertPreferences(JNIEnv* env, jclass, jobject callback) { +void ClearClientCertPreferences(JNIEnv* env, + const JavaParamRef<jclass>&, + const JavaParamRef<jobject>& callback) { DCHECK_CURRENTLY_ON(content::BrowserThread::UI); ScopedJavaGlobalRef<jobject>* j_callback = new ScopedJavaGlobalRef<jobject>(); j_callback->Reset(env, callback); @@ -51,7 +53,9 @@ void ClearClientCertPreferences(JNIEnv* env, jclass, jobject callback) { } // static -void SetDataReductionProxyKey(JNIEnv* env, jclass, jstring key) { +void SetDataReductionProxyKey(JNIEnv* env, + const JavaParamRef<jclass>&, + const JavaParamRef<jstring>& key) { AwBrowserContext* browser_context = AwBrowserContext::GetDefault(); DCHECK(browser_context); DCHECK(browser_context->GetRequestContext()); @@ -72,28 +76,37 @@ void SetDataReductionProxyKey(JNIEnv* env, jclass, jstring key) { } // static -void SetDataReductionProxyEnabled(JNIEnv* env, jclass, jboolean enabled) { +void SetDataReductionProxyEnabled(JNIEnv* env, + const JavaParamRef<jclass>&, + jboolean enabled) { AwBrowserContext::SetDataReductionProxyEnabled(enabled); } // static -ScopedJavaLocalRef<jstring> GetUnreachableWebDataUrl(JNIEnv* env, jclass) { +ScopedJavaLocalRef<jstring> GetUnreachableWebDataUrl( + JNIEnv* env, + const JavaParamRef<jclass>&) { return base::android::ConvertUTF8ToJavaString( env, content::kUnreachableWebDataURL); } // static -void SetRecordFullDocument(JNIEnv* env, jclass, jboolean record_full_document) { +void SetRecordFullDocument(JNIEnv* env, + const JavaParamRef<jclass>&, + jboolean record_full_document) { content::SynchronousCompositor::SetRecordFullDocument(record_full_document); } // static -void SetLegacyCacheRemovalDelayForTest(JNIEnv*, jclass, jlong delay_ms) { +void SetLegacyCacheRemovalDelayForTest(JNIEnv*, + const JavaParamRef<jclass>&, + jlong delay_ms) { AwBrowserContext::SetLegacyCacheRemovalDelayForTest(delay_ms); } // static -ScopedJavaLocalRef<jstring> GetProductVersion(JNIEnv* env, jclass) { +ScopedJavaLocalRef<jstring> GetProductVersion(JNIEnv* env, + const JavaParamRef<jclass>&) { return base::android::ConvertUTF8ToJavaString(env, PRODUCT_VERSION); } diff --git a/android_webview/native/aw_dev_tools_server.cc b/android_webview/native/aw_dev_tools_server.cc index 6b3e82a..41b4994 100644 --- a/android_webview/native/aw_dev_tools_server.cc +++ b/android_webview/native/aw_dev_tools_server.cc @@ -157,17 +157,19 @@ bool RegisterAwDevToolsServer(JNIEnv* env) { } static jlong InitRemoteDebugging(JNIEnv* env, - jobject obj) { + const JavaParamRef<jobject>& obj) { AwDevToolsServer* server = new AwDevToolsServer(); return reinterpret_cast<intptr_t>(server); } -static void DestroyRemoteDebugging(JNIEnv* env, jobject obj, jlong server) { +static void DestroyRemoteDebugging(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jlong server) { delete reinterpret_cast<AwDevToolsServer*>(server); } static void SetRemoteDebuggingEnabled(JNIEnv* env, - jobject obj, + const JavaParamRef<jobject>& obj, jlong server, jboolean enabled) { AwDevToolsServer* devtools_server = diff --git a/android_webview/native/aw_form_database.cc b/android_webview/native/aw_form_database.cc index 2269d76..8e31e88 100644 --- a/android_webview/native/aw_form_database.cc +++ b/android_webview/native/aw_form_database.cc @@ -26,12 +26,12 @@ AwFormDatabaseService* GetFormDatabaseService() { } // anonymous namespace // static -jboolean HasFormData(JNIEnv*, jclass) { +jboolean HasFormData(JNIEnv*, const JavaParamRef<jclass>&) { return GetFormDatabaseService()->HasFormData(); } // static -void ClearFormData(JNIEnv*, jclass) { +void ClearFormData(JNIEnv*, const JavaParamRef<jclass>&) { GetFormDatabaseService()->ClearFormData(); } diff --git a/android_webview/native/aw_message_port_service_impl.cc b/android_webview/native/aw_message_port_service_impl.cc index 969842d..cbbe282 100644 --- a/android_webview/native/aw_message_port_service_impl.cc +++ b/android_webview/native/aw_message_port_service_impl.cc @@ -231,7 +231,7 @@ bool RegisterAwMessagePortService(JNIEnv* env) { } // static -jlong InitAwMessagePortService(JNIEnv* env, jobject obj) { +jlong InitAwMessagePortService(JNIEnv* env, const JavaParamRef<jobject>& obj) { AwMessagePortServiceImpl* service = AwMessagePortServiceImpl::GetInstance(); service->Init(env, obj); return reinterpret_cast<intptr_t>(service); diff --git a/android_webview/native/aw_quota_manager_bridge_impl.cc b/android_webview/native/aw_quota_manager_bridge_impl.cc index 1f01530..abf791e 100644 --- a/android_webview/native/aw_quota_manager_bridge_impl.cc +++ b/android_webview/native/aw_quota_manager_bridge_impl.cc @@ -155,7 +155,8 @@ void RunOnUIThread(const base::Closure& task) { // static -jlong GetDefaultNativeAwQuotaManagerBridge(JNIEnv* env, jclass clazz) { +jlong GetDefaultNativeAwQuotaManagerBridge(JNIEnv* env, + const JavaParamRef<jclass>& clazz) { AwBrowserContext* browser_context = AwContentBrowserClient::GetAwBrowserContext(); diff --git a/android_webview/native/aw_settings.cc b/android_webview/native/aw_settings.cc index a5ae993..f708da6 100644 --- a/android_webview/native/aw_settings.cc +++ b/android_webview/native/aw_settings.cc @@ -421,16 +421,17 @@ void AwSettings::PopulateWebPreferencesLocked( } static jlong Init(JNIEnv* env, - jobject obj, - jobject web_contents) { + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& web_contents) { content::WebContents* contents = content::WebContents::FromJavaWebContents( web_contents); AwSettings* settings = new AwSettings(env, obj, contents); return reinterpret_cast<intptr_t>(settings); } -static ScopedJavaLocalRef<jstring> GetDefaultUserAgent(JNIEnv* env, - jclass clazz) { +static ScopedJavaLocalRef<jstring> GetDefaultUserAgent( + JNIEnv* env, + const JavaParamRef<jclass>& clazz) { return base::android::ConvertUTF8ToJavaString(env, GetUserAgent()); } diff --git a/android_webview/native/aw_web_contents_delegate.cc b/android_webview/native/aw_web_contents_delegate.cc index 1d22633..e2a0b39 100644 --- a/android_webview/native/aw_web_contents_delegate.cc +++ b/android_webview/native/aw_web_contents_delegate.cc @@ -252,11 +252,14 @@ bool AwWebContentsDelegate::IsFullscreenForTabOrPending( return is_fullscreen_; } - static void FilesSelectedInChooser( - JNIEnv* env, jclass clazz, - jint process_id, jint render_id, jint mode_flags, - jobjectArray file_paths, jobjectArray display_names) { + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + jint process_id, + jint render_id, + jint mode_flags, + const JavaParamRef<jobjectArray>& file_paths, + const JavaParamRef<jobjectArray>& display_names) { content::RenderViewHost* rvh = content::RenderViewHost::FromID(process_id, render_id); if (!rvh) diff --git a/android_webview/native/cookie_manager.cc b/android_webview/native/cookie_manager.cc index 130e76c..4d3460f 100644 --- a/android_webview/native/cookie_manager.cc +++ b/android_webview/native/cookie_manager.cc @@ -512,19 +512,22 @@ void CookieManager::SetAcceptFileSchemeCookiesLocked(bool accept) { } // namespace -static void SetShouldAcceptCookies(JNIEnv* env, jobject obj, jboolean accept) { +static void SetShouldAcceptCookies(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jboolean accept) { CookieManager::GetInstance()->SetShouldAcceptCookies(accept); } -static jboolean GetShouldAcceptCookies(JNIEnv* env, jobject obj) { +static jboolean GetShouldAcceptCookies(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return CookieManager::GetInstance()->GetShouldAcceptCookies(); } static void SetCookie(JNIEnv* env, - jobject obj, - jstring url, - jstring value, - jobject java_callback) { + const JavaParamRef<jobject>& obj, + const JavaParamRef<jstring>& url, + const JavaParamRef<jstring>& value, + const JavaParamRef<jobject>& java_callback) { GURL host(ConvertJavaStringToUTF16(env, url)); std::string cookie_value(ConvertJavaStringToUTF8(env, value)); scoped_ptr<BoolCookieCallbackHolder> callback( @@ -533,9 +536,9 @@ static void SetCookie(JNIEnv* env, } static void SetCookieSync(JNIEnv* env, - jobject obj, - jstring url, - jstring value) { + const JavaParamRef<jobject>& obj, + const JavaParamRef<jstring>& url, + const JavaParamRef<jstring>& value) { GURL host(ConvertJavaStringToUTF16(env, url)); std::string cookie_value(ConvertJavaStringToUTF8(env, value)); @@ -543,8 +546,8 @@ static void SetCookieSync(JNIEnv* env, } static ScopedJavaLocalRef<jstring> GetCookie(JNIEnv* env, - jobject obj, - jstring url) { + const JavaParamRef<jobject>& obj, + const JavaParamRef<jstring>& url) { GURL host(ConvertJavaStringToUTF16(env, url)); return base::android::ConvertUTF8ToJavaString( @@ -552,44 +555,51 @@ static ScopedJavaLocalRef<jstring> GetCookie(JNIEnv* env, } static void RemoveSessionCookies(JNIEnv* env, - jobject obj, - jobject java_callback) { + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& java_callback) { scoped_ptr<BoolCookieCallbackHolder> callback( new BoolCookieCallbackHolder(env, java_callback)); CookieManager::GetInstance()->RemoveSessionCookies(callback.Pass()); } -static void RemoveSessionCookiesSync(JNIEnv* env, jobject obj) { +static void RemoveSessionCookiesSync(JNIEnv* env, + const JavaParamRef<jobject>& obj) { CookieManager::GetInstance()->RemoveSessionCookiesSync(); } -static void RemoveAllCookies(JNIEnv* env, jobject obj, jobject java_callback) { +static void RemoveAllCookies(JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& java_callback) { scoped_ptr<BoolCookieCallbackHolder> callback( new BoolCookieCallbackHolder(env, java_callback)); CookieManager::GetInstance()->RemoveAllCookies(callback.Pass()); } -static void RemoveAllCookiesSync(JNIEnv* env, jobject obj) { +static void RemoveAllCookiesSync(JNIEnv* env, + const JavaParamRef<jobject>& obj) { CookieManager::GetInstance()->RemoveAllCookiesSync(); } -static void RemoveExpiredCookies(JNIEnv* env, jobject obj) { +static void RemoveExpiredCookies(JNIEnv* env, + const JavaParamRef<jobject>& obj) { CookieManager::GetInstance()->RemoveExpiredCookies(); } -static void FlushCookieStore(JNIEnv* env, jobject obj) { +static void FlushCookieStore(JNIEnv* env, const JavaParamRef<jobject>& obj) { CookieManager::GetInstance()->FlushCookieStore(); } -static jboolean HasCookies(JNIEnv* env, jobject obj) { +static jboolean HasCookies(JNIEnv* env, const JavaParamRef<jobject>& obj) { return CookieManager::GetInstance()->HasCookies(); } -static jboolean AllowFileSchemeCookies(JNIEnv* env, jobject obj) { +static jboolean AllowFileSchemeCookies(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return CookieManager::GetInstance()->AllowFileSchemeCookies(); } -static void SetAcceptFileSchemeCookies(JNIEnv* env, jobject obj, +static void SetAcceptFileSchemeCookies(JNIEnv* env, + const JavaParamRef<jobject>& obj, jboolean accept) { return CookieManager::GetInstance()->SetAcceptFileSchemeCookies(accept); } diff --git a/base/android/animation_frame_time_histogram.cc b/base/android/animation_frame_time_histogram.cc index 0d79619..2cf7516 100644 --- a/base/android/animation_frame_time_histogram.cc +++ b/base/android/animation_frame_time_histogram.cc @@ -10,9 +10,9 @@ // static void SaveHistogram(JNIEnv* env, - jobject jcaller, - jstring j_histogram_name, - jlongArray j_frame_times_ms, + const JavaParamRef<jobject>& jcaller, + const JavaParamRef<jstring>& j_histogram_name, + const JavaParamRef<jlongArray>& j_frame_times_ms, jint j_count) { jlong *frame_times_ms = env->GetLongArrayElements(j_frame_times_ms, NULL); std::string histogram_name = base::android::ConvertJavaStringToUTF8( diff --git a/base/android/application_status_listener.cc b/base/android/application_status_listener.cc index 3e6fbf8..5aee781 100644 --- a/base/android/application_status_listener.cc +++ b/base/android/application_status_listener.cc @@ -66,7 +66,7 @@ void ApplicationStatusListener::NotifyApplicationStateChange( } static void OnApplicationStateChange(JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jint new_state) { ApplicationState application_state = static_cast<ApplicationState>(new_state); ApplicationStatusListener::NotifyApplicationStateChange(application_state); diff --git a/base/android/command_line_android.cc b/base/android/command_line_android.cc index 3a2b1f2..e196aed 100644 --- a/base/android/command_line_android.cc +++ b/base/android/command_line_android.cc @@ -31,18 +31,21 @@ void AppendJavaStringArrayToCommandLine(JNIEnv* env, } // namespace -static void Reset(JNIEnv* env, jclass clazz) { +static void Reset(JNIEnv* env, const JavaParamRef<jclass>& clazz) { CommandLine::Reset(); } -static jboolean HasSwitch(JNIEnv* env, jclass clazz, jstring jswitch) { +static jboolean HasSwitch(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jswitch) { std::string switch_string(ConvertJavaStringToUTF8(env, jswitch)); return CommandLine::ForCurrentProcess()->HasSwitch(switch_string); } -static ScopedJavaLocalRef<jstring> GetSwitchValue(JNIEnv* env, - jclass clazz, - jstring jswitch) { +static ScopedJavaLocalRef<jstring> GetSwitchValue( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jswitch) { std::string switch_string(ConvertJavaStringToUTF8(env, jswitch)); std::string value(CommandLine::ForCurrentProcess()->GetSwitchValueNative( switch_string)); @@ -51,21 +54,27 @@ static ScopedJavaLocalRef<jstring> GetSwitchValue(JNIEnv* env, return ConvertUTF8ToJavaString(env, value); } -static void AppendSwitch(JNIEnv* env, jclass clazz, jstring jswitch) { +static void AppendSwitch(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jswitch) { std::string switch_string(ConvertJavaStringToUTF8(env, jswitch)); CommandLine::ForCurrentProcess()->AppendSwitch(switch_string); } -static void AppendSwitchWithValue(JNIEnv* env, jclass clazz, - jstring jswitch, jstring jvalue) { +static void AppendSwitchWithValue(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jswitch, + const JavaParamRef<jstring>& jvalue) { std::string switch_string(ConvertJavaStringToUTF8(env, jswitch)); std::string value_string (ConvertJavaStringToUTF8(env, jvalue)); CommandLine::ForCurrentProcess()->AppendSwitchASCII(switch_string, value_string); } -static void AppendSwitchesAndArguments(JNIEnv* env, jclass clazz, - jobjectArray array) { +static void AppendSwitchesAndArguments( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobjectArray>& array) { AppendJavaStringArrayToCommandLine(env, array, false); } diff --git a/base/android/cpu_features.cc b/base/android/cpu_features.cc index 6a18695..c139b78 100644 --- a/base/android/cpu_features.cc +++ b/base/android/cpu_features.cc @@ -10,11 +10,11 @@ namespace base { namespace android { -jint GetCoreCount(JNIEnv*, jclass) { +jint GetCoreCount(JNIEnv*, const JavaParamRef<jclass>&) { return android_getCpuCount(); } -jlong GetCpuFeatures(JNIEnv*, jclass) { +jlong GetCpuFeatures(JNIEnv*, const JavaParamRef<jclass>&) { return android_getCpuFeatures(); } diff --git a/base/android/field_trial_list.cc b/base/android/field_trial_list.cc index 3ff3811..9731a48 100644 --- a/base/android/field_trial_list.cc +++ b/base/android/field_trial_list.cc @@ -13,15 +13,18 @@ using base::android::ConvertJavaStringToUTF8; using base::android::ConvertUTF8ToJavaString; -static ScopedJavaLocalRef<jstring> FindFullName(JNIEnv* env, - jclass clazz, - jstring jtrial_name) { +static ScopedJavaLocalRef<jstring> FindFullName( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jtrial_name) { std::string trial_name(ConvertJavaStringToUTF8(env, jtrial_name)); return ConvertUTF8ToJavaString( env, base::FieldTrialList::FindFullName(trial_name)); } -static jboolean TrialExists(JNIEnv* env, jclass clazz, jstring jtrial_name) { +static jboolean TrialExists(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jtrial_name) { std::string trial_name(ConvertJavaStringToUTF8(env, jtrial_name)); return base::FieldTrialList::TrialExists(trial_name); } diff --git a/base/android/important_file_writer_android.cc b/base/android/important_file_writer_android.cc index bcbd785..f324738 100644 --- a/base/android/important_file_writer_android.cc +++ b/base/android/important_file_writer_android.cc @@ -15,9 +15,9 @@ namespace base { namespace android { static jboolean WriteFileAtomically(JNIEnv* env, - jclass /* clazz */, - jstring file_name, - jbyteArray data) { + const JavaParamRef<jclass>& /* clazz */, + const JavaParamRef<jstring>& file_name, + const JavaParamRef<jbyteArray>& data) { // This is called on the UI thread during shutdown to save tab data, so // needs to enable IO. base::ThreadRestrictions::ScopedAllowIO allow_io; 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 974cfff..e982609 100644 --- a/base/android/jni_generator/golden_sample_for_tests_jni.h +++ b/base/android/jni_generator/golden_sample_for_tests_jni.h @@ -41,14 +41,15 @@ namespace android { // Step 2: method stubs. -static jlong Init(JNIEnv* env, jobject jcaller, - jstring param); +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& jcaller, + const JavaParamRef<jstring>& param); static jlong Java_org_chromium_example_jni_1generator_SampleForTests_nativeInit(JNIEnv* env, jobject jcaller, jstring param) { - return Init(env, jcaller, param); + return Init(env, JavaParamRef<jobject>(env, jcaller), + JavaParamRef<jstring>(env, param)); } static void @@ -58,42 +59,45 @@ static void jlong nativeCPPClass) { CPPClass* native = reinterpret_cast<CPPClass*>(nativeCPPClass); CHECK_NATIVE_PTR(env, jcaller, native, "Destroy"); - return native->Destroy(env, jcaller); + return native->Destroy(env, JavaParamRef<jobject>(env, jcaller)); } -static jdouble GetDoubleFunction(JNIEnv* env, jobject jcaller); +static jdouble GetDoubleFunction(JNIEnv* env, const JavaParamRef<jobject>& + jcaller); static jdouble Java_org_chromium_example_jni_1generator_SampleForTests_nativeGetDoubleFunction(JNIEnv* env, jobject jcaller) { - return GetDoubleFunction(env, jcaller); + return GetDoubleFunction(env, JavaParamRef<jobject>(env, jcaller)); } -static jfloat GetFloatFunction(JNIEnv* env, jclass jcaller); +static jfloat GetFloatFunction(JNIEnv* env, const JavaParamRef<jclass>& + jcaller); static jfloat Java_org_chromium_example_jni_1generator_SampleForTests_nativeGetFloatFunction(JNIEnv* env, jclass jcaller) { - return GetFloatFunction(env, jcaller); + return GetFloatFunction(env, JavaParamRef<jclass>(env, jcaller)); } -static void SetNonPODDatatype(JNIEnv* env, jobject jcaller, - jobject rect); +static void SetNonPODDatatype(JNIEnv* env, const JavaParamRef<jobject>& jcaller, + const JavaParamRef<jobject>& rect); static void Java_org_chromium_example_jni_1generator_SampleForTests_nativeSetNonPODDatatype(JNIEnv* env, jobject jcaller, jobject rect) { - return SetNonPODDatatype(env, jcaller, rect); + return SetNonPODDatatype(env, JavaParamRef<jobject>(env, jcaller), + JavaParamRef<jobject>(env, rect)); } -static ScopedJavaLocalRef<jobject> GetNonPODDatatype(JNIEnv* env, jobject - jcaller); +static ScopedJavaLocalRef<jobject> GetNonPODDatatype(JNIEnv* env, const + JavaParamRef<jobject>& jcaller); static jobject Java_org_chromium_example_jni_1generator_SampleForTests_nativeGetNonPODDatatype(JNIEnv* env, jobject jcaller) { - return GetNonPODDatatype(env, jcaller).Release(); + return GetNonPODDatatype(env, JavaParamRef<jobject>(env, jcaller)).Release(); } static jint @@ -103,7 +107,7 @@ static jint jlong nativeCPPClass) { CPPClass* native = reinterpret_cast<CPPClass*>(nativeCPPClass); CHECK_NATIVE_PTR(env, jcaller, native, "Method", 0); - return native->Method(env, jcaller); + return native->Method(env, JavaParamRef<jobject>(env, jcaller)); } static jdouble @@ -114,7 +118,7 @@ static jdouble CPPClass::InnerClass* native = reinterpret_cast<CPPClass::InnerClass*>(nativePtr); CHECK_NATIVE_PTR(env, jcaller, native, "MethodOtherP0", 0); - return native->MethodOtherP0(env, jcaller); + return native->MethodOtherP0(env, JavaParamRef<jobject>(env, jcaller)); } static void @@ -125,7 +129,8 @@ static void jobject b) { CPPClass* native = reinterpret_cast<CPPClass*>(nativeCPPClass); CHECK_NATIVE_PTR(env, jcaller, native, "AddStructB"); - return native->AddStructB(env, jcaller, b); + return native->AddStructB(env, JavaParamRef<jobject>(env, jcaller), + JavaParamRef<jobject>(env, b)); } static void @@ -135,7 +140,8 @@ static void jlong nativeCPPClass) { CPPClass* native = reinterpret_cast<CPPClass*>(nativeCPPClass); CHECK_NATIVE_PTR(env, jcaller, native, "IterateAndDoSomethingWithStructB"); - return native->IterateAndDoSomethingWithStructB(env, jcaller); + return native->IterateAndDoSomethingWithStructB(env, + JavaParamRef<jobject>(env, jcaller)); } static jstring @@ -145,7 +151,8 @@ static jstring jlong nativeCPPClass) { CPPClass* native = reinterpret_cast<CPPClass*>(nativeCPPClass); CHECK_NATIVE_PTR(env, jcaller, native, "ReturnAString", NULL); - return native->ReturnAString(env, jcaller).Release(); + return native->ReturnAString(env, JavaParamRef<jobject>(env, + jcaller)).Release(); } static base::subtle::AtomicWord g_SampleForTests_javaMethod = 0; diff --git a/base/android/jni_generator/jni_generator.py b/base/android/jni_generator/jni_generator.py index 33f83ecc..5d262c8 100755 --- a/base/android/jni_generator/jni_generator.py +++ b/base/android/jni_generator/jni_generator.py @@ -135,6 +135,19 @@ def JavaDataTypeToC(java_type): return 'jobject' +def WrapCTypeForDeclaration(c_type): + """Wrap the C datatype in a JavaRef if required.""" + if re.match(RE_SCOPED_JNI_TYPES, c_type): + return 'const JavaParamRef<' + c_type + '>&' + else: + return c_type + + +def JavaDataTypeToCForDeclaration(java_type): + """Returns a JavaRef-wrapped C datatype for the given java type.""" + return WrapCTypeForDeclaration(JavaDataTypeToC(java_type)) + + def JavaDataTypeToCForCalledByNativeParam(java_type): """Returns a C datatype to be when calling from native.""" if java_type == 'int': @@ -527,10 +540,9 @@ def MangleCalledByNatives(called_by_natives): return called_by_natives -# Regex to match the JNI return types that should be included in a -# ScopedJavaLocalRef. -RE_SCOPED_JNI_RETURN_TYPES = re.compile( - 'jobject|jclass|jstring|jthrowable|.*Array') +# Regex to match the JNI types that should be wrapped in a JavaRef. +RE_SCOPED_JNI_TYPES = re.compile('jobject|jclass|jstring|jthrowable|.*Array') + # Regex to match a string like "@CalledByNative public void foo(int bar)". RE_CALLED_BY_NATIVE = re.compile( @@ -1005,18 +1017,36 @@ Java_${FULLY_QUALIFIED_CLASS}_${INIT_NATIVE_NAME}(JNIEnv* env, jclass clazz) { return '\n'.join(all_namespaces) + '\n' return '' - def GetJNIFirstParam(self, native): - ret = [] + def GetJNIFirstParamType(self, native): if native.type == 'method': - ret = ['jobject jcaller'] + return 'jobject' elif native.type == 'function': if native.static: - ret = ['jclass jcaller'] + return 'jclass' else: - ret = ['jobject jcaller'] - return ret + return 'jobject' + + def GetJNIFirstParam(self, native, for_declaration): + c_type = self.GetJNIFirstParamType(native) + if for_declaration: + c_type = WrapCTypeForDeclaration(c_type) + return [c_type + ' jcaller'] def GetParamsInDeclaration(self, native): + """Returns the params for the forward declaration. + + Args: + native: the native dictionary describing the method. + + Returns: + A string containing the params. + """ + return ',\n '.join(self.GetJNIFirstParam(native, True) + + [JavaDataTypeToCForDeclaration(param.datatype) + ' ' + + param.name + for param in native.params]) + + def GetParamsInStub(self, native): """Returns the params for the stub declaration. Args: @@ -1025,7 +1055,7 @@ Java_${FULLY_QUALIFIED_CLASS}_${INIT_NATIVE_NAME}(JNIEnv* env, jclass clazz) { Returns: A string containing the params. """ - return ',\n '.join(self.GetJNIFirstParam(native) + + return ',\n '.join(self.GetJNIFirstParam(native, False) + [JavaDataTypeToC(param.datatype) + ' ' + param.name for param in native.params]) @@ -1056,6 +1086,16 @@ Java_${FULLY_QUALIFIED_CLASS}_${INIT_NATIVE_NAME}(JNIEnv* env, jclass clazz) { 'JAVA_NAME': java_name} return template.substitute(values) + def GetJavaParamRefForCall(self, c_type, name): + return Template('JavaParamRef<${TYPE}>(env, ${NAME})').substitute({ + 'TYPE': c_type, + 'NAME': name, + }) + + def GetJNIFirstParamForCall(self, native): + c_type = self.GetJNIFirstParamType(native) + return [self.GetJavaParamRefForCall(c_type, 'jcaller')] + def GetNativeStub(self, native): is_method = native.type == 'method' @@ -1065,8 +1105,14 @@ Java_${FULLY_QUALIFIED_CLASS}_${INIT_NATIVE_NAME}(JNIEnv* env, jclass clazz) { params = native.params params_in_call = [] if not self.options.pure_native_methods: - params_in_call = ['env', 'jcaller'] - params_in_call = ', '.join(params_in_call + [p.name for p in params]) + params_in_call = ['env'] + self.GetJNIFirstParamForCall(native) + for p in params: + c_type = JavaDataTypeToC(p.datatype) + if re.match(RE_SCOPED_JNI_TYPES, c_type): + params_in_call.append(self.GetJavaParamRefForCall(c_type, p.name)) + else: + params_in_call.append(p.name) + params_in_call = ', '.join(params_in_call) if self.options.native_exports: stub_visibility = 'extern "C" __attribute__((visibility("default")))\n' @@ -1074,7 +1120,7 @@ Java_${FULLY_QUALIFIED_CLASS}_${INIT_NATIVE_NAME}(JNIEnv* env, jclass clazz) { stub_visibility = 'static ' return_type = return_declaration = JavaDataTypeToC(native.return_type) post_call = '' - if re.match(RE_SCOPED_JNI_RETURN_TYPES, return_type): + if re.match(RE_SCOPED_JNI_TYPES, return_type): post_call = '.Release()' return_declaration = 'ScopedJavaLocalRef<' + return_type + '>' values = { @@ -1082,6 +1128,7 @@ Java_${FULLY_QUALIFIED_CLASS}_${INIT_NATIVE_NAME}(JNIEnv* env, jclass clazz) { 'RETURN_DECLARATION': return_declaration, 'NAME': native.name, 'PARAMS': self.GetParamsInDeclaration(native), + 'PARAMS_IN_STUB': self.GetParamsInStub(native), 'PARAMS_IN_CALL': params_in_call, 'POST_CALL': post_call, 'STUB_NAME': self.GetStubName(native), @@ -1099,7 +1146,7 @@ Java_${FULLY_QUALIFIED_CLASS}_${INIT_NATIVE_NAME}(JNIEnv* env, jclass clazz) { }) template = Template("""\ ${STUB_VISIBILITY}${RETURN} ${STUB_NAME}(JNIEnv* env, - ${PARAMS}) { + ${PARAMS_IN_STUB}) { ${P0_TYPE}* native = reinterpret_cast<${P0_TYPE}*>(${PARAM0_NAME}); CHECK_NATIVE_PTR(env, jcaller, native, "${NAME}"${OPTIONAL_ERROR_RETURN}); return native->${NAME}(${PARAMS_IN_CALL})${POST_CALL}; @@ -1109,7 +1156,7 @@ ${STUB_VISIBILITY}${RETURN} ${STUB_NAME}(JNIEnv* env, template = Template(""" static ${RETURN_DECLARATION} ${NAME}(JNIEnv* env, ${PARAMS}); -${STUB_VISIBILITY}${RETURN} ${STUB_NAME}(JNIEnv* env, ${PARAMS}) { +${STUB_VISIBILITY}${RETURN} ${STUB_NAME}(JNIEnv* env, ${PARAMS_IN_STUB}) { return ${NAME}(${PARAMS_IN_CALL})${POST_CALL}; } """) @@ -1157,7 +1204,7 @@ ${STUB_VISIBILITY}${RETURN} ${STUB_NAME}(JNIEnv* env, ${PARAMS}) { if return_type != 'void': pre_call = ' ' + pre_call return_declaration = return_type + ' ret =' - if re.match(RE_SCOPED_JNI_RETURN_TYPES, return_type): + if re.match(RE_SCOPED_JNI_TYPES, return_type): return_type = 'ScopedJavaLocalRef<' + return_type + '>' return_clause = 'return ' + return_type + '(env, ret);' else: diff --git a/base/android/jni_generator/jni_generator_helper.h b/base/android/jni_generator/jni_generator_helper.h index b9736e1..1fdc4ee 100644 --- a/base/android/jni_generator/jni_generator_helper.h +++ b/base/android/jni_generator/jni_generator_helper.h @@ -36,5 +36,6 @@ namespace jni_generator { } // namespace jni_generator using base::android::ScopedJavaLocalRef; +using base::android::JavaParamRef; #endif // BASE_ANDROID_JNI_GENERATOR_JNI_GENERATOR_HELPER_H_ diff --git a/base/android/jni_generator/sample_for_tests.cc b/base/android/jni_generator/sample_for_tests.cc index a05909a..a38377c 100644 --- a/base/android/jni_generator/sample_for_tests.cc +++ b/base/android/jni_generator/sample_for_tests.cc @@ -66,22 +66,27 @@ base::android::ScopedJavaLocalRef<jstring> CPPClass::ReturnAString( } // Static free functions declared and called directly from java. -static jlong Init(JNIEnv* env, jobject caller, jstring param) { +static jlong Init(JNIEnv* env, + const JavaParamRef<jobject>& caller, + const JavaParamRef<jstring>& param) { return 0; } -static jdouble GetDoubleFunction(JNIEnv*, jobject) { +static jdouble GetDoubleFunction(JNIEnv*, const JavaParamRef<jobject>&) { return 0; } -static jfloat GetFloatFunction(JNIEnv*, jclass) { +static jfloat GetFloatFunction(JNIEnv*, const JavaParamRef<jclass>&) { return 0; } -static void SetNonPODDatatype(JNIEnv*, jobject, jobject) { -} +static void SetNonPODDatatype(JNIEnv*, + const JavaParamRef<jobject>&, + const JavaParamRef<jobject>&) {} -static ScopedJavaLocalRef<jobject> GetNonPODDatatype(JNIEnv*, jobject) { +static ScopedJavaLocalRef<jobject> GetNonPODDatatype( + JNIEnv*, + const JavaParamRef<jobject>&) { return ScopedJavaLocalRef<jobject>(); } diff --git a/base/android/jni_generator/testEagerCalledByNativesOption.golden b/base/android/jni_generator/testEagerCalledByNativesOption.golden index cdd6151..b01cd39 100644 --- a/base/android/jni_generator/testEagerCalledByNativesOption.golden +++ b/base/android/jni_generator/testEagerCalledByNativesOption.golden @@ -36,7 +36,7 @@ static jint Java_org_chromium_example_jni_1generator_Test_nativeMethod(JNIEnv* jint arg1) { Test* native = reinterpret_cast<Test*>(nativeTest); CHECK_NATIVE_PTR(env, jcaller, native, "Method", 0); - return native->Method(env, jcaller, arg1); + return native->Method(env, JavaParamRef<jobject>(env, jcaller), arg1); } namespace { diff --git a/base/android/jni_generator/testInnerClassNatives.golden b/base/android/jni_generator/testInnerClassNatives.golden index d6676c4..ad140e2 100644 --- a/base/android/jni_generator/testInnerClassNatives.golden +++ b/base/android/jni_generator/testInnerClassNatives.golden @@ -28,11 +28,11 @@ jclass g_TestJni_clazz = NULL; // Step 2: method stubs. -static jint Init(JNIEnv* env, jobject jcaller); +static jint Init(JNIEnv* env, const JavaParamRef<jobject>& jcaller); static jint Java_org_chromium_TestJni_00024MyInnerClass_nativeInit(JNIEnv* env, jobject jcaller) { - return Init(env, jcaller); + return Init(env, JavaParamRef<jobject>(env, jcaller)); } // Step 3: RegisterNatives. diff --git a/base/android/jni_generator/testInnerClassNativesBothInnerAndOuter.golden b/base/android/jni_generator/testInnerClassNativesBothInnerAndOuter.golden index a9e645c..0a890e7 100644 --- a/base/android/jni_generator/testInnerClassNativesBothInnerAndOuter.golden +++ b/base/android/jni_generator/testInnerClassNativesBothInnerAndOuter.golden @@ -29,17 +29,17 @@ jclass g_TestJni_clazz = NULL; // Step 2: method stubs. -static jint Init(JNIEnv* env, jobject jcaller); +static jint Init(JNIEnv* env, const JavaParamRef<jobject>& jcaller); static jint Java_org_chromium_TestJni_nativeInit(JNIEnv* env, jobject jcaller) { - return Init(env, jcaller); + return Init(env, JavaParamRef<jobject>(env, jcaller)); } -static jint Init(JNIEnv* env, jobject jcaller); +static jint Init(JNIEnv* env, const JavaParamRef<jobject>& jcaller); static jint Java_org_chromium_TestJni_00024MyOtherInnerClass_nativeInit(JNIEnv* env, jobject jcaller) { - return Init(env, jcaller); + return Init(env, JavaParamRef<jobject>(env, jcaller)); } // Step 3: RegisterNatives. diff --git a/base/android/jni_generator/testInnerClassNativesMultiple.golden b/base/android/jni_generator/testInnerClassNativesMultiple.golden index 5f54364..268f794 100644 --- a/base/android/jni_generator/testInnerClassNativesMultiple.golden +++ b/base/android/jni_generator/testInnerClassNativesMultiple.golden @@ -30,18 +30,18 @@ jclass g_TestJni_clazz = NULL; // Step 2: method stubs. -static jint Init(JNIEnv* env, jobject jcaller); +static jint Init(JNIEnv* env, const JavaParamRef<jobject>& jcaller); static jint Java_org_chromium_TestJni_00024MyInnerClass_nativeInit(JNIEnv* env, jobject jcaller) { - return Init(env, jcaller); + return Init(env, JavaParamRef<jobject>(env, jcaller)); } -static jint Init(JNIEnv* env, jobject jcaller); +static jint Init(JNIEnv* env, const JavaParamRef<jobject>& jcaller); static jint Java_org_chromium_TestJni_00024MyOtherInnerClass_nativeInit(JNIEnv* env, jobject jcaller) { - return Init(env, jcaller); + return Init(env, JavaParamRef<jobject>(env, jcaller)); } // Step 3: RegisterNatives. diff --git a/base/android/jni_generator/testJNIInitNativeNameOption.golden b/base/android/jni_generator/testJNIInitNativeNameOption.golden index 084f08d..46a57ac 100644 --- a/base/android/jni_generator/testJNIInitNativeNameOption.golden +++ b/base/android/jni_generator/testJNIInitNativeNameOption.golden @@ -33,7 +33,7 @@ static jint Java_org_chromium_example_jni_1generator_Test_nativeMethod(JNIEnv* jint arg1) { Test* native = reinterpret_cast<Test*>(nativeTest); CHECK_NATIVE_PTR(env, jcaller, native, "Method", 0); - return native->Method(env, jcaller, arg1); + return native->Method(env, JavaParamRef<jobject>(env, jcaller), arg1); } // Step 3: RegisterNatives. diff --git a/base/android/jni_generator/testJarJarRemapping.golden b/base/android/jni_generator/testJarJarRemapping.golden index b626a8a..fe13952 100644 --- a/base/android/jni_generator/testJarJarRemapping.golden +++ b/base/android/jni_generator/testJarJarRemapping.golden @@ -27,40 +27,44 @@ jclass g_Example_clazz = NULL; // Step 2: method stubs. -static void Test(JNIEnv* env, jclass jcaller, - jobject t); +static void Test(JNIEnv* env, const JavaParamRef<jclass>& jcaller, + const JavaParamRef<jobject>& t); static void Java_com_test_jni_1generator_Example_nativeTest(JNIEnv* env, jclass jcaller, jobject t) { - return Test(env, jcaller, t); + return Test(env, JavaParamRef<jclass>(env, jcaller), + JavaParamRef<jobject>(env, t)); } -static void Test2(JNIEnv* env, jclass jcaller, - jobject t); +static void Test2(JNIEnv* env, const JavaParamRef<jclass>& jcaller, + const JavaParamRef<jobject>& t); static void Java_com_test_jni_1generator_Example_nativeTest2(JNIEnv* env, jclass jcaller, jobject t) { - return Test2(env, jcaller, t); + return Test2(env, JavaParamRef<jclass>(env, jcaller), + JavaParamRef<jobject>(env, t)); } -static void Test3(JNIEnv* env, jclass jcaller, - jobject t); +static void Test3(JNIEnv* env, const JavaParamRef<jclass>& jcaller, + const JavaParamRef<jobject>& t); static void Java_com_test_jni_1generator_Example_nativeTest3(JNIEnv* env, jclass jcaller, jobject t) { - return Test3(env, jcaller, t); + return Test3(env, JavaParamRef<jclass>(env, jcaller), + JavaParamRef<jobject>(env, t)); } -static void Test4(JNIEnv* env, jclass jcaller, - jobject t); +static void Test4(JNIEnv* env, const JavaParamRef<jclass>& jcaller, + const JavaParamRef<jobject>& t); static void Java_com_test_jni_1generator_Example_nativeTest4(JNIEnv* env, jclass jcaller, jobject t) { - return Test4(env, jcaller, t); + return Test4(env, JavaParamRef<jclass>(env, jcaller), + JavaParamRef<jobject>(env, t)); } // Step 3: RegisterNatives. diff --git a/base/android/jni_generator/testMultipleJNIAdditionalImport.golden b/base/android/jni_generator/testMultipleJNIAdditionalImport.golden index eb15190..6de8c21 100644 --- a/base/android/jni_generator/testMultipleJNIAdditionalImport.golden +++ b/base/android/jni_generator/testMultipleJNIAdditionalImport.golden @@ -27,15 +27,17 @@ jclass g_Foo_clazz = NULL; // Step 2: method stubs. -static void DoSomething(JNIEnv* env, jclass jcaller, - jobject callback1, - jobject callback2); +static void DoSomething(JNIEnv* env, const JavaParamRef<jclass>& jcaller, + const JavaParamRef<jobject>& callback1, + const JavaParamRef<jobject>& callback2); static void Java_org_chromium_foo_Foo_nativeDoSomething(JNIEnv* env, jclass jcaller, jobject callback1, jobject callback2) { - return DoSomething(env, jcaller, callback1, callback2); + return DoSomething(env, JavaParamRef<jclass>(env, jcaller), + JavaParamRef<jobject>(env, callback1), JavaParamRef<jobject>(env, + callback2)); } static base::subtle::AtomicWord g_Foo_calledByNative = 0; diff --git a/base/android/jni_generator/testNativeExportsOption.golden b/base/android/jni_generator/testNativeExportsOption.golden index 68736ad..13cd2b9 100644 --- a/base/android/jni_generator/testNativeExportsOption.golden +++ b/base/android/jni_generator/testNativeExportsOption.golden @@ -36,7 +36,7 @@ jint jint arg1) { Test* native = reinterpret_cast<Test*>(nativeTest); CHECK_NATIVE_PTR(env, jcaller, native, "StaticMethod", 0); - return native->StaticMethod(env, jcaller, arg1); + return native->StaticMethod(env, JavaParamRef<jobject>(env, jcaller), arg1); } extern "C" __attribute__((visibility("default"))) @@ -48,25 +48,25 @@ jint jint arg1) { Test* native = reinterpret_cast<Test*>(nativeTest); CHECK_NATIVE_PTR(env, jcaller, native, "Method", 0); - return native->Method(env, jcaller, arg1); + return native->Method(env, JavaParamRef<jobject>(env, jcaller), arg1); } -static jint Init(JNIEnv* env, jobject jcaller); +static jint Init(JNIEnv* env, const JavaParamRef<jobject>& jcaller); extern "C" __attribute__((visibility("default"))) jint Java_org_chromium_example_jni_1generator_SampleForTests_00024MyInnerClass_nativeInit(JNIEnv* env, jobject jcaller) { - return Init(env, jcaller); + return Init(env, JavaParamRef<jobject>(env, jcaller)); } -static jint Init(JNIEnv* env, jobject jcaller); +static jint Init(JNIEnv* env, const JavaParamRef<jobject>& jcaller); extern "C" __attribute__((visibility("default"))) jint Java_org_chromium_example_jni_1generator_SampleForTests_00024MyOtherInnerClass_nativeInit(JNIEnv* env, jobject jcaller) { - return Init(env, jcaller); + return Init(env, JavaParamRef<jobject>(env, jcaller)); } static base::subtle::AtomicWord g_SampleForTests_testMethodWithParam = 0; diff --git a/base/android/jni_generator/testNativeExportsOptionalOption.golden b/base/android/jni_generator/testNativeExportsOptionalOption.golden index 6e2b655..e2cf051 100644 --- a/base/android/jni_generator/testNativeExportsOptionalOption.golden +++ b/base/android/jni_generator/testNativeExportsOptionalOption.golden @@ -36,7 +36,7 @@ jint jint arg1) { Test* native = reinterpret_cast<Test*>(nativeTest); CHECK_NATIVE_PTR(env, jcaller, native, "StaticMethod", 0); - return native->StaticMethod(env, jcaller, arg1); + return native->StaticMethod(env, JavaParamRef<jobject>(env, jcaller), arg1); } extern "C" __attribute__((visibility("default"))) @@ -48,25 +48,25 @@ jint jint arg1) { Test* native = reinterpret_cast<Test*>(nativeTest); CHECK_NATIVE_PTR(env, jcaller, native, "Method", 0); - return native->Method(env, jcaller, arg1); + return native->Method(env, JavaParamRef<jobject>(env, jcaller), arg1); } -static jint Init(JNIEnv* env, jobject jcaller); +static jint Init(JNIEnv* env, const JavaParamRef<jobject>& jcaller); extern "C" __attribute__((visibility("default"))) jint Java_org_chromium_example_jni_1generator_SampleForTests_00024MyInnerClass_nativeInit(JNIEnv* env, jobject jcaller) { - return Init(env, jcaller); + return Init(env, JavaParamRef<jobject>(env, jcaller)); } -static jint Init(JNIEnv* env, jobject jcaller); +static jint Init(JNIEnv* env, const JavaParamRef<jobject>& jcaller); extern "C" __attribute__((visibility("default"))) jint Java_org_chromium_example_jni_1generator_SampleForTests_00024MyOtherInnerClass_nativeInit(JNIEnv* env, jobject jcaller) { - return Init(env, jcaller); + return Init(env, JavaParamRef<jobject>(env, jcaller)); } static base::subtle::AtomicWord g_SampleForTests_testMethodWithParam = 0; diff --git a/base/android/jni_generator/testNatives.golden b/base/android/jni_generator/testNatives.golden index b19c337..f9538a3 100644 --- a/base/android/jni_generator/testNatives.golden +++ b/base/android/jni_generator/testNatives.golden @@ -27,10 +27,10 @@ jclass g_TestJni_clazz = NULL; // Step 2: method stubs. -static jint Init(JNIEnv* env, jobject jcaller); +static jint Init(JNIEnv* env, const JavaParamRef<jobject>& jcaller); static jint Java_org_chromium_TestJni_nativeInit(JNIEnv* env, jobject jcaller) { - return Init(env, jcaller); + return Init(env, JavaParamRef<jobject>(env, jcaller)); } static void Java_org_chromium_TestJni_nativeDestroy(JNIEnv* env, @@ -39,7 +39,7 @@ static void Java_org_chromium_TestJni_nativeDestroy(JNIEnv* env, ChromeBrowserProvider* native = reinterpret_cast<ChromeBrowserProvider*>(nativeChromeBrowserProvider); CHECK_NATIVE_PTR(env, jcaller, native, "Destroy"); - return native->Destroy(env, jcaller); + return native->Destroy(env, JavaParamRef<jobject>(env, jcaller)); } static jlong Java_org_chromium_TestJni_nativeAddBookmark(JNIEnv* env, @@ -52,58 +52,67 @@ static jlong Java_org_chromium_TestJni_nativeAddBookmark(JNIEnv* env, ChromeBrowserProvider* native = reinterpret_cast<ChromeBrowserProvider*>(nativeChromeBrowserProvider); CHECK_NATIVE_PTR(env, jcaller, native, "AddBookmark", 0); - return native->AddBookmark(env, jcaller, url, title, isFolder, parentId); + return native->AddBookmark(env, JavaParamRef<jobject>(env, jcaller), + JavaParamRef<jstring>(env, url), JavaParamRef<jstring>(env, title), + isFolder, parentId); } -static ScopedJavaLocalRef<jstring> GetDomainAndRegistry(JNIEnv* env, jclass - jcaller, - jstring url); +static ScopedJavaLocalRef<jstring> GetDomainAndRegistry(JNIEnv* env, const + JavaParamRef<jclass>& jcaller, + const JavaParamRef<jstring>& url); static jstring Java_org_chromium_TestJni_nativeGetDomainAndRegistry(JNIEnv* env, jclass jcaller, jstring url) { - return GetDomainAndRegistry(env, jcaller, url).Release(); + return GetDomainAndRegistry(env, JavaParamRef<jclass>(env, jcaller), + JavaParamRef<jstring>(env, url)).Release(); } -static void CreateHistoricalTabFromState(JNIEnv* env, jclass jcaller, - jbyteArray state, +static void CreateHistoricalTabFromState(JNIEnv* env, const + JavaParamRef<jclass>& jcaller, + const JavaParamRef<jbyteArray>& state, jint tab_index); static void Java_org_chromium_TestJni_nativeCreateHistoricalTabFromState(JNIEnv* env, jclass jcaller, jbyteArray state, jint tab_index) { - return CreateHistoricalTabFromState(env, jcaller, state, tab_index); + return CreateHistoricalTabFromState(env, JavaParamRef<jclass>(env, jcaller), + JavaParamRef<jbyteArray>(env, state), tab_index); } -static ScopedJavaLocalRef<jbyteArray> GetStateAsByteArray(JNIEnv* env, jobject - jcaller, - jobject view); +static ScopedJavaLocalRef<jbyteArray> GetStateAsByteArray(JNIEnv* env, const + JavaParamRef<jobject>& jcaller, + const JavaParamRef<jobject>& view); static jbyteArray Java_org_chromium_TestJni_nativeGetStateAsByteArray(JNIEnv* env, jobject jcaller, jobject view) { - return GetStateAsByteArray(env, jcaller, view).Release(); + return GetStateAsByteArray(env, JavaParamRef<jobject>(env, jcaller), + JavaParamRef<jobject>(env, view)).Release(); } static ScopedJavaLocalRef<jobjectArray> GetAutofillProfileGUIDs(JNIEnv* env, - jclass jcaller); + const JavaParamRef<jclass>& jcaller); static jobjectArray Java_org_chromium_TestJni_nativeGetAutofillProfileGUIDs(JNIEnv* env, jclass jcaller) { - return GetAutofillProfileGUIDs(env, jcaller).Release(); + return GetAutofillProfileGUIDs(env, JavaParamRef<jclass>(env, + jcaller)).Release(); } -static void SetRecognitionResults(JNIEnv* env, jobject jcaller, +static void SetRecognitionResults(JNIEnv* env, const JavaParamRef<jobject>& + jcaller, jint sessionId, - jobjectArray results); + const JavaParamRef<jobjectArray>& results); static void Java_org_chromium_TestJni_nativeSetRecognitionResults(JNIEnv* env, jobject jcaller, jint sessionId, jobjectArray results) { - return SetRecognitionResults(env, jcaller, sessionId, results); + return SetRecognitionResults(env, JavaParamRef<jobject>(env, jcaller), + sessionId, JavaParamRef<jobjectArray>(env, results)); } static jlong Java_org_chromium_TestJni_nativeAddBookmarkFromAPI(JNIEnv* env, @@ -119,24 +128,29 @@ static jlong Java_org_chromium_TestJni_nativeAddBookmarkFromAPI(JNIEnv* env, ChromeBrowserProvider* native = reinterpret_cast<ChromeBrowserProvider*>(nativeChromeBrowserProvider); CHECK_NATIVE_PTR(env, jcaller, native, "AddBookmarkFromAPI", 0); - return native->AddBookmarkFromAPI(env, jcaller, url, created, isBookmark, - date, favicon, title, visits); + return native->AddBookmarkFromAPI(env, JavaParamRef<jobject>(env, jcaller), + JavaParamRef<jstring>(env, url), JavaParamRef<jobject>(env, created), + JavaParamRef<jobject>(env, isBookmark), JavaParamRef<jobject>(env, date), + JavaParamRef<jbyteArray>(env, favicon), JavaParamRef<jstring>(env, title), + JavaParamRef<jobject>(env, visits)); } -static jint FindAll(JNIEnv* env, jobject jcaller, - jstring find); +static jint FindAll(JNIEnv* env, const JavaParamRef<jobject>& jcaller, + const JavaParamRef<jstring>& find); static jint Java_org_chromium_TestJni_nativeFindAll(JNIEnv* env, jobject jcaller, jstring find) { - return FindAll(env, jcaller, find); + return FindAll(env, JavaParamRef<jobject>(env, jcaller), + JavaParamRef<jstring>(env, find)); } -static ScopedJavaLocalRef<jobject> GetInnerClass(JNIEnv* env, jclass jcaller); +static ScopedJavaLocalRef<jobject> GetInnerClass(JNIEnv* env, const + JavaParamRef<jclass>& jcaller); static jobject Java_org_chromium_TestJni_nativeGetInnerClass(JNIEnv* env, jclass jcaller) { - return GetInnerClass(env, jcaller).Release(); + return GetInnerClass(env, JavaParamRef<jclass>(env, jcaller)).Release(); } static jobject Java_org_chromium_TestJni_nativeQueryBitmap(JNIEnv* env, @@ -149,8 +163,10 @@ static jobject Java_org_chromium_TestJni_nativeQueryBitmap(JNIEnv* env, ChromeBrowserProvider* native = reinterpret_cast<ChromeBrowserProvider*>(nativeChromeBrowserProvider); CHECK_NATIVE_PTR(env, jcaller, native, "QueryBitmap", NULL); - return native->QueryBitmap(env, jcaller, projection, selection, selectionArgs, - sortOrder).Release(); + return native->QueryBitmap(env, JavaParamRef<jobject>(env, jcaller), + JavaParamRef<jobjectArray>(env, projection), JavaParamRef<jstring>(env, + selection), JavaParamRef<jobjectArray>(env, selectionArgs), + JavaParamRef<jstring>(env, sortOrder)).Release(); } static void Java_org_chromium_TestJni_nativeGotOrientation(JNIEnv* env, @@ -162,17 +178,19 @@ static void Java_org_chromium_TestJni_nativeGotOrientation(JNIEnv* env, DataFetcherImplAndroid* native = reinterpret_cast<DataFetcherImplAndroid*>(nativeDataFetcherImplAndroid); CHECK_NATIVE_PTR(env, jcaller, native, "GotOrientation"); - return native->GotOrientation(env, jcaller, alpha, beta, gamma); + return native->GotOrientation(env, JavaParamRef<jobject>(env, jcaller), alpha, + beta, gamma); } -static ScopedJavaLocalRef<jthrowable> MessWithJavaException(JNIEnv* env, jclass - jcaller, - jthrowable e); +static ScopedJavaLocalRef<jthrowable> MessWithJavaException(JNIEnv* env, const + JavaParamRef<jclass>& jcaller, + const JavaParamRef<jthrowable>& e); static jthrowable Java_org_chromium_TestJni_nativeMessWithJavaException(JNIEnv* env, jclass jcaller, jthrowable e) { - return MessWithJavaException(env, jcaller, e).Release(); + return MessWithJavaException(env, JavaParamRef<jclass>(env, jcaller), + JavaParamRef<jthrowable>(env, e)).Release(); } // Step 3: RegisterNatives. diff --git a/base/android/jni_generator/testNativesLong.golden b/base/android/jni_generator/testNativesLong.golden index 1235616..d5b67ba 100644 --- a/base/android/jni_generator/testNativesLong.golden +++ b/base/android/jni_generator/testNativesLong.golden @@ -32,7 +32,7 @@ static void Java_org_chromium_TestJni_nativeDestroy(JNIEnv* env, ChromeBrowserProvider* native = reinterpret_cast<ChromeBrowserProvider*>(nativeChromeBrowserProvider); CHECK_NATIVE_PTR(env, jcaller, native, "Destroy"); - return native->Destroy(env, jcaller); + return native->Destroy(env, JavaParamRef<jobject>(env, jcaller)); } // Step 3: RegisterNatives. diff --git a/base/android/jni_generator/testSingleJNIAdditionalImport.golden b/base/android/jni_generator/testSingleJNIAdditionalImport.golden index 3536139..1b2895ee 100644 --- a/base/android/jni_generator/testSingleJNIAdditionalImport.golden +++ b/base/android/jni_generator/testSingleJNIAdditionalImport.golden @@ -27,13 +27,14 @@ jclass g_Foo_clazz = NULL; // Step 2: method stubs. -static void DoSomething(JNIEnv* env, jclass jcaller, - jobject callback); +static void DoSomething(JNIEnv* env, const JavaParamRef<jclass>& jcaller, + const JavaParamRef<jobject>& callback); static void Java_org_chromium_foo_Foo_nativeDoSomething(JNIEnv* env, jclass jcaller, jobject callback) { - return DoSomething(env, jcaller, callback); + return DoSomething(env, JavaParamRef<jclass>(env, jcaller), + JavaParamRef<jobject>(env, callback)); } static base::subtle::AtomicWord g_Foo_calledByNative = 0; diff --git a/base/android/library_loader/library_loader_hooks.cc b/base/android/library_loader/library_loader_hooks.cc index 18eb7b9..67b7c5d 100644 --- a/base/android/library_loader/library_loader_hooks.cc +++ b/base/android/library_loader/library_loader_hooks.cc @@ -57,7 +57,7 @@ long g_renderer_library_load_time_ms = 0; static void RegisterChromiumAndroidLinkerRendererHistogram( JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jboolean requested_shared_relro, jboolean load_at_fixed_address_failed, jlong library_load_time_ms) { @@ -88,7 +88,7 @@ void RecordChromiumAndroidLinkerRendererHistogram() { static void RecordChromiumAndroidLinkerBrowserHistogram( JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jboolean is_using_browser_shared_relros, jboolean load_at_fixed_address_failed, jint library_load_from_apk_status, @@ -120,13 +120,15 @@ void SetLibraryLoadedHook(LibraryLoadedHook* func) { g_registration_callback = func; } -static void InitCommandLine(JNIEnv* env, - jobject jcaller, - jobjectArray init_command_line) { +static void InitCommandLine( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + const JavaParamRef<jobjectArray>& init_command_line) { InitNativeCommandLineFromJavaArray(env, init_command_line); } -static jboolean LibraryLoaded(JNIEnv* env, jobject jcaller) { +static jboolean LibraryLoaded(JNIEnv* env, + const JavaParamRef<jobject>& jcaller) { if (g_registration_callback == NULL) { return true; } @@ -140,7 +142,9 @@ void LibraryLoaderExitHook() { } } -static jboolean ForkAndPrefetchNativeLibrary(JNIEnv* env, jclass clazz) { +static jboolean ForkAndPrefetchNativeLibrary( + JNIEnv* env, + const JavaParamRef<jclass>& clazz) { return NativeLibraryPrefetcher::ForkAndPrefetchNativeLibrary(); } @@ -152,7 +156,9 @@ void SetVersionNumber(const char* version_number) { g_library_version_number = strdup(version_number); } -ScopedJavaLocalRef<jstring> GetVersionNumber(JNIEnv* env, jobject jcaller) { +ScopedJavaLocalRef<jstring> GetVersionNumber( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller) { return ConvertUTF8ToJavaString(env, g_library_version_number); } diff --git a/base/android/memory_pressure_listener_android.cc b/base/android/memory_pressure_listener_android.cc index 80c07bc..9d3dd46 100644 --- a/base/android/memory_pressure_listener_android.cc +++ b/base/android/memory_pressure_listener_android.cc @@ -8,8 +8,9 @@ #include "jni/MemoryPressureListener_jni.h" // Defined and called by JNI. -static void OnMemoryPressure( - JNIEnv* env, jclass clazz, jint memory_pressure_level) { +static void OnMemoryPressure(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + jint memory_pressure_level) { base::MemoryPressureListener::NotifyMemoryPressure( static_cast<base::MemoryPressureListener::MemoryPressureLevel>( memory_pressure_level)); diff --git a/base/android/path_service_android.cc b/base/android/path_service_android.cc index 18ca70c..9972bbb6 100644 --- a/base/android/path_service_android.cc +++ b/base/android/path_service_android.cc @@ -13,7 +13,10 @@ namespace base { namespace android { -void Override(JNIEnv* env, jclass clazz, jint what, jstring path) { +void Override(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + jint what, + const JavaParamRef<jstring>& path) { FilePath file_path(ConvertJavaStringToUTF8(env, path)); PathService::Override(what, file_path); } diff --git a/base/android/record_histogram.cc b/base/android/record_histogram.cc index 0688e4f..51ca482 100644 --- a/base/android/record_histogram.cc +++ b/base/android/record_histogram.cc @@ -174,8 +174,8 @@ base::LazyInstance<HistogramCache>::Leaky g_histograms; } // namespace void RecordBooleanHistogram(JNIEnv* env, - jclass clazz, - jstring j_histogram_name, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& j_histogram_name, jint j_histogram_key, jboolean j_sample) { bool sample = static_cast<bool>(j_sample); @@ -185,8 +185,8 @@ void RecordBooleanHistogram(JNIEnv* env, } void RecordEnumeratedHistogram(JNIEnv* env, - jclass clazz, - jstring j_histogram_name, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& j_histogram_name, jint j_histogram_key, jint j_sample, jint j_boundary) { @@ -198,8 +198,8 @@ void RecordEnumeratedHistogram(JNIEnv* env, } void RecordCustomCountHistogram(JNIEnv* env, - jclass clazz, - jstring j_histogram_name, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& j_histogram_name, jint j_histogram_key, jint j_sample, jint j_min, @@ -214,8 +214,8 @@ void RecordCustomCountHistogram(JNIEnv* env, } void RecordLinearCountHistogram(JNIEnv* env, - jclass clazz, - jstring j_histogram_name, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& j_histogram_name, jint j_histogram_key, jint j_sample, jint j_min, @@ -230,31 +230,32 @@ void RecordLinearCountHistogram(JNIEnv* env, } void RecordSparseHistogram(JNIEnv* env, - jclass clazz, - jstring j_histogram_name, - jint j_histogram_key, - jint j_sample) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& j_histogram_name, + jint j_histogram_key, + jint j_sample) { int sample = static_cast<int>(j_sample); g_histograms.Get() .SparseHistogram(env, j_histogram_name, j_histogram_key) ->Add(sample); } -void RecordCustomTimesHistogramMilliseconds(JNIEnv* env, - jclass clazz, - jstring j_histogram_name, - jint j_histogram_key, - jlong j_duration, - jlong j_min, - jlong j_max, - jint j_num_buckets) { +void RecordCustomTimesHistogramMilliseconds( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& j_histogram_name, + jint j_histogram_key, + jlong j_duration, + jlong j_min, + jlong j_max, + jint j_num_buckets) { g_histograms.Get() .CustomTimesHistogram(env, j_histogram_name, j_histogram_key, j_min, j_max, j_num_buckets) ->AddTime(TimeDelta::FromMilliseconds(static_cast<int64>(j_duration))); } -void Initialize(JNIEnv* env, jclass) { +void Initialize(JNIEnv* env, const JavaParamRef<jclass>&) { StatisticsRecorder::Initialize(); } @@ -262,10 +263,11 @@ void Initialize(JNIEnv* env, jclass) { // MetricsUtils.HistogramDelta. It should live in a test-specific file, but we // currently can't have test-specific native code packaged in test-specific Java // targets - see http://crbug.com/415945. -jint GetHistogramValueCountForTesting(JNIEnv* env, - jclass clazz, - jstring histogram_name, - jint sample) { +jint GetHistogramValueCountForTesting( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& histogram_name, + jint sample) { HistogramBase* histogram = StatisticsRecorder::FindHistogram( android::ConvertJavaStringToUTF8(env, histogram_name)); if (histogram == nullptr) { diff --git a/base/android/record_user_action.cc b/base/android/record_user_action.cc index 6172f2e..1452341 100644 --- a/base/android/record_user_action.cc +++ b/base/android/record_user_action.cc @@ -11,7 +11,9 @@ namespace base { namespace android { -static void RecordUserAction(JNIEnv* env, jclass clazz, jstring j_action) { +static void RecordUserAction(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& j_action) { RecordComputedAction(ConvertJavaStringToUTF8(env, j_action)); } diff --git a/base/android/scoped_java_ref.h b/base/android/scoped_java_ref.h index 37e7fd3..d6a81fa 100644 --- a/base/android/scoped_java_ref.h +++ b/base/android/scoped_java_ref.h @@ -94,6 +94,27 @@ class JavaRef : public JavaRef<jobject> { DISALLOW_COPY_AND_ASSIGN(JavaRef); }; +// Holds a local reference to a JNI method parameter. +// Method parameters should not be deleted, and so this class exists purely to +// wrap them as a JavaRef<T> in the JNI binding generator. Do not create +// instances manually. +template<typename T> +class JavaParamRef : public JavaRef<T> { + public: + // Assumes that |obj| is a parameter passed to a JNI method from Java. + // Does not assume ownership as parameters should not be deleted. + JavaParamRef(JNIEnv* env, T obj) : JavaRef<T>(env, obj) {} + + ~JavaParamRef() {} + + // TODO(torne): remove this cast once we're using JavaRef consistently. + // http://crbug.com/506850 + operator T() const { return JavaRef<T>::obj(); } + + private: + DISALLOW_COPY_AND_ASSIGN(JavaParamRef); +}; + // Holds a local reference to a Java object. The local reference is scoped // to the lifetime of this object. // Instances of this class may hold onto any JNIEnv passed into it until @@ -208,6 +229,11 @@ class ScopedJavaGlobalRef : public JavaRef<T> { } template<typename U> + void Reset(JNIEnv* env, const JavaParamRef<U>& other) { + this->Reset(env, other.obj()); + } + + template<typename U> void Reset(JNIEnv* env, U obj) { implicit_cast<T>(obj); // Ensure U is assignable to T this->SetNewGlobalRef(env, obj); diff --git a/base/android/trace_event_binding.cc b/base/android/trace_event_binding.cc index 3c5ee17..f761a64 100644 --- a/base/android/trace_event_binding.cc +++ b/base/android/trace_event_binding.cc @@ -69,23 +69,26 @@ base::LazyInstance<TraceEnabledObserver>::Leaky g_trace_enabled_state_observer_; } // namespace -static void RegisterEnabledObserver(JNIEnv* env, jclass clazz) { +static void RegisterEnabledObserver(JNIEnv* env, + const JavaParamRef<jclass>& clazz) { bool enabled = trace_event::TraceLog::GetInstance()->IsEnabled(); base::android::Java_TraceEvent_setEnabled(env, enabled); trace_event::TraceLog::GetInstance()->AddEnabledStateObserver( g_trace_enabled_state_observer_.Pointer()); } -static void StartATrace(JNIEnv* env, jclass clazz) { +static void StartATrace(JNIEnv* env, const JavaParamRef<jclass>& clazz) { base::trace_event::TraceLog::GetInstance()->StartATrace(); } -static void StopATrace(JNIEnv* env, jclass clazz) { +static void StopATrace(JNIEnv* env, const JavaParamRef<jclass>& clazz) { base::trace_event::TraceLog::GetInstance()->StopATrace(); } -static void Instant(JNIEnv* env, jclass clazz, - jstring jname, jstring jarg) { +static void Instant(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jname, + const JavaParamRef<jstring>& jarg) { TraceEventDataConverter converter(env, jname, jarg); if (converter.arg()) { TRACE_EVENT_COPY_INSTANT1(kJavaCategory, converter.name(), @@ -97,8 +100,10 @@ static void Instant(JNIEnv* env, jclass clazz, } } -static void Begin(JNIEnv* env, jclass clazz, - jstring jname, jstring jarg) { +static void Begin(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jname, + const JavaParamRef<jstring>& jarg) { TraceEventDataConverter converter(env, jname, jarg); if (converter.arg()) { TRACE_EVENT_COPY_BEGIN1(kJavaCategory, converter.name(), @@ -108,8 +113,10 @@ static void Begin(JNIEnv* env, jclass clazz, } } -static void End(JNIEnv* env, jclass clazz, - jstring jname, jstring jarg) { +static void End(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jname, + const JavaParamRef<jstring>& jarg) { TraceEventDataConverter converter(env, jname, jarg); if (converter.arg()) { TRACE_EVENT_COPY_END1(kJavaCategory, converter.name(), @@ -119,20 +126,26 @@ static void End(JNIEnv* env, jclass clazz, } } -static void BeginToplevel(JNIEnv* env, jclass clazz) { +static void BeginToplevel(JNIEnv* env, const JavaParamRef<jclass>& clazz) { TRACE_EVENT_BEGIN0(kToplevelCategory, kLooperDispatchMessage); } -static void EndToplevel(JNIEnv* env, jclass clazz) { +static void EndToplevel(JNIEnv* env, const JavaParamRef<jclass>& clazz) { TRACE_EVENT_END0(kToplevelCategory, kLooperDispatchMessage); } -static void StartAsync(JNIEnv* env, jclass clazz, jstring jname, jlong jid) { +static void StartAsync(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jname, + jlong jid) { TraceEventDataConverter converter(env, jname, nullptr); TRACE_EVENT_COPY_ASYNC_BEGIN0(kJavaCategory, converter.name(), jid); } -static void FinishAsync(JNIEnv* env, jclass clazz, jstring jname, jlong jid) { +static void FinishAsync(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jname, + jlong jid) { TraceEventDataConverter converter(env, jname, nullptr); TRACE_EVENT_COPY_ASYNC_END0(kJavaCategory, converter.name(), jid); } diff --git a/base/message_loop/message_pump_android.cc b/base/message_loop/message_pump_android.cc index babd17b..a0eee12 100644 --- a/base/message_loop/message_pump_android.cc +++ b/base/message_loop/message_pump_android.cc @@ -21,8 +21,10 @@ using base::android::ScopedJavaLocalRef; // ---------------------------------------------------------------------------- // This method can not move to anonymous namespace as it has been declared as // 'static' in system_message_handler_jni.h. -static void DoRunLoopOnce(JNIEnv* env, jobject obj, jlong native_delegate, - jlong delayed_scheduled_time_ticks) { +static void DoRunLoopOnce(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jlong native_delegate, + jlong delayed_scheduled_time_ticks) { base::MessagePump::Delegate* delegate = reinterpret_cast<base::MessagePump::Delegate*>(native_delegate); DCHECK(delegate); diff --git a/base/power_monitor/power_monitor_device_source_android.cc b/base/power_monitor/power_monitor_device_source_android.cc index 4d9eb52..9671c30 100644 --- a/base/power_monitor/power_monitor_device_source_android.cc +++ b/base/power_monitor/power_monitor_device_source_android.cc @@ -19,15 +19,15 @@ void ProcessPowerEventHelper(PowerMonitorSource::PowerEvent event) { namespace android { // Native implementation of PowerMonitor.java. -void OnBatteryChargingChanged(JNIEnv* env, jclass clazz) { +void OnBatteryChargingChanged(JNIEnv* env, const JavaParamRef<jclass>& clazz) { ProcessPowerEventHelper(PowerMonitorSource::POWER_STATE_EVENT); } -void OnMainActivityResumed(JNIEnv* env, jclass clazz) { +void OnMainActivityResumed(JNIEnv* env, const JavaParamRef<jclass>& clazz) { ProcessPowerEventHelper(PowerMonitorSource::RESUME_EVENT); } -void OnMainActivitySuspended(JNIEnv* env, jclass clazz) { +void OnMainActivitySuspended(JNIEnv* env, const JavaParamRef<jclass>& clazz) { ProcessPowerEventHelper(PowerMonitorSource::SUSPEND_EVENT); } diff --git a/chrome/browser/after_startup_task_utils_android.cc b/chrome/browser/after_startup_task_utils_android.cc index a57cc8b..925b6c1 100644 --- a/chrome/browser/after_startup_task_utils_android.cc +++ b/chrome/browser/after_startup_task_utils_android.cc @@ -18,7 +18,7 @@ class AfterStartupTaskUtilsJNI { } // android -static void SetStartupComplete(JNIEnv* env, jclass obj) { +static void SetStartupComplete(JNIEnv* env, const JavaParamRef<jclass>& obj) { android::AfterStartupTaskUtilsJNI::SetBrowserStartupIsComplete(); } diff --git a/chrome/browser/android/accessibility/font_size_prefs_android.cc b/chrome/browser/android/accessibility/font_size_prefs_android.cc index 72ddb10..56e94ed 100644 --- a/chrome/browser/android/accessibility/font_size_prefs_android.cc +++ b/chrome/browser/android/accessibility/font_size_prefs_android.cc @@ -71,7 +71,7 @@ bool FontSizePrefsAndroid::Register(JNIEnv* env) { return RegisterNativesImpl(env); } -jlong Init(JNIEnv* env, jobject obj) { +jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { FontSizePrefsAndroid* font_size_prefs_android = new FontSizePrefsAndroid(env, obj); return reinterpret_cast<intptr_t>(font_size_prefs_android); @@ -109,7 +109,7 @@ void FontSizePrefsObserverAndroid::DestroyObserverAndroid(JNIEnv* env, delete this; } -jlong InitObserverAndroid(JNIEnv* env, jobject obj) { +jlong InitObserverAndroid(JNIEnv* env, const JavaParamRef<jobject>& obj) { FontSizePrefsObserverAndroid* observer_wrapper = new FontSizePrefsObserverAndroid(env, obj); return reinterpret_cast<intptr_t>(observer_wrapper); diff --git a/chrome/browser/android/appmenu/app_menu_drag_helper.cc b/chrome/browser/android/appmenu/app_menu_drag_helper.cc index 7d285d5..1f018ea 100644 --- a/chrome/browser/android/appmenu/app_menu_drag_helper.cc +++ b/chrome/browser/android/appmenu/app_menu_drag_helper.cc @@ -11,7 +11,9 @@ bool RegisterAppMenuDragHelper(JNIEnv* env) { } // static -void RecordAppMenuTouchDuration(JNIEnv* env, jclass jcaller, jlong time_ms) { +void RecordAppMenuTouchDuration(JNIEnv* env, + const JavaParamRef<jclass>& jcaller, + jlong time_ms) { UMA_HISTOGRAM_TIMES("WrenchMenu.TouchDuration", base::TimeDelta::FromMilliseconds(time_ms)); } diff --git a/chrome/browser/android/banners/app_banner_manager_android.cc b/chrome/browser/android/banners/app_banner_manager_android.cc index d158824..27d1f45 100644 --- a/chrome/browser/android/banners/app_banner_manager_android.cc +++ b/chrome/browser/android/banners/app_banner_manager_android.cc @@ -176,29 +176,32 @@ bool AppBannerManagerAndroid::Register(JNIEnv* env) { return RegisterNativesImpl(env); } -jlong Init(JNIEnv* env, jobject obj, jint icon_size) { +jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj, jint icon_size) { AppBannerManagerAndroid* manager = new AppBannerManagerAndroid(env, obj, icon_size); return reinterpret_cast<intptr_t>(manager); } -void SetTimeDeltaForTesting(JNIEnv* env, jclass clazz, jint days) { +void SetTimeDeltaForTesting(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + jint days) { AppBannerDataFetcher::SetTimeDeltaForTesting(days); } -void DisableSecureSchemeCheckForTesting(JNIEnv* env, jclass clazz) { +void DisableSecureSchemeCheckForTesting(JNIEnv* env, + const JavaParamRef<jclass>& clazz) { AppBannerManager::DisableSecureSchemeCheckForTesting(); } void SetEngagementWeights(JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jdouble direct_engagement, jdouble indirect_engagement) { AppBannerManager::SetEngagementWeights(direct_engagement, indirect_engagement); } -jboolean IsEnabled(JNIEnv* env, jclass clazz) { +jboolean IsEnabled(JNIEnv* env, const JavaParamRef<jclass>& clazz) { return base::FieldTrialList::FindFullName("AppBanners") == "Enabled"; } diff --git a/chrome/browser/android/bookmarks/bookmarks_bridge.cc b/chrome/browser/android/bookmarks/bookmarks_bridge.cc index 663ddc3..db7145a 100644 --- a/chrome/browser/android/bookmarks/bookmarks_bridge.cc +++ b/chrome/browser/android/bookmarks/bookmarks_bridge.cc @@ -134,13 +134,16 @@ bool BookmarksBridge::RegisterBookmarksBridge(JNIEnv* env) { return RegisterNativesImpl(env); } -static jlong Init(JNIEnv* env, jobject obj, jobject j_profile) { +static jlong Init(JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& j_profile) { BookmarksBridge* delegate = new BookmarksBridge(env, obj, j_profile); return reinterpret_cast<intptr_t>(delegate); } -static jboolean IsEnhancedBookmarksFeatureEnabled(JNIEnv* env, - jclass clazz) { +static jboolean IsEnhancedBookmarksFeatureEnabled( + JNIEnv* env, + const JavaParamRef<jclass>& clazz) { return enhanced_bookmarks::IsEnhancedBookmarksEnabled(); } diff --git a/chrome/browser/android/bookmarks/edit_bookmark_helper.cc b/chrome/browser/android/bookmarks/edit_bookmark_helper.cc index c55faf7..6b94576 100644 --- a/chrome/browser/android/bookmarks/edit_bookmark_helper.cc +++ b/chrome/browser/android/bookmarks/edit_bookmark_helper.cc @@ -15,10 +15,10 @@ using bookmarks::BookmarkNode; void SetPartnerBookmarkTitle(JNIEnv* env, - jclass clazz, - jobject jprofile, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& jprofile, jlong bookmark_id, - jstring new_title) { + const JavaParamRef<jstring>& new_title) { PartnerBookmarksShim* partner_bookmarks_shim = PartnerBookmarksShim::BuildForBrowserContext( chrome::GetBrowserContextRedirectedInIncognito( diff --git a/chrome/browser/android/bookmarks/partner_bookmarks_reader.cc b/chrome/browser/android/bookmarks/partner_bookmarks_reader.cc index 7894193..aae7a3e 100644 --- a/chrome/browser/android/bookmarks/partner_bookmarks_reader.cc +++ b/chrome/browser/android/bookmarks/partner_bookmarks_reader.cc @@ -183,7 +183,8 @@ jlong PartnerBookmarksReader::AddPartnerBookmark(JNIEnv* env, } // static -static void DisablePartnerBookmarksEditing(JNIEnv* env, jclass clazz) { +static void DisablePartnerBookmarksEditing(JNIEnv* env, + const JavaParamRef<jclass>& clazz) { PartnerBookmarksShim::DisablePartnerBookmarksEditing(); } @@ -194,7 +195,7 @@ bool PartnerBookmarksReader::RegisterPartnerBookmarksReader(JNIEnv* env) { // ---------------------------------------------------------------- -static jlong Init(JNIEnv* env, jobject obj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { Profile* profile = ProfileManager::GetActiveUserProfile(); PartnerBookmarksShim* partner_bookmarks_shim = PartnerBookmarksShim::BuildForBrowserContext(profile); diff --git a/chrome/browser/android/bottombar/contextualsearch/contextual_search_panel.cc b/chrome/browser/android/bottombar/contextualsearch/contextual_search_panel.cc index 41235e3..0d9d7b0 100644 --- a/chrome/browser/android/bottombar/contextualsearch/contextual_search_panel.cc +++ b/chrome/browser/android/bottombar/contextualsearch/contextual_search_panel.cc @@ -141,7 +141,7 @@ bool RegisterContextualSearchPanel(JNIEnv* env) { return RegisterNativesImpl(env); } -jlong Init(JNIEnv* env, jobject obj) { +jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { ContextualSearchPanel* manager = new ContextualSearchPanel(env, obj); return reinterpret_cast<intptr_t>(manager); } diff --git a/chrome/browser/android/chrome_application.cc b/chrome/browser/android/chrome_application.cc index a5661ef..241bdd2 100644 --- a/chrome/browser/android/chrome_application.cc +++ b/chrome/browser/android/chrome_application.cc @@ -81,12 +81,13 @@ void ChangeAppStatusOnIOThread(SafeBrowsingService* sb_service, } // namespace -static ScopedJavaLocalRef<jstring> GetBrowserUserAgent(JNIEnv* env, - jclass clazz) { +static ScopedJavaLocalRef<jstring> GetBrowserUserAgent( + JNIEnv* env, + const JavaParamRef<jclass>& clazz) { return ConvertUTF8ToJavaString(env, GetUserAgent()); } -static void FlushPersistentData(JNIEnv* env, jclass obj) { +static void FlushPersistentData(JNIEnv* env, const JavaParamRef<jclass>& obj) { // Commit the prending writes for all the loaded profiles. std::vector<Profile*> loaded_profiles = g_browser_process->profile_manager()->GetLoadedProfiles(); @@ -97,14 +98,16 @@ static void FlushPersistentData(JNIEnv* env, jclass obj) { g_browser_process->local_state()->CommitPendingWrite(); } -static void RemoveSessionCookies(JNIEnv* env, jclass obj) { +static void RemoveSessionCookies(JNIEnv* env, const JavaParamRef<jclass>& obj) { std::vector<Profile*> loaded_profiles = g_browser_process->profile_manager()->GetLoadedProfiles(); std::for_each(loaded_profiles.begin(), loaded_profiles.end(), RemoveSessionCookiesForProfile); } -static void ChangeAppStatus(JNIEnv* env, jclass obj, jboolean foreground) { +static void ChangeAppStatus(JNIEnv* env, + const JavaParamRef<jclass>& obj, + jboolean foreground) { content::BrowserThread::PostTask( content::BrowserThread::IO, FROM_HERE, base::Bind(&ChangeAppStatusOnIOThread, diff --git a/chrome/browser/android/chrome_web_contents_delegate_android.cc b/chrome/browser/android/chrome_web_contents_delegate_android.cc index 0f17a14..1fb8fcf3 100644 --- a/chrome/browser/android/chrome_web_contents_delegate_android.cc +++ b/chrome/browser/android/chrome_web_contents_delegate_android.cc @@ -387,8 +387,8 @@ void ChromeWebContentsDelegateAndroid::AddNewContents( } // namespace chrome jboolean IsCapturingAudio(JNIEnv* env, - jclass clazz, - jobject java_web_contents) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& java_web_contents) { content::WebContents* web_contents = content::WebContents::FromJavaWebContents(java_web_contents); scoped_refptr<MediaStreamCaptureIndicator> indicator = @@ -398,8 +398,8 @@ jboolean IsCapturingAudio(JNIEnv* env, } jboolean IsCapturingVideo(JNIEnv* env, - jclass clazz, - jobject java_web_contents) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& java_web_contents) { content::WebContents* web_contents = content::WebContents::FromJavaWebContents(java_web_contents); scoped_refptr<MediaStreamCaptureIndicator> indicator = diff --git a/chrome/browser/android/compositor/compositor_view.cc b/chrome/browser/android/compositor/compositor_view.cc index c89995e..ff75b95 100644 --- a/chrome/browser/android/compositor/compositor_view.cc +++ b/chrome/browser/android/compositor/compositor_view.cc @@ -41,12 +41,12 @@ namespace chrome { namespace android { jlong Init(JNIEnv* env, - jobject obj, + const JavaParamRef<jobject>& obj, jboolean low_mem_device, jint empty_background_color, jlong native_window_android, - jobject jlayer_title_cache, - jobject jtab_content_manager) { + const JavaParamRef<jobject>& jlayer_title_cache, + const JavaParamRef<jobject>& jtab_content_manager) { CompositorView* view; ui::WindowAndroid* window_android = reinterpret_cast<ui::WindowAndroid*>(native_window_android); diff --git a/chrome/browser/android/compositor/layer_title_cache.cc b/chrome/browser/android/compositor/layer_title_cache.cc index 3db241b..ac8c776 100644 --- a/chrome/browser/android/compositor/layer_title_cache.cc +++ b/chrome/browser/android/compositor/layer_title_cache.cc @@ -109,7 +109,7 @@ bool RegisterLayerTitleCache(JNIEnv* env) { // ---------------------------------------------------------------------------- jlong Init(JNIEnv* env, - jobject obj, + const JavaParamRef<jobject>& obj, jint fade_width, jint favicon_start_padding, jint favicon_end_padding, diff --git a/chrome/browser/android/compositor/scene_layer/contextual_search_scene_layer.cc b/chrome/browser/android/compositor/scene_layer/contextual_search_scene_layer.cc index 14496ef..7735c39 100644 --- a/chrome/browser/android/compositor/scene_layer/contextual_search_scene_layer.cc +++ b/chrome/browser/android/compositor/scene_layer/contextual_search_scene_layer.cc @@ -119,7 +119,7 @@ void ContextualSearchSceneLayer::UpdateContextualSearchLayer( progress_bar_completion); } -static jlong Init(JNIEnv* env, jobject jobj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& jobj) { // This will automatically bind to the Java object and pass ownership there. ContextualSearchSceneLayer* tree_provider = new ContextualSearchSceneLayer(env, jobj); diff --git a/chrome/browser/android/compositor/scene_layer/reader_mode_scene_layer.cc b/chrome/browser/android/compositor/scene_layer/reader_mode_scene_layer.cc index 80c22df..2817feb 100644 --- a/chrome/browser/android/compositor/scene_layer/reader_mode_scene_layer.cc +++ b/chrome/browser/android/compositor/scene_layer/reader_mode_scene_layer.cc @@ -64,7 +64,7 @@ void ReaderModeSceneLayer::UpdateReaderModeLayer( panel_text_opacity, header_background_color); } -static jlong Init(JNIEnv* env, jobject jobj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& jobj) { // This will automatically bind to the Java object and pass ownership there. ReaderModeSceneLayer* tree_provider = new ReaderModeSceneLayer(env, jobj); diff --git a/chrome/browser/android/compositor/scene_layer/scene_layer.cc b/chrome/browser/android/compositor/scene_layer/scene_layer.cc index 33d4c21..5995e97 100644 --- a/chrome/browser/android/compositor/scene_layer/scene_layer.cc +++ b/chrome/browser/android/compositor/scene_layer/scene_layer.cc @@ -58,7 +58,7 @@ SkColor SceneLayer::GetBackgroundColor() { return SK_ColorWHITE; } -static jlong Init(JNIEnv* env, jobject jobj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& jobj) { // This will automatically bind to the Java object and pass ownership there. SceneLayer* tree_provider = new SceneLayer(env, jobj); return reinterpret_cast<intptr_t>(tree_provider); diff --git a/chrome/browser/android/compositor/scene_layer/static_tab_scene_layer.cc b/chrome/browser/android/compositor/scene_layer/static_tab_scene_layer.cc index f22bc02..540a963 100644 --- a/chrome/browser/android/compositor/scene_layer/static_tab_scene_layer.cc +++ b/chrome/browser/android/compositor/scene_layer/static_tab_scene_layer.cc @@ -136,7 +136,7 @@ void StaticTabSceneLayer::SetContentSceneLayer(JNIEnv* env, } } -static jlong Init(JNIEnv* env, jobject jobj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& jobj) { // This will automatically bind to the Java object and pass ownership there. StaticTabSceneLayer* scene_layer = new StaticTabSceneLayer(env, jobj); return reinterpret_cast<intptr_t>(scene_layer); diff --git a/chrome/browser/android/compositor/scene_layer/tab_list_scene_layer.cc b/chrome/browser/android/compositor/scene_layer/tab_list_scene_layer.cc index ea64894..5903160 100644 --- a/chrome/browser/android/compositor/scene_layer/tab_list_scene_layer.cc +++ b/chrome/browser/android/compositor/scene_layer/tab_list_scene_layer.cc @@ -202,7 +202,7 @@ scoped_refptr<TabLayer> TabListSceneLayer::GetNextLayer(bool incognito) { return layer; } -static jlong Init(JNIEnv* env, jobject jobj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& jobj) { // This will automatically bind to the Java object and pass ownership there. TabListSceneLayer* scene_layer = new TabListSceneLayer(env, jobj); return reinterpret_cast<intptr_t>(scene_layer); diff --git a/chrome/browser/android/compositor/scene_layer/tab_strip_scene_layer.cc b/chrome/browser/android/compositor/scene_layer/tab_strip_scene_layer.cc index 026984b..434f9b9 100644 --- a/chrome/browser/android/compositor/scene_layer/tab_strip_scene_layer.cc +++ b/chrome/browser/android/compositor/scene_layer/tab_strip_scene_layer.cc @@ -216,7 +216,7 @@ scoped_refptr<TabHandleLayer> TabStripSceneLayer::GetNextLayer( return layer_tree; } -static jlong Init(JNIEnv* env, jobject jobj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& jobj) { // This will automatically bind to the Java object and pass ownership there. TabStripSceneLayer* scene_layer = new TabStripSceneLayer(env, jobj); return reinterpret_cast<intptr_t>(scene_layer); diff --git a/chrome/browser/android/compositor/tab_content_manager.cc b/chrome/browser/android/compositor/tab_content_manager.cc index 4da3916..6746910 100644 --- a/chrome/browser/android/compositor/tab_content_manager.cc +++ b/chrome/browser/android/compositor/tab_content_manager.cc @@ -370,7 +370,7 @@ bool RegisterTabContentManager(JNIEnv* env) { // ---------------------------------------------------------------------------- jlong Init(JNIEnv* env, - jobject obj, + const JavaParamRef<jobject>& obj, jint default_cache_size, jint approximation_cache_size, jint compression_queue_max_size, diff --git a/chrome/browser/android/contextualsearch/contextual_search_manager.cc b/chrome/browser/android/contextualsearch/contextual_search_manager.cc index dfd5153..be8f127 100644 --- a/chrome/browser/android/contextualsearch/contextual_search_manager.cc +++ b/chrome/browser/android/contextualsearch/contextual_search_manager.cc @@ -146,7 +146,7 @@ bool RegisterContextualSearchManager(JNIEnv* env) { return RegisterNativesImpl(env); } -jlong Init(JNIEnv* env, jobject obj) { +jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { ContextualSearchManager* manager = new ContextualSearchManager(env, obj); return reinterpret_cast<intptr_t>(manager); } diff --git a/chrome/browser/android/contextualsearch/contextual_search_tab_helper.cc b/chrome/browser/android/contextualsearch/contextual_search_tab_helper.cc index 6e635c5..8dfc691 100644 --- a/chrome/browser/android/contextualsearch/contextual_search_tab_helper.cc +++ b/chrome/browser/android/contextualsearch/contextual_search_tab_helper.cc @@ -40,7 +40,9 @@ void ContextualSearchTabHelper::Destroy(JNIEnv* env, jobject obj) { delete this; } -static jlong Init(JNIEnv* env, jobject obj, jobject java_profile) { +static jlong Init(JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& java_profile) { Profile* profile = ProfileAndroid::FromProfileAndroid(java_profile); CHECK(profile); ContextualSearchTabHelper* tab = new ContextualSearchTabHelper( diff --git a/chrome/browser/android/cookies/cookies_fetcher.cc b/chrome/browser/android/cookies/cookies_fetcher.cc index 255f914..d8c4bf1 100644 --- a/chrome/browser/android/cookies/cookies_fetcher.cc +++ b/chrome/browser/android/cookies/cookies_fetcher.cc @@ -161,7 +161,7 @@ void CookiesFetcher::RestoreToCookieJarInternal( } // JNI functions -static jlong Init(JNIEnv* env, jobject obj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { return reinterpret_cast<intptr_t>(new CookiesFetcher(env, obj, 0)); } diff --git a/chrome/browser/android/dev_tools_server.cc b/chrome/browser/android/dev_tools_server.cc index 20aea05..13faafe 100644 --- a/chrome/browser/android/dev_tools_server.cc +++ b/chrome/browser/android/dev_tools_server.cc @@ -229,26 +229,29 @@ bool RegisterDevToolsServer(JNIEnv* env) { return RegisterNativesImpl(env); } -static jlong InitRemoteDebugging(JNIEnv* env, - jobject obj, - jstring socket_name_prefix) { +static jlong InitRemoteDebugging( + JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jstring>& socket_name_prefix) { DevToolsServer* server = new DevToolsServer( base::android::ConvertJavaStringToUTF8(env, socket_name_prefix)); return reinterpret_cast<intptr_t>(server); } -static void DestroyRemoteDebugging(JNIEnv* env, jobject obj, jlong server) { +static void DestroyRemoteDebugging(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jlong server) { delete reinterpret_cast<DevToolsServer*>(server); } static jboolean IsRemoteDebuggingEnabled(JNIEnv* env, - jobject obj, + const JavaParamRef<jobject>& obj, jlong server) { return reinterpret_cast<DevToolsServer*>(server)->IsStarted(); } static void SetRemoteDebuggingEnabled(JNIEnv* env, - jobject obj, + const JavaParamRef<jobject>& obj, jlong server, jboolean enabled, jboolean allow_debug_permission) { diff --git a/chrome/browser/android/document/document_web_contents_delegate.cc b/chrome/browser/android/document/document_web_contents_delegate.cc index a56362a..25b8067 100644 --- a/chrome/browser/android/document/document_web_contents_delegate.cc +++ b/chrome/browser/android/document/document_web_contents_delegate.cc @@ -55,7 +55,6 @@ bool DocumentWebContentsDelegate::ShouldCreateWebContents( return false; } - -static jlong Initialize(JNIEnv* env, jobject obj) { +static jlong Initialize(JNIEnv* env, const JavaParamRef<jobject>& obj) { return reinterpret_cast<intptr_t>(new DocumentWebContentsDelegate(env, obj)); } diff --git a/chrome/browser/android/download/chrome_download_delegate.cc b/chrome/browser/android/download/chrome_download_delegate.cc index 9dd66ee..e570d24 100644 --- a/chrome/browser/android/download/chrome_download_delegate.cc +++ b/chrome/browser/android/download/chrome_download_delegate.cc @@ -23,9 +23,10 @@ #include "ui/base/l10n/l10n_util.h" // Gets the download warning text for the given file name. -static ScopedJavaLocalRef<jstring> GetDownloadWarningText(JNIEnv* env, - jclass clazz, - jstring filename) { +static ScopedJavaLocalRef<jstring> GetDownloadWarningText( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& filename) { return base::android::ConvertUTF8ToJavaString( env, l10n_util::GetStringFUTF8( IDS_PROMPT_DANGEROUS_DOWNLOAD, @@ -33,16 +34,20 @@ static ScopedJavaLocalRef<jstring> GetDownloadWarningText(JNIEnv* env, } // Returns true if a file name is dangerous, or false otherwise. -static jboolean IsDownloadDangerous( - JNIEnv* env, jclass clazz, jstring filename) { +static jboolean IsDownloadDangerous(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& filename) { base::FilePath path(base::android::ConvertJavaStringToUTF8(env, filename)); return download_util::GetFileDangerLevel(path) != download_util::NOT_DANGEROUS; } // Called when a dangerous download is validated. -static void DangerousDownloadValidated( - JNIEnv* env, jclass clazz, jobject tab, jint download_id, jboolean accept) { +static void DangerousDownloadValidated(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& tab, + jint download_id, + jboolean accept) { TabAndroid* tab_android = TabAndroid::GetNativeTab(env, tab); content::DownloadControllerAndroid::Get()->DangerousDownloadValidated( tab_android->web_contents(), download_id, accept); @@ -61,14 +66,15 @@ void ChromeDownloadDelegate::EnqueueDownloadManagerRequest( // Called when we need to interrupt download and ask users whether to overwrite // an existing file. -static void LaunchDownloadOverwriteInfoBar(JNIEnv* env, - jclass clazz, - jobject delegate, - jobject tab, - jobject download_info, - jstring jfile_name, - jstring jdir_name, - jstring jdir_full_path) { +static void LaunchDownloadOverwriteInfoBar( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& delegate, + const JavaParamRef<jobject>& tab, + const JavaParamRef<jobject>& download_info, + const JavaParamRef<jstring>& jfile_name, + const JavaParamRef<jstring>& jdir_name, + const JavaParamRef<jstring>& jdir_full_path) { TabAndroid* tab_android = TabAndroid::GetNativeTab(env, tab); std::string file_name = diff --git a/chrome/browser/android/favicon_helper.cc b/chrome/browser/android/favicon_helper.cc index 7f008f2..466cf43 100644 --- a/chrome/browser/android/favicon_helper.cc +++ b/chrome/browser/android/favicon_helper.cc @@ -143,7 +143,7 @@ void OnFaviconImageResultAvailable( } // namespace -static jlong Init(JNIEnv* env, jclass clazz) { +static jlong Init(JNIEnv* env, const JavaParamRef<jclass>& clazz) { return reinterpret_cast<intptr_t>(new FaviconHelper()); } @@ -294,8 +294,8 @@ void FaviconHelper::EnsureFaviconIsAvailable( FaviconHelper::~FaviconHelper() {} static jint GetDominantColorForBitmap(JNIEnv* env, - jclass clazz, - jobject bitmap) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& bitmap) { if (!bitmap) return 0; diff --git a/chrome/browser/android/feature_utilities.cc b/chrome/browser/android/feature_utilities.cc index 4757d7e..23111c6 100644 --- a/chrome/browser/android/feature_utilities.cc +++ b/chrome/browser/android/feature_utilities.cc @@ -27,15 +27,14 @@ CustomTabsVisibilityHistogram GetCustomTabsVisibleValue() { } // namespace android } // namespace chrome - static void SetDocumentModeEnabled(JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jboolean enabled) { document_mode_enabled = enabled; } static void SetCustomTabVisible(JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jboolean visible) { custom_tab_visible = visible; } diff --git a/chrome/browser/android/feedback/connectivity_checker.cc b/chrome/browser/android/feedback/connectivity_checker.cc index 7c7fc6f..fa2e133 100644 --- a/chrome/browser/android/feedback/connectivity_checker.cc +++ b/chrome/browser/android/feedback/connectivity_checker.cc @@ -164,11 +164,11 @@ void ConnectivityChecker::OnTimeout() { } // namespace void CheckConnectivity(JNIEnv* env, - jclass clazz, - jobject j_profile, - jstring j_url, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& j_profile, + const JavaParamRef<jstring>& j_url, jlong j_timeout_ms, - jobject j_callback) { + const JavaParamRef<jobject>& j_callback) { Profile* profile = ProfileAndroid::FromProfileAndroid(j_profile); if (!profile) { PostCallback(env, j_callback, CONNECTIVITY_CHECK_RESULT_ERROR); @@ -187,7 +187,9 @@ void CheckConnectivity(JNIEnv* env, connectivity_checker->StartAsyncCheck(); } -jboolean IsUrlValid(JNIEnv* env, jclass clazz, jstring j_url) { +jboolean IsUrlValid(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& j_url) { GURL url(base::android::ConvertJavaStringToUTF8(env, j_url)); return url.is_valid(); } diff --git a/chrome/browser/android/find_in_page/find_in_page_bridge.cc b/chrome/browser/android/find_in_page/find_in_page_bridge.cc index 10d6422..6488fbaa 100644 --- a/chrome/browser/android/find_in_page/find_in_page_bridge.cc +++ b/chrome/browser/android/find_in_page/find_in_page_bridge.cc @@ -70,7 +70,9 @@ void FindInPageBridge::ActivateFindInPageResultForAccessibility( } // static -static jlong Init(JNIEnv* env, jobject obj, jobject j_web_contents) { +static jlong Init(JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& j_web_contents) { FindInPageBridge* bridge = new FindInPageBridge(env, obj, j_web_contents); return reinterpret_cast<intptr_t>(bridge); } diff --git a/chrome/browser/android/foreign_session_helper.cc b/chrome/browser/android/foreign_session_helper.cc index ef4a5dc..7eed11f 100644 --- a/chrome/browser/android/foreign_session_helper.cc +++ b/chrome/browser/android/foreign_session_helper.cc @@ -142,7 +142,9 @@ void CopySessionToJava( } // namespace -static jlong Init(JNIEnv* env, jclass clazz, jobject profile) { +static jlong Init(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& profile) { ForeignSessionHelper* foreign_session_helper = new ForeignSessionHelper( ProfileAndroid::FromProfileAndroid(profile)); return reinterpret_cast<intptr_t>(foreign_session_helper); diff --git a/chrome/browser/android/fullscreen/fullscreen_infobar_delegate.cc b/chrome/browser/android/fullscreen/fullscreen_infobar_delegate.cc index 6d16a98..a36cb6c 100644 --- a/chrome/browser/android/fullscreen/fullscreen_infobar_delegate.cc +++ b/chrome/browser/android/fullscreen/fullscreen_infobar_delegate.cc @@ -21,8 +21,9 @@ #include "url/gurl.h" // static -jlong LaunchFullscreenInfoBar( - JNIEnv* env, jobject obj, jobject tab) { +jlong LaunchFullscreenInfoBar(JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& tab) { TabAndroid* tab_android = TabAndroid::GetNativeTab(env, tab); GURL origin = tab_android->GetURL().GetOrigin(); FullscreenInfoBarDelegate* delegate = new FullscreenInfoBarDelegate( diff --git a/chrome/browser/android/history_report/history_report_jni_bridge.cc b/chrome/browser/android/history_report/history_report_jni_bridge.cc index c439c2e..7acdf71 100644 --- a/chrome/browser/android/history_report/history_report_jni_bridge.cc +++ b/chrome/browser/android/history_report/history_report_jni_bridge.cc @@ -26,7 +26,7 @@ namespace history_report { -static jlong Init(JNIEnv* env, jobject obj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { HistoryReportJniBridge* bridge = new HistoryReportJniBridge(env, obj); return reinterpret_cast<intptr_t>(bridge); } diff --git a/chrome/browser/android/java_exception_reporter.cc b/chrome/browser/android/java_exception_reporter.cc index 1d572e5..bfe57ee 100644 --- a/chrome/browser/android/java_exception_reporter.cc +++ b/chrome/browser/android/java_exception_reporter.cc @@ -17,7 +17,9 @@ void InitJavaExceptionReporter() { Java_JavaExceptionReporter_installHandler(env); } -void ReportJavaException(JNIEnv* env, jclass jcaller, jthrowable e) { +void ReportJavaException(JNIEnv* env, + const JavaParamRef<jclass>& jcaller, + const JavaParamRef<jthrowable>& e) { // Set the exception_string in BuildInfo so that breakpad can read it. base::android::BuildInfo::GetInstance()->SetJavaExceptionInfo( base::android::GetJavaExceptionInfo(env, e)); diff --git a/chrome/browser/android/large_icon_bridge.cc b/chrome/browser/android/large_icon_bridge.cc index 5cc8601..d539b1d 100644 --- a/chrome/browser/android/large_icon_bridge.cc +++ b/chrome/browser/android/large_icon_bridge.cc @@ -59,7 +59,7 @@ void OnLargeIconAvailable( } // namespace -static jlong Init(JNIEnv* env, jclass clazz) { +static jlong Init(JNIEnv* env, const JavaParamRef<jclass>& clazz) { return reinterpret_cast<intptr_t>(new LargeIconBridge()); } diff --git a/chrome/browser/android/logo_bridge.cc b/chrome/browser/android/logo_bridge.cc index 6c97a04..d2250b2 100644 --- a/chrome/browser/android/logo_bridge.cc +++ b/chrome/browser/android/logo_bridge.cc @@ -79,7 +79,9 @@ class LogoObserverAndroid : public search_provider_logos::LogoObserver { } // namespace -static jlong Init(JNIEnv* env, jobject obj, jobject j_profile) { +static jlong Init(JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& j_profile) { LogoBridge* logo_bridge = new LogoBridge(j_profile); return reinterpret_cast<intptr_t>(logo_bridge); } diff --git a/chrome/browser/android/metrics/launch_metrics.cc b/chrome/browser/android/metrics/launch_metrics.cc index c5e3330c..3168667 100644 --- a/chrome/browser/android/metrics/launch_metrics.cc +++ b/chrome/browser/android/metrics/launch_metrics.cc @@ -27,8 +27,12 @@ bool RegisterLaunchMetrics(JNIEnv* env) { return RegisterNativesImpl(env); } -static void RecordLaunch(JNIEnv* env, jclass caller, jboolean standalone, - jstring jurl, int source, jobject jweb_contents) { +static void RecordLaunch(JNIEnv* env, + const JavaParamRef<jclass>& caller, + jboolean standalone, + const JavaParamRef<jstring>& jurl, + int source, + const JavaParamRef<jobject>& jweb_contents) { GURL url(base::android::ConvertJavaStringToUTF8(env, jurl)); content::WebContents* web_contents = diff --git a/chrome/browser/android/metrics/uma_session_stats.cc b/chrome/browser/android/metrics/uma_session_stats.cc index 9be1c014..8d21247 100644 --- a/chrome/browser/android/metrics/uma_session_stats.cc +++ b/chrome/browser/android/metrics/uma_session_stats.cc @@ -92,8 +92,10 @@ void UmaSessionStats::RegisterSyntheticFieldTrial( // This happens when we've got permission to upload on Wi-Fi but we're on a // mobile connection (for example). // * Logs are neither being recorded or uploaded. -static void UpdateMetricsServiceState(JNIEnv* env, jobject obj, - jboolean may_record, jboolean may_upload) { +static void UpdateMetricsServiceState(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jboolean may_record, + jboolean may_upload) { metrics::MetricsService* metrics = g_browser_process->metrics_service(); DCHECK(metrics); @@ -112,7 +114,9 @@ static void UpdateMetricsServiceState(JNIEnv* env, jobject obj, } // Renderer process crashed in the foreground. -static void LogRendererCrash(JNIEnv* env, jclass clazz, jboolean is_paused) { +static void LogRendererCrash(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + jboolean is_paused) { DCHECK(g_browser_process); if (!is_paused) { @@ -129,7 +133,7 @@ static void LogRendererCrash(JNIEnv* env, jclass clazz, jboolean is_paused) { } static void RegisterExternalExperiment(JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jint study_id, jint experiment_id) { const std::string group_name_utf8 = base::IntToString(experiment_id); @@ -145,16 +149,18 @@ static void RegisterExternalExperiment(JNIEnv* env, static_cast<uint32_t>(study_id), group_name_utf8); } -static void RegisterSyntheticFieldTrial(JNIEnv* env, - jclass clazz, - jstring jtrial_name, - jstring jgroup_name) { +static void RegisterSyntheticFieldTrial( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jtrial_name, + const JavaParamRef<jstring>& jgroup_name) { std::string trial_name(ConvertJavaStringToUTF8(env, jtrial_name)); std::string group_name(ConvertJavaStringToUTF8(env, jgroup_name)); UmaSessionStats::RegisterSyntheticFieldTrial(trial_name, group_name); } -static void RecordMultiWindowSession(JNIEnv*, jclass, +static void RecordMultiWindowSession(JNIEnv*, + const JavaParamRef<jclass>&, jint area_percent, jint instance_count) { UMA_HISTOGRAM_PERCENTAGE("MobileStartup.MobileMultiWindowSession", @@ -168,12 +174,16 @@ static void RecordMultiWindowSession(JNIEnv*, jclass, 10 /* bucket count */); } -static void RecordTabCountPerLoad(JNIEnv*, jclass, jint num_tabs) { +static void RecordTabCountPerLoad(JNIEnv*, + const JavaParamRef<jclass>&, + jint num_tabs) { // Record how many tabs total are open. UMA_HISTOGRAM_CUSTOM_COUNTS("Tabs.TabCountPerLoad", num_tabs, 1, 200, 50); } -static void RecordPageLoaded(JNIEnv*, jclass, jboolean is_desktop_user_agent) { +static void RecordPageLoaded(JNIEnv*, + const JavaParamRef<jclass>&, + jboolean is_desktop_user_agent) { // Should be called whenever a page has been loaded. content::RecordAction(UserMetricsAction("MobilePageLoaded")); if (is_desktop_user_agent) { @@ -182,11 +192,11 @@ static void RecordPageLoaded(JNIEnv*, jclass, jboolean is_desktop_user_agent) { } } -static void RecordPageLoadedWithKeyboard(JNIEnv*, jclass) { +static void RecordPageLoadedWithKeyboard(JNIEnv*, const JavaParamRef<jclass>&) { content::RecordAction(UserMetricsAction("MobilePageLoadedWithKeyboard")); } -static jlong Init(JNIEnv* env, jclass obj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jclass>& obj) { // We should have only one UmaSessionStats instance. DCHECK(!g_uma_session_stats); g_uma_session_stats = new UmaSessionStats(); diff --git a/chrome/browser/android/metrics/variations_session.cc b/chrome/browser/android/metrics/variations_session.cc index 747b17a..068246f 100644 --- a/chrome/browser/android/metrics/variations_session.cc +++ b/chrome/browser/android/metrics/variations_session.cc @@ -17,9 +17,10 @@ bool g_on_app_enter_foreground_called = false; } // namespace -static void StartVariationsSession(JNIEnv* env, - jobject obj, - jstring jrestrict_mode) { +static void StartVariationsSession( + JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jstring>& jrestrict_mode) { DCHECK(g_browser_process); variations::VariationsService* variations_service = diff --git a/chrome/browser/android/most_visited_sites.cc b/chrome/browser/android/most_visited_sites.cc index 6c82bb3..7273300 100644 --- a/chrome/browser/android/most_visited_sites.cc +++ b/chrome/browser/android/most_visited_sites.cc @@ -571,7 +571,9 @@ void MostVisitedSites::TopSitesChanged(history::TopSites* top_sites, } } -static jlong Init(JNIEnv* env, jobject obj, jobject jprofile) { +static jlong Init(JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& jprofile) { MostVisitedSites* most_visited_sites = new MostVisitedSites(ProfileAndroid::FromProfileAndroid(jprofile)); return reinterpret_cast<intptr_t>(most_visited_sites); diff --git a/chrome/browser/android/new_tab_page_prefs.cc b/chrome/browser/android/new_tab_page_prefs.cc index 0bb054d..d22d6fb 100644 --- a/chrome/browser/android/new_tab_page_prefs.cc +++ b/chrome/browser/android/new_tab_page_prefs.cc @@ -16,7 +16,9 @@ using base::android::ConvertJavaStringToUTF8; -static jlong Init(JNIEnv* env, jclass clazz, jobject profile) { +static jlong Init(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& profile) { NewTabPagePrefs* new_tab_page_prefs = new NewTabPagePrefs(ProfileAndroid::FromProfileAndroid(profile)); return reinterpret_cast<intptr_t>(new_tab_page_prefs); diff --git a/chrome/browser/android/offline_pages/offline_page_bridge.cc b/chrome/browser/android/offline_pages/offline_page_bridge.cc index bc7e611..4c3c3d5 100644 --- a/chrome/browser/android/offline_pages/offline_page_bridge.cc +++ b/chrome/browser/android/offline_pages/offline_page_bridge.cc @@ -67,7 +67,8 @@ void ToJavaOfflinePageList(JNIEnv* env, } // namespace -static jboolean IsOfflinePagesEnabled(JNIEnv* env, jclass clazz) { +static jboolean IsOfflinePagesEnabled(JNIEnv* env, + const JavaParamRef<jclass>& clazz) { return offline_pages::IsOfflinePagesEnabled(); } @@ -215,7 +216,9 @@ base::FilePath OfflinePageBridge::GetDownloadsPath( return DownloadPrefs::FromDownloadManager(manager)->DownloadPath(); } -static jlong Init(JNIEnv* env, jobject obj, jobject j_profile) { +static jlong Init(JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& j_profile) { return reinterpret_cast<jlong>(new OfflinePageBridge( env, obj, ProfileAndroid::FromProfileAndroid(j_profile))); } diff --git a/chrome/browser/android/omnibox/answers_image_bridge.cc b/chrome/browser/android/omnibox/answers_image_bridge.cc index 41d215d..910f48d 100644 --- a/chrome/browser/android/omnibox/answers_image_bridge.cc +++ b/chrome/browser/android/omnibox/answers_image_bridge.cc @@ -52,8 +52,8 @@ class AnswersImageObserverAndroid : public BitmapFetcherService::Observer { } // namespace static void CancelAnswersImageRequest(JNIEnv* env, - jclass, - jobject java_profile, + const JavaParamRef<jclass>&, + const JavaParamRef<jobject>& java_profile, jint java_request_id) { Profile* profile = ProfileAndroid::FromProfileAndroid(java_profile); DCHECK(profile); @@ -63,10 +63,10 @@ static void CancelAnswersImageRequest(JNIEnv* env, } static int RequestAnswersImage(JNIEnv* env, - jclass, - jobject java_profile, - jstring java_url, - jobject java_callback) { + const JavaParamRef<jclass>&, + const JavaParamRef<jobject>& java_profile, + const JavaParamRef<jstring>& java_url, + const JavaParamRef<jobject>& java_callback) { Profile* profile = ProfileAndroid::FromProfileAndroid(java_profile); DCHECK(profile); BitmapFetcherService* bitmap_fetcher_service = diff --git a/chrome/browser/android/omnibox/autocomplete_controller_android.cc b/chrome/browser/android/omnibox/autocomplete_controller_android.cc index 9080238..221d172 100644 --- a/chrome/browser/android/omnibox/autocomplete_controller_android.cc +++ b/chrome/browser/android/omnibox/autocomplete_controller_android.cc @@ -508,7 +508,9 @@ AutocompleteControllerAndroid::GetTopSynchronousResult( return BuildOmniboxSuggestion(env, *result.begin()); } -static jlong Init(JNIEnv* env, jobject obj, jobject jprofile) { +static jlong Init(JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& jprofile) { Profile* profile = ProfileAndroid::FromProfileAndroid(jprofile); if (!profile) return 0; @@ -518,9 +520,10 @@ static jlong Init(JNIEnv* env, jobject obj, jobject jprofile) { return reinterpret_cast<intptr_t>(native_bridge); } -static ScopedJavaLocalRef<jstring> QualifyPartialURLQuery(JNIEnv* env, - jclass clazz, - jstring jquery) { +static ScopedJavaLocalRef<jstring> QualifyPartialURLQuery( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jquery) { Profile* profile = ProfileManager::GetActiveUserProfile(); if (!profile) return ScopedJavaLocalRef<jstring>(); @@ -546,7 +549,8 @@ static ScopedJavaLocalRef<jstring> QualifyPartialURLQuery(JNIEnv* env, return ConvertUTF8ToJavaString(env, match.destination_url.spec()); } -static void PrefetchZeroSuggestResults(JNIEnv* env, jclass clazz) { +static void PrefetchZeroSuggestResults(JNIEnv* env, + const JavaParamRef<jclass>& clazz) { Profile* profile = ProfileManager::GetActiveUserProfile(); if (!profile) return; diff --git a/chrome/browser/android/omnibox/omnibox_prerender.cc b/chrome/browser/android/omnibox/omnibox_prerender.cc index 13069bf..f0a373a 100644 --- a/chrome/browser/android/omnibox/omnibox_prerender.cc +++ b/chrome/browser/android/omnibox/omnibox_prerender.cc @@ -28,7 +28,7 @@ OmniboxPrerender::OmniboxPrerender(JNIEnv* env, jobject obj) OmniboxPrerender::~OmniboxPrerender() { } -static jlong Init(JNIEnv* env, jobject obj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { OmniboxPrerender* omnibox = new OmniboxPrerender(env, obj); return reinterpret_cast<intptr_t>(omnibox); } diff --git a/chrome/browser/android/password_ui_view_android.cc b/chrome/browser/android/password_ui_view_android.cc index d71d1ed..f851e94 100644 --- a/chrome/browser/android/password_ui_view_android.cc +++ b/chrome/browser/android/password_ui_view_android.cc @@ -110,18 +110,20 @@ void PasswordUIViewAndroid::HandleRemoveSavedPasswordException( password_manager_presenter_.RemovePasswordException(index); } -ScopedJavaLocalRef<jstring> GetAccountDashboardURL(JNIEnv* env, jclass) { +ScopedJavaLocalRef<jstring> GetAccountDashboardURL( + JNIEnv* env, + const JavaParamRef<jclass>&) { return ConvertUTF8ToJavaString(env, chrome::kPasswordManagerAccountDashboardURL); } -static jboolean ShouldDisplayManageAccountLink( - JNIEnv* env, jclass) { +static jboolean ShouldDisplayManageAccountLink(JNIEnv* env, + const JavaParamRef<jclass>&) { return password_manager::ManageAccountLinkExperimentEnabled(); } -static jboolean ShouldUseSmartLockBranding( - JNIEnv* env, jclass) { +static jboolean ShouldUseSmartLockBranding(JNIEnv* env, + const JavaParamRef<jclass>&) { const ProfileSyncService* sync_service = ProfileSyncServiceFactory::GetForProfile( ProfileManager::GetLastUsedProfile()); @@ -129,7 +131,7 @@ static jboolean ShouldUseSmartLockBranding( } // static -static jlong Init(JNIEnv* env, jobject obj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { PasswordUIViewAndroid* controller = new PasswordUIViewAndroid(env, obj); return reinterpret_cast<intptr_t>(controller); } diff --git a/chrome/browser/android/precache/precache_launcher.cc b/chrome/browser/android/precache/precache_launcher.cc index db11b8c..eac5a85 100644 --- a/chrome/browser/android/precache/precache_launcher.cc +++ b/chrome/browser/android/precache/precache_launcher.cc @@ -80,12 +80,12 @@ void PrecacheLauncher::OnPrecacheCompleted(bool try_again_soon) { try_again_soon ? JNI_TRUE : JNI_FALSE); } -static jlong Init(JNIEnv* env, jobject obj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { return reinterpret_cast<intptr_t>(new PrecacheLauncher(env, obj)); } // Must be run on the UI thread. -static jboolean ShouldRun(JNIEnv* env, jobject obj) { +static jboolean ShouldRun(JNIEnv* env, const JavaParamRef<jobject>& obj) { Profile* profile = GetProfile(); PrecacheManager* precache_manager = GetPrecacheManager(profile); return precache_manager && (precache_manager->IsInExperimentGroup() || diff --git a/chrome/browser/android/preferences/autofill/autofill_profile_bridge.cc b/chrome/browser/android/preferences/autofill/autofill_profile_bridge.cc index dcf2a13..96c6810 100644 --- a/chrome/browser/android/preferences/autofill/autofill_profile_bridge.cc +++ b/chrome/browser/android/preferences/autofill/autofill_profile_bridge.cc @@ -46,18 +46,20 @@ enum AddressField { } // namespace -static ScopedJavaLocalRef<jstring> GetDefaultCountryCode(JNIEnv* env, - jclass clazz) { +static ScopedJavaLocalRef<jstring> GetDefaultCountryCode( + JNIEnv* env, + const JavaParamRef<jclass>& clazz) { std::string default_country_code = autofill::AutofillCountry::CountryCodeForLocale( g_browser_process->GetApplicationLocale()); return ConvertUTF8ToJavaString(env, default_country_code); } -static void GetSupportedCountries(JNIEnv* env, - jclass clazz, - jobject j_country_code_list, - jobject j_country_name_list) { +static void GetSupportedCountries( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& j_country_code_list, + const JavaParamRef<jobject>& j_country_name_list) { std::vector<std::string> country_codes = ::i18n::addressinput::GetRegionCodes(); std::vector<std::string> known_country_codes; @@ -83,11 +85,11 @@ static void GetSupportedCountries(JNIEnv* env, static ScopedJavaLocalRef<jstring> GetAddressUiComponents( JNIEnv* env, - jclass clazz, - jstring j_country_code, - jstring j_language_code, - jobject j_id_list, - jobject j_name_list) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& j_country_code, + const JavaParamRef<jstring>& j_language_code, + const JavaParamRef<jobject>& j_id_list, + const JavaParamRef<jobject>& j_name_list) { std::string best_language_tag; std::vector<int> component_ids; std::vector<std::string> component_labels; diff --git a/chrome/browser/android/preferences/pref_service_bridge.cc b/chrome/browser/android/preferences/pref_service_bridge.cc index 9b0cc72..fdd0d2b 100644 --- a/chrome/browser/android/preferences/pref_service_bridge.cc +++ b/chrome/browser/android/preferences/pref_service_bridge.cc @@ -136,14 +136,16 @@ PrefService* GetPrefService() { // Native JNI methods // ---------------------------------------------------------------------------- -static jboolean IsContentSettingManaged(JNIEnv* env, jobject obj, - int content_settings_type) { +static jboolean IsContentSettingManaged(JNIEnv* env, + const JavaParamRef<jobject>& obj, + int content_settings_type) { return IsContentSettingManaged( static_cast<ContentSettingsType>(content_settings_type)); } -static jboolean IsContentSettingEnabled(JNIEnv* env, jobject obj, - int content_settings_type) { +static jboolean IsContentSettingEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj, + int content_settings_type) { // Before we migrate functions over to this central function, we must verify // that the functionality provided below is correct. DCHECK(content_settings_type == CONTENT_SETTINGS_TYPE_JAVASCRIPT || @@ -161,8 +163,10 @@ static jboolean IsContentSettingEnabled(JNIEnv* env, jobject obj, type, nullptr) == CONTENT_SETTING_ALLOW; } -static void SetContentSettingEnabled(JNIEnv* env, jobject obj, - int content_settings_type, jboolean allow) { +static void SetContentSettingEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj, + int content_settings_type, + jboolean allow) { // Before we migrate functions over to this central function, we must verify // that the new category supports ALLOW/BLOCK pairs and, if not, handle them. DCHECK(content_settings_type == CONTENT_SETTINGS_TYPE_JAVASCRIPT || @@ -175,8 +179,11 @@ static void SetContentSettingEnabled(JNIEnv* env, jobject obj, allow ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK); } -static void SetContentSettingForPattern(JNIEnv* env, jobject obj, - int content_settings_type, jstring pattern, int setting) { +static void SetContentSettingForPattern(JNIEnv* env, + const JavaParamRef<jobject>& obj, + int content_settings_type, + const JavaParamRef<jstring>& pattern, + int setting) { HostContentSettingsMap* host_content_settings_map = GetOriginalProfile()->GetHostContentSettingsMap(); host_content_settings_map->SetContentSetting( @@ -187,8 +194,10 @@ static void SetContentSettingForPattern(JNIEnv* env, jobject obj, static_cast<ContentSetting>(setting)); } -static void GetContentSettingsExceptions(JNIEnv* env, jobject obj, - int content_settings_type, jobject list) { +static void GetContentSettingsExceptions(JNIEnv* env, + const JavaParamRef<jobject>& obj, + int content_settings_type, + const JavaParamRef<jobject>& list) { HostContentSettingsMap* host_content_settings_map = GetOriginalProfile()->GetHostContentSettingsMap(); ContentSettingsForOneType entries; @@ -206,132 +215,167 @@ static void GetContentSettingsExceptions(JNIEnv* env, jobject obj, } } -static jboolean GetAcceptCookiesEnabled(JNIEnv* env, jobject obj) { +static jboolean GetAcceptCookiesEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetBooleanForContentSetting(CONTENT_SETTINGS_TYPE_COOKIES); } -static jboolean GetAcceptCookiesManaged(JNIEnv* env, jobject obj) { +static jboolean GetAcceptCookiesManaged(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return IsContentSettingManaged(CONTENT_SETTINGS_TYPE_COOKIES); } -static jboolean GetBlockThirdPartyCookiesEnabled(JNIEnv* env, jobject obj) { +static jboolean GetBlockThirdPartyCookiesEnabled( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->GetBoolean(prefs::kBlockThirdPartyCookies); } -static jboolean GetBlockThirdPartyCookiesManaged(JNIEnv* env, jobject obj) { +static jboolean GetBlockThirdPartyCookiesManaged( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->IsManagedPreference(prefs::kBlockThirdPartyCookies); } -static jboolean GetRememberPasswordsEnabled(JNIEnv* env, jobject obj) { +static jboolean GetRememberPasswordsEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->GetBoolean( password_manager::prefs::kPasswordManagerSavingEnabled); } -static jboolean GetPasswordManagerAutoSigninEnabled(JNIEnv* env, jobject obj) { +static jboolean GetPasswordManagerAutoSigninEnabled( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->GetBoolean( password_manager::prefs::kPasswordManagerAutoSignin); } -static jboolean GetRememberPasswordsManaged(JNIEnv* env, jobject obj) { +static jboolean GetRememberPasswordsManaged(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->IsManagedPreference( password_manager::prefs::kPasswordManagerSavingEnabled); } -static jboolean GetPasswordManagerAutoSigninManaged(JNIEnv* env, jobject obj) { +static jboolean GetPasswordManagerAutoSigninManaged( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->IsManagedPreference( password_manager::prefs::kPasswordManagerAutoSignin); } -static jboolean GetDoNotTrackEnabled(JNIEnv* env, jobject obj) { +static jboolean GetDoNotTrackEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->GetBoolean(prefs::kEnableDoNotTrack); } -static jint GetNetworkPredictionOptions(JNIEnv* env, jobject obj) { +static jint GetNetworkPredictionOptions(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->GetInteger(prefs::kNetworkPredictionOptions); } -static jboolean GetNetworkPredictionManaged(JNIEnv* env, jobject obj) { +static jboolean GetNetworkPredictionManaged(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->IsManagedPreference( prefs::kNetworkPredictionOptions); } -static jboolean GetPasswordEchoEnabled(JNIEnv* env, jobject obj) { +static jboolean GetPasswordEchoEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->GetBoolean(prefs::kWebKitPasswordEchoEnabled); } -static jboolean GetPrintingEnabled(JNIEnv* env, jobject obj) { +static jboolean GetPrintingEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->GetBoolean(prefs::kPrintingEnabled); } -static jboolean GetPrintingManaged(JNIEnv* env, jobject obj) { +static jboolean GetPrintingManaged(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->IsManagedPreference(prefs::kPrintingEnabled); } -static jboolean GetTranslateEnabled(JNIEnv* env, jobject obj) { +static jboolean GetTranslateEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->GetBoolean(prefs::kEnableTranslate); } -static jboolean GetTranslateManaged(JNIEnv* env, jobject obj) { +static jboolean GetTranslateManaged(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->IsManagedPreference(prefs::kEnableTranslate); } -static jboolean GetAutoDetectEncodingEnabled(JNIEnv* env, jobject obj) { +static jboolean GetAutoDetectEncodingEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->GetBoolean(prefs::kWebKitUsesUniversalDetector); } -static jboolean GetSearchSuggestEnabled(JNIEnv* env, jobject obj) { +static jboolean GetSearchSuggestEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->GetBoolean(prefs::kSearchSuggestEnabled); } -static jboolean GetSearchSuggestManaged(JNIEnv* env, jobject obj) { +static jboolean GetSearchSuggestManaged(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->IsManagedPreference(prefs::kSearchSuggestEnabled); } -static jboolean GetSafeBrowsingExtendedReportingEnabled(JNIEnv* env, - jobject obj) { +static jboolean GetSafeBrowsingExtendedReportingEnabled( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->GetBoolean( prefs::kSafeBrowsingExtendedReportingEnabled); } -static void SetSafeBrowsingExtendedReportingEnabled(JNIEnv* env, - jobject obj, - jboolean enabled) { +static void SetSafeBrowsingExtendedReportingEnabled( + JNIEnv* env, + const JavaParamRef<jobject>& obj, + jboolean enabled) { GetPrefService()->SetBoolean(prefs::kSafeBrowsingExtendedReportingEnabled, enabled); } -static jboolean GetSafeBrowsingExtendedReportingManaged(JNIEnv* env, - jobject obj) { +static jboolean GetSafeBrowsingExtendedReportingManaged( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->IsManagedPreference( prefs::kSafeBrowsingExtendedReportingEnabled); } -static jboolean GetSafeBrowsingEnabled(JNIEnv* env, jobject obj) { +static jboolean GetSafeBrowsingEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->GetBoolean(prefs::kSafeBrowsingEnabled); } -static void SetSafeBrowsingEnabled(JNIEnv* env, jobject obj, jboolean enabled) { +static void SetSafeBrowsingEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jboolean enabled) { GetPrefService()->SetBoolean(prefs::kSafeBrowsingEnabled, enabled); } -static jboolean GetSafeBrowsingManaged(JNIEnv* env, jobject obj) { +static jboolean GetSafeBrowsingManaged(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->IsManagedPreference(prefs::kSafeBrowsingEnabled); } -static jboolean GetProtectedMediaIdentifierEnabled(JNIEnv* env, jobject obj) { +static jboolean GetProtectedMediaIdentifierEnabled( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetBooleanForContentSetting( CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER); } -static jboolean GetPushNotificationsEnabled(JNIEnv* env, jobject obj) { +static jboolean GetPushNotificationsEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetBooleanForContentSetting(CONTENT_SETTINGS_TYPE_NOTIFICATIONS); } -static jboolean GetAllowLocationEnabled(JNIEnv* env, jobject obj) { +static jboolean GetAllowLocationEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetBooleanForContentSetting(CONTENT_SETTINGS_TYPE_GEOLOCATION); } -static jboolean GetLocationAllowedByPolicy(JNIEnv* env, jobject obj) { +static jboolean GetLocationAllowedByPolicy(JNIEnv* env, + const JavaParamRef<jobject>& obj) { if (!IsContentSettingManaged(CONTENT_SETTINGS_TYPE_GEOLOCATION)) return false; HostContentSettingsMap* content_settings = @@ -341,39 +385,51 @@ static jboolean GetLocationAllowedByPolicy(JNIEnv* env, jobject obj) { CONTENT_SETTING_ALLOW; } -static jboolean GetAllowLocationUserModifiable(JNIEnv* env, jobject obj) { +static jboolean GetAllowLocationUserModifiable( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { return IsContentSettingUserModifiable(CONTENT_SETTINGS_TYPE_GEOLOCATION); } -static jboolean GetAllowLocationManagedByCustodian(JNIEnv* env, jobject obj) { +static jboolean GetAllowLocationManagedByCustodian( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { return IsContentSettingManagedByCustodian(CONTENT_SETTINGS_TYPE_GEOLOCATION); } -static jboolean GetResolveNavigationErrorEnabled(JNIEnv* env, jobject obj) { +static jboolean GetResolveNavigationErrorEnabled( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->GetBoolean(prefs::kAlternateErrorPagesEnabled); } -static jboolean GetResolveNavigationErrorManaged(JNIEnv* env, jobject obj) { +static jboolean GetResolveNavigationErrorManaged( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->IsManagedPreference( prefs::kAlternateErrorPagesEnabled); } -static jboolean GetCrashReportManaged(JNIEnv* env, jobject obj) { +static jboolean GetCrashReportManaged(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->IsManagedPreference( prefs::kCrashReportingEnabled); } -static jboolean GetForceGoogleSafeSearch(JNIEnv* env, jobject obj) { +static jboolean GetForceGoogleSafeSearch(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->GetBoolean(prefs::kForceGoogleSafeSearch); } -static jint GetDefaultSupervisedUserFilteringBehavior(JNIEnv* env, - jobject obj) { +static jint GetDefaultSupervisedUserFilteringBehavior( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->GetInteger( prefs::kDefaultSupervisedUserFilteringBehavior); } -static jboolean GetIncognitoModeEnabled(JNIEnv* env, jobject obj) { +static jboolean GetIncognitoModeEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj) { PrefService* prefs = GetPrefService(); IncognitoModePrefs::Availability incognito_pref = IncognitoModePrefs::GetAvailability(prefs); @@ -383,35 +439,40 @@ static jboolean GetIncognitoModeEnabled(JNIEnv* env, jobject obj) { return incognito_pref != IncognitoModePrefs::DISABLED; } -static jboolean GetIncognitoModeManaged(JNIEnv* env, jobject obj) { +static jboolean GetIncognitoModeManaged(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->IsManagedPreference( prefs::kIncognitoModeAvailability); } -static jboolean GetFullscreenManaged(JNIEnv* env, jobject obj) { +static jboolean GetFullscreenManaged(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return IsContentSettingManaged(CONTENT_SETTINGS_TYPE_FULLSCREEN); } -static jboolean GetFullscreenAllowed(JNIEnv* env, jobject obj) { +static jboolean GetFullscreenAllowed(JNIEnv* env, + const JavaParamRef<jobject>& obj) { HostContentSettingsMap* content_settings = GetOriginalProfile()->GetHostContentSettingsMap(); return content_settings->GetDefaultContentSetting( CONTENT_SETTINGS_TYPE_FULLSCREEN, NULL) == CONTENT_SETTING_ALLOW; } -static jboolean GetMetricsReportingEnabled(JNIEnv* env, jobject obj) { +static jboolean GetMetricsReportingEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj) { PrefService* local_state = g_browser_process->local_state(); return local_state->GetBoolean(prefs::kMetricsReportingEnabled); } static void SetMetricsReportingEnabled(JNIEnv* env, - jobject obj, + const JavaParamRef<jobject>& obj, jboolean enabled) { PrefService* local_state = g_browser_process->local_state(); local_state->SetBoolean(prefs::kMetricsReportingEnabled, enabled); } -static jboolean HasSetMetricsReporting(JNIEnv* env, jobject obj) { +static jboolean HasSetMetricsReporting(JNIEnv* env, + const JavaParamRef<jobject>& obj) { PrefService* local_state = g_browser_process->local_state(); return local_state->HasPrefPath(prefs::kMetricsReportingEnabled); } @@ -446,9 +507,13 @@ class ClearBrowsingDataObserver : public BrowsingDataRemover::Observer { }; } // namespace -static void ClearBrowsingData(JNIEnv* env, jobject obj, jboolean history, - jboolean cache, jboolean cookies_and_site_data, jboolean passwords, - jboolean form_data) { +static void ClearBrowsingData(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jboolean history, + jboolean cache, + jboolean cookies_and_site_data, + jboolean passwords, + jboolean form_data) { // BrowsingDataRemover deletes itself. BrowsingDataRemover* browsing_data_remover = BrowsingDataRemover::CreateForPeriod( @@ -474,11 +539,14 @@ static void ClearBrowsingData(JNIEnv* env, jobject obj, jboolean history, BrowsingDataHelper::UNPROTECTED_WEB); } -static jboolean CanDeleteBrowsingHistory(JNIEnv* env, jobject obj) { +static jboolean CanDeleteBrowsingHistory(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->GetBoolean(prefs::kAllowDeletingBrowserHistory); } -static void SetAllowCookiesEnabled(JNIEnv* env, jobject obj, jboolean allow) { +static void SetAllowCookiesEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jboolean allow) { HostContentSettingsMap* host_content_settings_map = GetOriginalProfile()->GetHostContentSettingsMap(); host_content_settings_map->SetDefaultContentSetting( @@ -486,26 +554,29 @@ static void SetAllowCookiesEnabled(JNIEnv* env, jobject obj, jboolean allow) { allow ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK); } -static void SetBlockThirdPartyCookiesEnabled(JNIEnv* env, jobject obj, +static void SetBlockThirdPartyCookiesEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj, jboolean enabled) { GetPrefService()->SetBoolean(prefs::kBlockThirdPartyCookies, enabled); } -static void SetRememberPasswordsEnabled(JNIEnv* env, jobject obj, +static void SetRememberPasswordsEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj, jboolean allow) { GetPrefService()->SetBoolean( password_manager::prefs::kPasswordManagerSavingEnabled, allow); } -static void SetPasswordManagerAutoSigninEnabled(JNIEnv* env, - jobject obj, - jboolean enabled) { +static void SetPasswordManagerAutoSigninEnabled( + JNIEnv* env, + const JavaParamRef<jobject>& obj, + jboolean enabled) { GetPrefService()->SetBoolean( password_manager::prefs::kPasswordManagerAutoSignin, enabled); } static void SetProtectedMediaIdentifierEnabled(JNIEnv* env, - jobject obj, + const JavaParamRef<jobject>& obj, jboolean is_enabled) { HostContentSettingsMap* host_content_settings_map = GetOriginalProfile()->GetHostContentSettingsMap(); @@ -515,7 +586,7 @@ static void SetProtectedMediaIdentifierEnabled(JNIEnv* env, } static void SetAllowLocationEnabled(JNIEnv* env, - jobject obj, + const JavaParamRef<jobject>& obj, jboolean is_enabled) { HostContentSettingsMap* host_content_settings_map = GetOriginalProfile()->GetHostContentSettingsMap(); @@ -524,7 +595,9 @@ static void SetAllowLocationEnabled(JNIEnv* env, is_enabled ? CONTENT_SETTING_ASK : CONTENT_SETTING_BLOCK); } -static void SetCameraEnabled(JNIEnv* env, jobject obj, jboolean allow) { +static void SetCameraEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jboolean allow) { HostContentSettingsMap* host_content_settings_map = GetOriginalProfile()->GetHostContentSettingsMap(); host_content_settings_map->SetDefaultContentSetting( @@ -532,7 +605,9 @@ static void SetCameraEnabled(JNIEnv* env, jobject obj, jboolean allow) { allow ? CONTENT_SETTING_ASK : CONTENT_SETTING_BLOCK); } -static void SetMicEnabled(JNIEnv* env, jobject obj, jboolean allow) { +static void SetMicEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jboolean allow) { HostContentSettingsMap* host_content_settings_map = GetOriginalProfile()->GetHostContentSettingsMap(); host_content_settings_map->SetDefaultContentSetting( @@ -540,7 +615,9 @@ static void SetMicEnabled(JNIEnv* env, jobject obj, jboolean allow) { allow ? CONTENT_SETTING_ASK : CONTENT_SETTING_BLOCK); } -static void SetFullscreenAllowed(JNIEnv* env, jobject obj, jboolean allow) { +static void SetFullscreenAllowed(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jboolean allow) { HostContentSettingsMap* host_content_settings_map = GetOriginalProfile()->GetHostContentSettingsMap(); host_content_settings_map->SetDefaultContentSetting( @@ -549,7 +626,7 @@ static void SetFullscreenAllowed(JNIEnv* env, jobject obj, jboolean allow) { } static void SetPushNotificationsEnabled(JNIEnv* env, - jobject obj, + const JavaParamRef<jobject>& obj, jboolean allow) { HostContentSettingsMap* host_content_settings_map = GetOriginalProfile()->GetHostContentSettingsMap(); @@ -558,42 +635,53 @@ static void SetPushNotificationsEnabled(JNIEnv* env, allow ? CONTENT_SETTING_ASK : CONTENT_SETTING_BLOCK); } -static void SetCrashReporting(JNIEnv* env, jobject obj, jboolean reporting) { +static void SetCrashReporting(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jboolean reporting) { PrefService* local_state = g_browser_process->local_state(); local_state->SetBoolean(prefs::kCrashReportingEnabled, reporting); } -static jboolean CanPredictNetworkActions(JNIEnv* env, jobject obj) { +static jboolean CanPredictNetworkActions(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return chrome_browser_net::CanPrefetchAndPrerenderUI(GetPrefService()); } -static void SetDoNotTrackEnabled(JNIEnv* env, jobject obj, jboolean allow) { +static void SetDoNotTrackEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jboolean allow) { GetPrefService()->SetBoolean(prefs::kEnableDoNotTrack, allow); } -static ScopedJavaLocalRef<jstring> GetSyncLastAccountName(JNIEnv* env, - jobject obj) { +static ScopedJavaLocalRef<jstring> GetSyncLastAccountName( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { return ConvertUTF8ToJavaString( env, GetPrefService()->GetString(prefs::kGoogleServicesLastUsername)); } -static void SetTranslateEnabled(JNIEnv* env, jobject obj, jboolean enabled) { +static void SetTranslateEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jboolean enabled) { GetPrefService()->SetBoolean(prefs::kEnableTranslate, enabled); } -static void SetAutoDetectEncodingEnabled(JNIEnv* env, jobject obj, +static void SetAutoDetectEncodingEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj, jboolean enabled) { content::RecordAction(base::UserMetricsAction("AutoDetectChange")); GetPrefService()->SetBoolean(prefs::kWebKitUsesUniversalDetector, enabled); } -static void ResetTranslateDefaults(JNIEnv* env, jobject obj) { +static void ResetTranslateDefaults(JNIEnv* env, + const JavaParamRef<jobject>& obj) { scoped_ptr<translate::TranslatePrefs> translate_prefs = ChromeTranslateClient::CreateTranslatePrefs(GetPrefService()); translate_prefs->ResetToDefaults(); } -static void MigrateJavascriptPreference(JNIEnv* env, jobject obj) { +static void MigrateJavascriptPreference(JNIEnv* env, + const JavaParamRef<jobject>& obj) { const PrefService::Preference* javascript_pref = GetPrefService()->FindPreference(prefs::kWebKitJavascriptEnabled); DCHECK(javascript_pref); @@ -609,7 +697,8 @@ static void MigrateJavascriptPreference(JNIEnv* env, jobject obj) { GetPrefService()->ClearPref(prefs::kWebKitJavascriptEnabled); } -static void MigrateLocationPreference(JNIEnv* env, jobject obj) { +static void MigrateLocationPreference(JNIEnv* env, + const JavaParamRef<jobject>& obj) { const PrefService::Preference* pref = GetPrefService()->FindPreference(prefs::kGeolocationEnabled); if (!pref || !pref->HasUserSetting()) @@ -624,7 +713,8 @@ static void MigrateLocationPreference(JNIEnv* env, jobject obj) { GetPrefService()->ClearPref(prefs::kGeolocationEnabled); } -static void MigrateProtectedMediaPreference(JNIEnv* env, jobject obj) { +static void MigrateProtectedMediaPreference(JNIEnv* env, + const JavaParamRef<jobject>& obj) { const PrefService::Preference* pref = GetPrefService()->FindPreference(prefs::kProtectedMediaIdentifierEnabled); if (!pref || !pref->HasUserSetting()) @@ -639,41 +729,48 @@ static void MigrateProtectedMediaPreference(JNIEnv* env, jobject obj) { } static void SetPasswordEchoEnabled(JNIEnv* env, - jobject obj, + const JavaParamRef<jobject>& obj, jboolean passwordEchoEnabled) { GetPrefService()->SetBoolean(prefs::kWebKitPasswordEchoEnabled, passwordEchoEnabled); } -static jboolean GetCameraEnabled(JNIEnv* env, jobject obj) { +static jboolean GetCameraEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetBooleanForContentSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA); } -static jboolean GetCameraUserModifiable(JNIEnv* env, jobject obj) { +static jboolean GetCameraUserModifiable(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return IsContentSettingUserModifiable( CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA); } -static jboolean GetCameraManagedByCustodian(JNIEnv* env, jobject obj) { +static jboolean GetCameraManagedByCustodian(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return IsContentSettingManagedByCustodian( CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA); } -static jboolean GetMicEnabled(JNIEnv* env, jobject obj) { +static jboolean GetMicEnabled(JNIEnv* env, const JavaParamRef<jobject>& obj) { return GetBooleanForContentSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC); } -static jboolean GetMicUserModifiable(JNIEnv* env, jobject obj) { +static jboolean GetMicUserModifiable(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return IsContentSettingUserModifiable( CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC); } -static jboolean GetMicManagedByCustodian(JNIEnv* env, jobject obj) { +static jboolean GetMicManagedByCustodian(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return IsContentSettingManagedByCustodian( CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC); } -static void SetJavaScriptAllowed(JNIEnv* env, jobject obj, jstring pattern, +static void SetJavaScriptAllowed(JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jstring>& pattern, int setting) { HostContentSettingsMap* host_content_settings_map = GetOriginalProfile()->GetHostContentSettingsMap(); @@ -685,7 +782,9 @@ static void SetJavaScriptAllowed(JNIEnv* env, jobject obj, jstring pattern, static_cast<ContentSetting>(setting)); } -static void SetPopupException(JNIEnv* env, jobject obj, jstring pattern, +static void SetPopupException(JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jstring>& pattern, int setting) { HostContentSettingsMap* host_content_settings_map = GetOriginalProfile()->GetHostContentSettingsMap(); @@ -697,48 +796,56 @@ static void SetPopupException(JNIEnv* env, jobject obj, jstring pattern, static_cast<ContentSetting>(setting)); } -static void SetSearchSuggestEnabled(JNIEnv* env, jobject obj, +static void SetSearchSuggestEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj, jboolean enabled) { GetPrefService()->SetBoolean(prefs::kSearchSuggestEnabled, enabled); } -static ScopedJavaLocalRef<jstring> GetContextualSearchPreference(JNIEnv* env, - jobject obj) { +static ScopedJavaLocalRef<jstring> GetContextualSearchPreference( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { return ConvertUTF8ToJavaString( env, GetPrefService()->GetString(prefs::kContextualSearchEnabled)); } -static jboolean GetContextualSearchPreferenceIsManaged(JNIEnv* env, - jobject obj) { +static jboolean GetContextualSearchPreferenceIsManaged( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { return GetPrefService()->IsManagedPreference(prefs::kContextualSearchEnabled); } -static void SetContextualSearchPreference(JNIEnv* env, jobject obj, - jstring pref) { +static void SetContextualSearchPreference(JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jstring>& pref) { GetPrefService()->SetString(prefs::kContextualSearchEnabled, ConvertJavaStringToUTF8(env, pref)); } -static void SetNetworkPredictionOptions(JNIEnv* env, jobject obj, int option) { +static void SetNetworkPredictionOptions(JNIEnv* env, + const JavaParamRef<jobject>& obj, + int option) { GetPrefService()->SetInteger(prefs::kNetworkPredictionOptions, option); } -static void SetResolveNavigationErrorEnabled(JNIEnv* env, jobject obj, +static void SetResolveNavigationErrorEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj, jboolean enabled) { GetPrefService()->SetBoolean(prefs::kAlternateErrorPagesEnabled, enabled); } -static jboolean GetFirstRunEulaAccepted(JNIEnv* env, jobject obj) { +static jboolean GetFirstRunEulaAccepted(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return g_browser_process->local_state()->GetBoolean(prefs::kEulaAccepted); } -static void SetEulaAccepted(JNIEnv* env, jobject obj) { +static void SetEulaAccepted(JNIEnv* env, const JavaParamRef<jobject>& obj) { g_browser_process->local_state()->SetBoolean(prefs::kEulaAccepted, true); } static void ResetAcceptLanguages(JNIEnv* env, - jobject obj, - jstring default_locale) { + const JavaParamRef<jobject>& obj, + const JavaParamRef<jstring>& default_locale) { std::string accept_languages(l10n_util::GetStringUTF8(IDS_ACCEPT_LANGUAGES)); std::string locale_string(ConvertJavaStringToUTF8(env, default_locale)); @@ -749,8 +856,9 @@ static void ResetAcceptLanguages(JNIEnv* env, // Sends all information about the different versions to Java. // From browser_about_handler.cc -static ScopedJavaLocalRef<jobject> GetAboutVersionStrings(JNIEnv* env, - jobject obj) { +static ScopedJavaLocalRef<jobject> GetAboutVersionStrings( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { std::string os_version = version_info::GetOSType(); os_version += " " + AndroidAboutAppInfo::GetOsInfo(); @@ -765,22 +873,23 @@ static ScopedJavaLocalRef<jobject> GetAboutVersionStrings(JNIEnv* env, ConvertUTF8ToJavaString(env, os_version).obj()); } -static ScopedJavaLocalRef<jstring> GetSupervisedUserCustodianName(JNIEnv* env, - jobject obj) { +static ScopedJavaLocalRef<jstring> GetSupervisedUserCustodianName( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { return ConvertUTF8ToJavaString( env, GetPrefService()->GetString(prefs::kSupervisedUserCustodianName)); } static ScopedJavaLocalRef<jstring> GetSupervisedUserCustodianEmail( JNIEnv* env, - jobject obj) { + const JavaParamRef<jobject>& obj) { return ConvertUTF8ToJavaString( env, GetPrefService()->GetString(prefs::kSupervisedUserCustodianEmail)); } static ScopedJavaLocalRef<jstring> GetSupervisedUserCustodianProfileImageURL( JNIEnv* env, - jobject obj) { + const JavaParamRef<jobject>& obj) { return ConvertUTF8ToJavaString( env, GetPrefService()->GetString( prefs::kSupervisedUserCustodianProfileImageURL)); @@ -788,7 +897,7 @@ static ScopedJavaLocalRef<jstring> GetSupervisedUserCustodianProfileImageURL( static ScopedJavaLocalRef<jstring> GetSupervisedUserSecondCustodianName( JNIEnv* env, - jobject obj) { + const JavaParamRef<jobject>& obj) { return ConvertUTF8ToJavaString( env, GetPrefService()->GetString(prefs::kSupervisedUserSecondCustodianName)); @@ -796,14 +905,16 @@ static ScopedJavaLocalRef<jstring> GetSupervisedUserSecondCustodianName( static ScopedJavaLocalRef<jstring> GetSupervisedUserSecondCustodianEmail( JNIEnv* env, - jobject obj) { + const JavaParamRef<jobject>& obj) { return ConvertUTF8ToJavaString( env, GetPrefService()->GetString(prefs::kSupervisedUserSecondCustodianEmail)); } static ScopedJavaLocalRef<jstring> -GetSupervisedUserSecondCustodianProfileImageURL(JNIEnv* env, jobject obj) { +GetSupervisedUserSecondCustodianProfileImageURL( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { return ConvertUTF8ToJavaString( env, GetPrefService()->GetString( prefs::kSupervisedUserSecondCustodianProfileImageURL)); diff --git a/chrome/browser/android/preferences/website_preference_bridge.cc b/chrome/browser/android/preferences/website_preference_bridge.cc index 24095c8..9d1f8e9 100644 --- a/chrome/browser/android/preferences/website_preference_bridge.cc +++ b/chrome/browser/android/preferences/website_preference_bridge.cc @@ -175,25 +175,25 @@ static void SetSettingForOrigin(JNIEnv* env, } static void GetFullscreenOrigins(JNIEnv* env, - jclass clazz, - jobject list, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& list, jboolean managedOnly) { GetOrigins(env, CONTENT_SETTINGS_TYPE_FULLSCREEN, list, managedOnly); } static jint GetFullscreenSettingForOrigin(JNIEnv* env, - jclass clazz, - jstring origin, - jstring embedder, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& origin, + const JavaParamRef<jstring>& embedder, jboolean is_incognito) { return GetSettingForOrigin(env, CONTENT_SETTINGS_TYPE_FULLSCREEN, origin, embedder, is_incognito); } static void SetFullscreenSettingForOrigin(JNIEnv* env, - jclass clazz, - jstring origin, - jstring embedder, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& origin, + const JavaParamRef<jstring>& embedder, jint value, jboolean is_incognito) { GURL embedder_url(ConvertJavaStringToUTF8(env, embedder)); @@ -203,50 +203,54 @@ static void SetFullscreenSettingForOrigin(JNIEnv* env, } static void GetGeolocationOrigins(JNIEnv* env, - jclass clazz, - jobject list, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& list, jboolean managedOnly) { GetOrigins(env, CONTENT_SETTINGS_TYPE_GEOLOCATION, list, managedOnly); } -static jint GetGeolocationSettingForOrigin(JNIEnv* env, - jclass clazz, - jstring origin, - jstring embedder, - jboolean is_incognito) { +static jint GetGeolocationSettingForOrigin( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& origin, + const JavaParamRef<jstring>& embedder, + jboolean is_incognito) { return GetSettingForOrigin(env, CONTENT_SETTINGS_TYPE_GEOLOCATION, origin, embedder, is_incognito); } -static void SetGeolocationSettingForOrigin(JNIEnv* env, - jclass clazz, - jstring origin, - jstring embedder, - jint value, - jboolean is_incognito) { +static void SetGeolocationSettingForOrigin( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& origin, + const JavaParamRef<jstring>& embedder, + jint value, + jboolean is_incognito) { GURL embedder_url(ConvertJavaStringToUTF8(env, embedder)); SetSettingForOrigin(env, CONTENT_SETTINGS_TYPE_GEOLOCATION, origin, ContentSettingsPattern::FromURLNoWildcard(embedder_url), value, is_incognito); } -static void GetMidiOrigins(JNIEnv* env, jclass clazz, jobject list) { +static void GetMidiOrigins(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& list) { GetOrigins(env, CONTENT_SETTINGS_TYPE_MIDI_SYSEX, list, false); } static jint GetMidiSettingForOrigin(JNIEnv* env, - jclass clazz, - jstring origin, - jstring embedder, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& origin, + const JavaParamRef<jstring>& embedder, jboolean is_incognito) { return GetSettingForOrigin(env, CONTENT_SETTINGS_TYPE_MIDI_SYSEX, origin, embedder, is_incognito); } static void SetMidiSettingForOrigin(JNIEnv* env, - jclass clazz, - jstring origin, - jstring embedder, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& origin, + const JavaParamRef<jstring>& embedder, jint value, jboolean is_incognito) { GURL embedder_url(ConvertJavaStringToUTF8(env, embedder)); @@ -255,28 +259,32 @@ static void SetMidiSettingForOrigin(JNIEnv* env, value, is_incognito); } -static void GetProtectedMediaIdentifierOrigins(JNIEnv* env, jclass clazz, - jobject list) { +static void GetProtectedMediaIdentifierOrigins( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& list) { GetOrigins(env, CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER, list, false); } -static jint GetProtectedMediaIdentifierSettingForOrigin(JNIEnv* env, - jclass clazz, - jstring origin, - jstring embedder, - jboolean is_incognito) { +static jint GetProtectedMediaIdentifierSettingForOrigin( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& origin, + const JavaParamRef<jstring>& embedder, + jboolean is_incognito) { return GetSettingForOrigin(env, CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER, origin, embedder, is_incognito); } -static void SetProtectedMediaIdentifierSettingForOrigin(JNIEnv* env, - jclass clazz, - jstring origin, - jstring embedder, - jint value, - jboolean is_incognito) { +static void SetProtectedMediaIdentifierSettingForOrigin( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& origin, + const JavaParamRef<jstring>& embedder, + jint value, + jboolean is_incognito) { GURL embedder_url(ConvertJavaStringToUTF8(env, embedder)); SetSettingForOrigin(env, CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER, origin, @@ -285,27 +293,29 @@ static void SetProtectedMediaIdentifierSettingForOrigin(JNIEnv* env, } static void GetPushNotificationOrigins(JNIEnv* env, - jclass clazz, - jobject list) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& list) { GetOrigins(env, CONTENT_SETTINGS_TYPE_NOTIFICATIONS, list, false); } -static jint GetPushNotificationSettingForOrigin(JNIEnv* env, - jclass clazz, - jstring origin, - jstring embedder, - jboolean is_incognito) { +static jint GetPushNotificationSettingForOrigin( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& origin, + const JavaParamRef<jstring>& embedder, + jboolean is_incognito) { return DesktopNotificationProfileUtil::GetContentSetting( GetActiveUserProfile(is_incognito), GURL(ConvertJavaStringToUTF8(env, origin))); } -static void SetPushNotificationSettingForOrigin(JNIEnv* env, - jclass clazz, - jstring origin, - jstring embedder, - jint value, - jboolean is_incognito) { +static void SetPushNotificationSettingForOrigin( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& origin, + const JavaParamRef<jstring>& embedder, + jint value, + jboolean is_incognito) { // TODO(peter): Web Notification permission behaves differently from all other // permission types. See https://crbug.com/416894. Profile* profile = GetActiveUserProfile(is_incognito); @@ -332,41 +342,41 @@ static void SetPushNotificationSettingForOrigin(JNIEnv* env, } static void GetCameraOrigins(JNIEnv* env, - jclass clazz, - jobject list, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& list, jboolean managedOnly) { GetOrigins(env, CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, list, managedOnly); } static void GetMicrophoneOrigins(JNIEnv* env, - jclass clazz, - jobject list, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& list, jboolean managedOnly) { GetOrigins(env, CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, list, managedOnly); } static jint GetMicrophoneSettingForOrigin(JNIEnv* env, - jclass clazz, - jstring origin, - jstring embedder, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& origin, + const JavaParamRef<jstring>& embedder, jboolean is_incognito) { return GetSettingForOrigin(env, CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, origin, embedder, is_incognito); } static jint GetCameraSettingForOrigin(JNIEnv* env, - jclass clazz, - jstring origin, - jstring embedder, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& origin, + const JavaParamRef<jstring>& embedder, jboolean is_incognito) { return GetSettingForOrigin(env, CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, origin, embedder, is_incognito); } static void SetMicrophoneSettingForOrigin(JNIEnv* env, - jclass clazz, - jstring origin, - jstring embedder, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& origin, + const JavaParamRef<jstring>& embedder, jint value, jboolean is_incognito) { SetSettingForOrigin(env, CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, origin, @@ -374,9 +384,9 @@ static void SetMicrophoneSettingForOrigin(JNIEnv* env, } static void SetCameraSettingForOrigin(JNIEnv* env, - jclass clazz, - jstring origin, - jstring embedder, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& origin, + const JavaParamRef<jstring>& embedder, jint value, jboolean is_incognito) { SetSettingForOrigin(env, CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, origin, @@ -390,8 +400,8 @@ static scoped_refptr<content_settings::CookieSettings> GetCookieSettings() { } static void GetCookieOrigins(JNIEnv* env, - jclass clazz, - jobject list, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& list, jboolean managedOnly) { ContentSettingsForOneType all_settings; GetCookieSettings()->GetCookieSettings(&all_settings); @@ -417,18 +427,18 @@ static void GetCookieOrigins(JNIEnv* env, } static jint GetCookieSettingForOrigin(JNIEnv* env, - jclass clazz, - jstring origin, - jstring embedder, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& origin, + const JavaParamRef<jstring>& embedder, jboolean is_incognito) { return GetSettingForOrigin(env, CONTENT_SETTINGS_TYPE_COOKIES, origin, embedder, false); } static void SetCookieSettingForOrigin(JNIEnv* env, - jclass clazz, - jstring origin, - jstring embedder, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& origin, + const JavaParamRef<jstring>& embedder, jint value, jboolean is_incognito) { GURL url(ConvertJavaStringToUTF8(env, origin)); @@ -447,16 +457,19 @@ static void SetCookieSettingForOrigin(JNIEnv* env, CONTENT_SETTINGS_TYPE_NOTIFICATIONS, setting); } -static jboolean IsContentSettingsPatternValid(JNIEnv* env, jclass clazz, - jstring pattern) { +static jboolean IsContentSettingsPatternValid( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& pattern) { return ContentSettingsPattern::FromString( ConvertJavaStringToUTF8(env, pattern)).IsValid(); } -static jboolean UrlMatchesContentSettingsPattern(JNIEnv* env, - jclass clazz, - jstring jurl, - jstring jpattern) { +static jboolean UrlMatchesContentSettingsPattern( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jurl, + const JavaParamRef<jstring>& jpattern) { ContentSettingsPattern pattern = ContentSettingsPattern::FromString( ConvertJavaStringToUTF8(env, jpattern)); return pattern.Matches(GURL(ConvertJavaStringToUTF8(env, jurl))); @@ -734,8 +747,9 @@ class LocalStorageInfoReadyCallback { // helpers keep a reference to themselves for the duration of their tasks, // which includes callback invocation. -static void FetchLocalStorageInfo(JNIEnv* env, jclass clazz, - jobject java_callback) { +static void FetchLocalStorageInfo(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& java_callback) { Profile* profile = ProfileManager::GetActiveUserProfile(); scoped_refptr<BrowsingDataLocalStorageHelper> local_storage_helper( new BrowsingDataLocalStorageHelper(profile)); @@ -748,7 +762,9 @@ static void FetchLocalStorageInfo(JNIEnv* env, jclass clazz, base::Unretained(local_storage_callback))); } -static void FetchStorageInfo(JNIEnv* env, jclass clazz, jobject java_callback) { +static void FetchStorageInfo(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& java_callback) { Profile* profile = ProfileManager::GetActiveUserProfile(); scoped_refptr<StorageInfoFetcher> storage_info_fetcher(new StorageInfoFetcher( content::BrowserContext::GetDefaultStoragePartition( @@ -757,7 +773,9 @@ static void FetchStorageInfo(JNIEnv* env, jclass clazz, jobject java_callback) { storage_info_fetcher->Run(); } -static void ClearLocalStorageData(JNIEnv* env, jclass clazz, jstring jorigin) { +static void ClearLocalStorageData(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jorigin) { Profile* profile = ProfileManager::GetActiveUserProfile(); scoped_refptr<BrowsingDataLocalStorageHelper> local_storage_helper = new BrowsingDataLocalStorageHelper(profile); @@ -766,10 +784,10 @@ static void ClearLocalStorageData(JNIEnv* env, jclass clazz, jstring jorigin) { } static void ClearStorageData(JNIEnv* env, - jclass clazz, - jstring jhost, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jhost, jint type, - jobject java_callback) { + const JavaParamRef<jobject>& java_callback) { Profile* profile = ProfileManager::GetActiveUserProfile(); std::string host = ConvertJavaStringToUTF8(env, jhost); scoped_refptr<StorageDataDeleter> storage_data_deleter(new StorageDataDeleter( @@ -781,7 +799,9 @@ static void ClearStorageData(JNIEnv* env, storage_data_deleter->Run(); } -static void ClearCookieData(JNIEnv* env, jclass clazz, jstring jorigin) { +static void ClearCookieData(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jorigin) { Profile* profile = ProfileManager::GetActiveUserProfile(); GURL url(ConvertJavaStringToUTF8(env, jorigin)); scoped_refptr<SiteDataDeleteHelper> site_data_deleter( diff --git a/chrome/browser/android/profiles/profile_downloader_android.cc b/chrome/browser/android/profiles/profile_downloader_android.cc index c0914d5..f2162d0 100644 --- a/chrome/browser/android/profiles/profile_downloader_android.cc +++ b/chrome/browser/android/profiles/profile_downloader_android.cc @@ -122,8 +122,8 @@ class AccountInfoRetriever : public ProfileDownloaderDelegate { // static ScopedJavaLocalRef<jstring> GetCachedFullNameForPrimaryAccount( JNIEnv* env, - jclass clazz, - jobject jprofile) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& jprofile) { Profile* profile = ProfileAndroid::FromProfileAndroid(jprofile); ProfileInfoInterface& info = g_browser_process->profile_manager()->GetProfileInfoCache(); @@ -139,8 +139,8 @@ ScopedJavaLocalRef<jstring> GetCachedFullNameForPrimaryAccount( // static ScopedJavaLocalRef<jstring> GetCachedGivenNameForPrimaryAccount( JNIEnv* env, - jclass clazz, - jobject jprofile) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& jprofile) { Profile* profile = ProfileAndroid::FromProfileAndroid(jprofile); ProfileInfoInterface& info = g_browser_process->profile_manager()->GetProfileInfoCache(); @@ -154,9 +154,10 @@ ScopedJavaLocalRef<jstring> GetCachedGivenNameForPrimaryAccount( } // static -ScopedJavaLocalRef<jobject> GetCachedAvatarForPrimaryAccount(JNIEnv* env, - jclass clazz, - jobject jprofile) { +ScopedJavaLocalRef<jobject> GetCachedAvatarForPrimaryAccount( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& jprofile) { Profile* profile = ProfileAndroid::FromProfileAndroid(jprofile); ProfileInfoInterface& info = g_browser_process->profile_manager()->GetProfileInfoCache(); @@ -177,13 +178,12 @@ ScopedJavaLocalRef<jobject> GetCachedAvatarForPrimaryAccount(JNIEnv* env, } // static -void StartFetchingAccountInfoFor( - JNIEnv* env, - jclass clazz, - jobject jprofile, - jstring jemail, - jint image_side_pixels, - jboolean is_pre_signin) { +void StartFetchingAccountInfoFor(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& jprofile, + const JavaParamRef<jstring>& jemail, + jint image_side_pixels, + jboolean is_pre_signin) { Profile* profile = ProfileAndroid::FromProfileAndroid(jprofile); const std::string email = base::android::ConvertJavaStringToUTF8(env, jemail); diff --git a/chrome/browser/android/provider/chrome_browser_provider.cc b/chrome/browser/android/provider/chrome_browser_provider.cc index 9040bae..3579825 100644 --- a/chrome/browser/android/provider/chrome_browser_provider.cc +++ b/chrome/browser/android/provider/chrome_browser_provider.cc @@ -1150,7 +1150,7 @@ void FillSearchRow(JNIEnv* env, // ------------- Native initialization and destruction ------------- // -static jlong Init(JNIEnv* env, jobject obj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { ChromeBrowserProvider* provider = new ChromeBrowserProvider(env, obj); return reinterpret_cast<intptr_t>(provider); } diff --git a/chrome/browser/android/rappor/rappor_service_bridge.cc b/chrome/browser/android/rappor/rappor_service_bridge.cc index 7dd7293..f88b46a 100644 --- a/chrome/browser/android/rappor/rappor_service_bridge.cc +++ b/chrome/browser/android/rappor/rappor_service_bridge.cc @@ -13,9 +13,9 @@ namespace rappor { void SampleDomainAndRegistryFromURL(JNIEnv* env, - jclass caller, - jstring j_metric, - jstring j_url) { + const JavaParamRef<jclass>& caller, + const JavaParamRef<jstring>& j_metric, + const JavaParamRef<jstring>& j_url) { // TODO(knn): UMA metrics hash the string to prevent frequent re-encoding, // perhaps we should do that as well. std::string metric(base::android::ConvertJavaStringToUTF8(env, j_metric)); diff --git a/chrome/browser/android/recently_closed_tabs_bridge.cc b/chrome/browser/android/recently_closed_tabs_bridge.cc index 0049595..2115590 100644 --- a/chrome/browser/android/recently_closed_tabs_bridge.cc +++ b/chrome/browser/android/recently_closed_tabs_bridge.cc @@ -157,7 +157,9 @@ void RecentlyClosedTabsBridge::EnsureTabRestoreService() { } } -static jlong Init(JNIEnv* env, jobject obj, jobject jprofile) { +static jlong Init(JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& jprofile) { RecentlyClosedTabsBridge* bridge = new RecentlyClosedTabsBridge( ProfileAndroid::FromProfileAndroid(jprofile)); return reinterpret_cast<intptr_t>(bridge); diff --git a/chrome/browser/android/rlz/revenue_stats.cc b/chrome/browser/android/rlz/revenue_stats.cc index f89a2c9..e68253a 100644 --- a/chrome/browser/android/rlz/revenue_stats.cc +++ b/chrome/browser/android/rlz/revenue_stats.cc @@ -18,12 +18,16 @@ bool RegisterRevenueStats(JNIEnv* env) { return RegisterNativesImpl(env); } -static void SetSearchClient(JNIEnv* env, jclass clazz, jstring jclient) { +static void SetSearchClient(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jclient) { SearchTermsDataAndroid::search_client_.Get() = base::android::ConvertJavaStringToUTF8(env, jclient); } -static void SetRlzParameterValue(JNIEnv* env, jclass clazz, jstring jrlz) { +static void SetRlzParameterValue(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jrlz) { SearchTermsDataAndroid::rlz_parameter_value_.Get() = base::android::ConvertJavaStringToUTF16(env, jrlz); } diff --git a/chrome/browser/android/signin/account_management_screen_helper.cc b/chrome/browser/android/signin/account_management_screen_helper.cc index d0bfa0f..7aa2e94 100644 --- a/chrome/browser/android/signin/account_management_screen_helper.cc +++ b/chrome/browser/android/signin/account_management_screen_helper.cc @@ -26,7 +26,7 @@ void AccountManagementScreenHelper::OpenAccountManagementScreen( } static void LogEvent(JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jint metric, jint gaiaServiceType) { ProfileMetrics::LogProfileAndroidAccountManagementMenu( diff --git a/chrome/browser/android/signin/signin_manager_android.cc b/chrome/browser/android/signin/signin_manager_android.cc index 3dadad8..e078206 100644 --- a/chrome/browser/android/signin/signin_manager_android.cc +++ b/chrome/browser/android/signin/signin_manager_android.cc @@ -284,15 +284,16 @@ void SigninManagerAndroid::OnSigninAllowedPrefChanged() { SigninManagerFactory::GetForProfile(profile_)->IsSigninAllowed()); } -static jlong Init(JNIEnv* env, jobject obj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { SigninManagerAndroid* signin_manager_android = new SigninManagerAndroid(env, obj); return reinterpret_cast<intptr_t>(signin_manager_android); } -static jboolean ShouldLoadPolicyForUser(JNIEnv* env, - jobject obj, - jstring j_username) { +static jboolean ShouldLoadPolicyForUser( + JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jstring>& j_username) { #if defined(ENABLE_CONFIGURATION_POLICY) std::string username = base::android::ConvertJavaStringToUTF8(env, j_username); diff --git a/chrome/browser/android/tab/thumbnail_tab_helper_android.cc b/chrome/browser/android/tab/thumbnail_tab_helper_android.cc index 3c6328f..17c0cae 100644 --- a/chrome/browser/android/tab/thumbnail_tab_helper_android.cc +++ b/chrome/browser/android/tab/thumbnail_tab_helper_android.cc @@ -28,8 +28,8 @@ bool RegisterThumbnailTabHelperAndroid(JNIEnv* env) { } static void InitThumbnailHelper(JNIEnv* env, - jclass clazz, - jobject jweb_contents) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& jweb_contents) { content::WebContents* web_contents = content::WebContents::FromJavaWebContents(jweb_contents); DCHECK(web_contents); @@ -44,8 +44,10 @@ static void InitThumbnailHelper(JNIEnv* env, thumbnail_tab_helper->set_enabled(false); } -static jboolean ShouldUpdateThumbnail( - JNIEnv* env, jclass clazz, jobject jprofile, jstring jurl) { +static jboolean ShouldUpdateThumbnail(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& jprofile, + const JavaParamRef<jstring>& jurl) { Profile* profile = ProfileAndroid::FromProfileAndroid(jprofile); GURL url(base::android::ConvertJavaStringToUTF8(env, jurl)); @@ -56,9 +58,9 @@ static jboolean ShouldUpdateThumbnail( } static void UpdateThumbnail(JNIEnv* env, - jclass clazz, - jobject jweb_contents, - jobject bitmap, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& jweb_contents, + const JavaParamRef<jobject>& bitmap, jboolean jat_top) { content::WebContents* web_contents = content::WebContents::FromJavaWebContents(jweb_contents); diff --git a/chrome/browser/android/tab_android.cc b/chrome/browser/android/tab_android.cc index a862509..8b28116 100644 --- a/chrome/browser/android/tab_android.cc +++ b/chrome/browser/android/tab_android.cc @@ -943,7 +943,7 @@ void TabAndroid::DetachOverlayContentViewCore(JNIEnv* env, content_view_core->GetLayer()->RemoveFromParent(); } -static void Init(JNIEnv* env, jobject obj) { +static void Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { TRACE_EVENT0("native", "TabAndroid::Init"); // This will automatically bind to the Java object and pass ownership there. new TabAndroid(env, obj); @@ -954,7 +954,8 @@ bool TabAndroid::RegisterTabAndroid(JNIEnv* env) { return RegisterNativesImpl(env); } -static void RecordStartupToCommitUma(JNIEnv* env, jclass jcaller) { +static void RecordStartupToCommitUma(JNIEnv* env, + const JavaParamRef<jclass>& jcaller) { // Currently it takes about 2000ms to commit a navigation if the measurement // begins very early in the browser start. How many buckets (b) are needed to // explore the _typical_ values with granularity 100ms and a maximum duration diff --git a/chrome/browser/android/tab_state.cc b/chrome/browser/android/tab_state.cc index 11c090f..48962ae 100644 --- a/chrome/browser/android/tab_state.cc +++ b/chrome/browser/android/tab_state.cc @@ -496,15 +496,17 @@ ScopedJavaLocalRef<jobject> // Static JNI methods. -static void FreeWebContentsStateBuffer(JNIEnv* env, jclass clazz, jobject obj) { +static void FreeWebContentsStateBuffer(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& obj) { void* data = env->GetDirectBufferAddress(obj); free(data); } static ScopedJavaLocalRef<jobject> RestoreContentsFromByteBuffer( JNIEnv* env, - jclass clazz, - jobject state, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& state, jint saved_state_version, jboolean initially_hidden) { return WebContentsState::RestoreContentsFromByteBuffer(env, @@ -514,18 +516,19 @@ static ScopedJavaLocalRef<jobject> RestoreContentsFromByteBuffer( initially_hidden); } -static ScopedJavaLocalRef<jobject> GetContentsStateAsByteBuffer(JNIEnv* env, - jclass clazz, - jobject jtab) { +static ScopedJavaLocalRef<jobject> GetContentsStateAsByteBuffer( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& jtab) { TabAndroid* tab_android = TabAndroid::GetNativeTab(env, jtab); return WebContentsState::GetContentsStateAsByteBuffer(env, tab_android); } static ScopedJavaLocalRef<jobject> CreateSingleNavigationStateAsByteBuffer( JNIEnv* env, - jclass clazz, - jstring url, - jstring referrer_url, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& url, + const JavaParamRef<jstring>& referrer_url, jint referrer_policy, jboolean is_off_the_record) { return WebContentsState::CreateSingleNavigationStateAsByteBuffer( @@ -534,8 +537,8 @@ static ScopedJavaLocalRef<jobject> CreateSingleNavigationStateAsByteBuffer( static ScopedJavaLocalRef<jstring> GetDisplayTitleFromByteBuffer( JNIEnv* env, - jclass clazz, - jobject state, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& state, jint saved_state_version) { void* data = env->GetDirectBufferAddress(state); int size = env->GetDirectBufferCapacity(state); @@ -548,8 +551,8 @@ static ScopedJavaLocalRef<jstring> GetDisplayTitleFromByteBuffer( static ScopedJavaLocalRef<jstring> GetVirtualUrlFromByteBuffer( JNIEnv* env, - jclass clazz, - jobject state, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& state, jint saved_state_version) { void* data = env->GetDirectBufferAddress(state); int size = env->GetDirectBufferCapacity(state); @@ -562,8 +565,8 @@ static ScopedJavaLocalRef<jstring> GetVirtualUrlFromByteBuffer( // Creates a historical tab entry from the serialized tab contents contained // within |state|. static void CreateHistoricalTab(JNIEnv* env, - jclass clazz, - jobject state, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& state, jint saved_state_version) { scoped_ptr<WebContents> web_contents(WebContents::FromJavaWebContents( WebContentsState::RestoreContentsFromByteBuffer(env, clazz, state, diff --git a/chrome/browser/android/url_utilities.cc b/chrome/browser/android/url_utilities.cc index 44c4b352..a829025 100644 --- a/chrome/browser/android/url_utilities.cc +++ b/chrome/browser/android/url_utilities.cc @@ -28,9 +28,9 @@ net::registry_controlled_domains::PrivateRegistryFilter GetRegistryFilter( } // namespace static jboolean SameDomainOrHost(JNIEnv* env, - jclass clazz, - jstring url_1_str, - jstring url_2_str, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& url_1_str, + const JavaParamRef<jstring>& url_2_str, jboolean include_private) { GURL url_1 = ConvertJavaStringToGURL(env, url_1_str); GURL url_2 = ConvertJavaStringToGURL(env, url_2_str); @@ -45,8 +45,8 @@ static jboolean SameDomainOrHost(JNIEnv* env, static ScopedJavaLocalRef<jstring> GetDomainAndRegistry( JNIEnv* env, - jclass clazz, - jstring url, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& url, jboolean include_private) { DCHECK(url); GURL gurl = ConvertJavaStringToGURL(env, url); @@ -61,24 +61,29 @@ static ScopedJavaLocalRef<jstring> GetDomainAndRegistry( net::registry_controlled_domains::GetDomainAndRegistry(gurl, filter)); } -static jboolean IsGoogleSearchUrl(JNIEnv* env, jclass clazz, jstring url) { +static jboolean IsGoogleSearchUrl(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& url) { GURL gurl = ConvertJavaStringToGURL(env, url); if (gurl.is_empty()) return false; return google_util::IsGoogleSearchUrl(gurl); } -static jboolean IsGoogleHomePageUrl(JNIEnv* env, jclass clazz, jstring url) { +static jboolean IsGoogleHomePageUrl(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& url) { GURL gurl = ConvertJavaStringToGURL(env, url); if (gurl.is_empty()) return false; return google_util::IsGoogleHomePageUrl(gurl); } -static ScopedJavaLocalRef<jstring> FixupUrl(JNIEnv* env, - jclass clazz, - jstring url, - jstring optional_desired_tld) { +static ScopedJavaLocalRef<jstring> FixupUrl( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& url, + const JavaParamRef<jstring>& optional_desired_tld) { DCHECK(url); GURL fixed_url = url_formatter::FixupURL( base::android::ConvertJavaStringToUTF8(env, url), diff --git a/chrome/browser/android/warmup_manager.cc b/chrome/browser/android/warmup_manager.cc index b5d82b6..0c7956a 100644 --- a/chrome/browser/android/warmup_manager.cc +++ b/chrome/browser/android/warmup_manager.cc @@ -12,9 +12,10 @@ #include "jni/WarmupManager_jni.h" #include "url/gurl.h" - -static void PreconnectUrlAndSubresources(JNIEnv* env, jclass clazz, - jobject jprofile, jstring url_str) { +static void PreconnectUrlAndSubresources(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& jprofile, + const JavaParamRef<jstring>& url_str) { if (url_str) { GURL url = GURL(base::android::ConvertJavaStringToUTF8(env, url_str)); Profile* profile = ProfileAndroid::FromProfileAndroid(jprofile); diff --git a/chrome/browser/android/web_contents_factory.cc b/chrome/browser/android/web_contents_factory.cc index 5df6ca8..605c5ab 100644 --- a/chrome/browser/android/web_contents_factory.cc +++ b/chrome/browser/android/web_contents_factory.cc @@ -14,7 +14,7 @@ static ScopedJavaLocalRef<jobject> CreateWebContents( JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jboolean incognito, jboolean initially_hidden) { Profile* profile = g_browser_process->profile_manager()->GetLastUsedProfile(); diff --git a/chrome/browser/android/webapps/add_to_homescreen_dialog_helper.cc b/chrome/browser/android/webapps/add_to_homescreen_dialog_helper.cc index 03f310d..658cd3d 100644 --- a/chrome/browser/android/webapps/add_to_homescreen_dialog_helper.cc +++ b/chrome/browser/android/webapps/add_to_homescreen_dialog_helper.cc @@ -24,7 +24,9 @@ using content::Manifest; -jlong Initialize(JNIEnv* env, jobject obj, jobject java_web_contents) { +jlong Initialize(JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& java_web_contents) { content::WebContents* web_contents = content::WebContents::FromJavaWebContents(java_web_contents); AddToHomescreenDialogHelper* add_to_homescreen_helper = diff --git a/chrome/browser/autofill/android/personal_data_manager_android.cc b/chrome/browser/autofill/android/personal_data_manager_android.cc index b4ceaaf..707565b 100644 --- a/chrome/browser/autofill/android/personal_data_manager_android.cc +++ b/chrome/browser/autofill/android/personal_data_manager_android.cc @@ -305,47 +305,57 @@ bool PersonalDataManagerAndroid::Register(JNIEnv* env) { } // Returns whether the Autofill feature is enabled. -static jboolean IsAutofillEnabled(JNIEnv* env, jclass clazz) { +static jboolean IsAutofillEnabled(JNIEnv* env, + const JavaParamRef<jclass>& clazz) { return GetPrefs()->GetBoolean(autofill::prefs::kAutofillEnabled); } // Enables or disables the Autofill feature. -static void SetAutofillEnabled(JNIEnv* env, jclass clazz, jboolean enable) { +static void SetAutofillEnabled(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + jboolean enable) { GetPrefs()->SetBoolean(autofill::prefs::kAutofillEnabled, enable); } // Returns whether the Autofill feature is managed. -static jboolean IsAutofillManaged(JNIEnv* env, jclass clazz) { +static jboolean IsAutofillManaged(JNIEnv* env, + const JavaParamRef<jclass>& clazz) { return GetPrefs()->IsManagedPreference(autofill::prefs::kAutofillEnabled); } // Returns whether the Wallet import feature is available. -static jboolean IsWalletImportFeatureAvailable(JNIEnv* env, jclass clazz) { +static jboolean IsWalletImportFeatureAvailable( + JNIEnv* env, + const JavaParamRef<jclass>& clazz) { return WalletIntegrationAvailableForProfile(GetProfile()); } // Returns whether the Wallet import feature is enabled. -static jboolean IsWalletImportEnabled(JNIEnv* env, jclass clazz) { +static jboolean IsWalletImportEnabled(JNIEnv* env, + const JavaParamRef<jclass>& clazz) { return GetPrefs()->GetBoolean(autofill::prefs::kAutofillWalletImportEnabled); } // Enables or disables the Wallet import feature. -static void SetWalletImportEnabled(JNIEnv* env, jclass clazz, jboolean enable) { +static void SetWalletImportEnabled(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + jboolean enable) { GetPrefs()->SetBoolean(autofill::prefs::kAutofillWalletImportEnabled, enable); } // Returns an ISO 3166-1-alpha-2 country code for a |jcountry_name| using // the application locale, or an empty string. -static ScopedJavaLocalRef<jstring> ToCountryCode(JNIEnv* env, - jclass clazz, - jstring jcountry_name) { +static ScopedJavaLocalRef<jstring> ToCountryCode( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jcountry_name) { return ConvertUTF8ToJavaString( env, AutofillCountry::GetCountryCode( base::android::ConvertJavaStringToUTF16(env, jcountry_name), g_browser_process->GetApplicationLocale())); } -static jlong Init(JNIEnv* env, jobject obj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { PersonalDataManagerAndroid* personal_data_manager_android = new PersonalDataManagerAndroid(env, obj); return reinterpret_cast<intptr_t>(personal_data_manager_android); diff --git a/chrome/browser/dom_distiller/dom_distiller_service_factory_android.cc b/chrome/browser/dom_distiller/dom_distiller_service_factory_android.cc index 1c1df8e..ed9971c 100644 --- a/chrome/browser/dom_distiller/dom_distiller_service_factory_android.cc +++ b/chrome/browser/dom_distiller/dom_distiller_service_factory_android.cc @@ -32,9 +32,10 @@ bool DomDistillerServiceFactoryAndroid::Register(JNIEnv* env) { return RegisterNativesImpl(env); } -ScopedJavaLocalRef<jobject> GetForProfile(JNIEnv* env, - jclass clazz, - jobject j_profile) { +ScopedJavaLocalRef<jobject> GetForProfile( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& j_profile) { return DomDistillerServiceFactoryAndroid::GetForProfile(env, clazz, j_profile); } diff --git a/chrome/browser/dom_distiller/tab_utils_android.cc b/chrome/browser/dom_distiller/tab_utils_android.cc index fdf3858..b54fc75 100644 --- a/chrome/browser/dom_distiller/tab_utils_android.cc +++ b/chrome/browser/dom_distiller/tab_utils_android.cc @@ -22,17 +22,17 @@ namespace android { void DistillCurrentPageAndView(JNIEnv* env, - jclass clazz, - jobject j_web_contents) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& j_web_contents) { content::WebContents* web_contents = content::WebContents::FromJavaWebContents(j_web_contents); ::DistillCurrentPageAndView(web_contents); } void DistillAndView(JNIEnv* env, - jclass clazz, - jobject j_source_web_contents, - jobject j_destination_web_contents) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& j_source_web_contents, + const JavaParamRef<jobject>& j_destination_web_contents) { content::WebContents* source_web_contents = content::WebContents::FromJavaWebContents(j_source_web_contents); content::WebContents* destination_web_contents = @@ -42,8 +42,8 @@ void DistillAndView(JNIEnv* env, ScopedJavaLocalRef<jstring> GetFormattedUrlFromOriginalDistillerUrl( JNIEnv* env, - jclass clazz, - jstring j_url) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& j_url) { GURL url(base::android::ConvertJavaStringToUTF8(env, j_url)); Profile* profile = ProfileManager::GetLastUsedProfile(); std::string languages; // Empty if Profile cannot be retrieved. diff --git a/chrome/browser/invalidation/invalidation_service_factory_android.cc b/chrome/browser/invalidation/invalidation_service_factory_android.cc index 5058f68..e42da0e 100644 --- a/chrome/browser/invalidation/invalidation_service_factory_android.cc +++ b/chrome/browser/invalidation/invalidation_service_factory_android.cc @@ -38,16 +38,17 @@ ScopedJavaLocalRef<jobject> InvalidationServiceFactoryAndroid::GetForTest( return ScopedJavaLocalRef<jobject>(service_android->java_ref_); } -ScopedJavaLocalRef<jobject> GetForProfile(JNIEnv* env, - jclass clazz, - jobject j_profile) { +ScopedJavaLocalRef<jobject> GetForProfile( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& j_profile) { return InvalidationServiceFactoryAndroid::GetForProfile(env, clazz, j_profile); } ScopedJavaLocalRef<jobject> GetForTest(JNIEnv* env, - jclass clazz, - jobject j_context) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& j_context) { return InvalidationServiceFactoryAndroid::GetForTest(env, clazz, j_context); } diff --git a/chrome/browser/media/android/remote/record_cast_action.cc b/chrome/browser/media/android/remote/record_cast_action.cc index 386083b..7f9b5ad 100644 --- a/chrome/browser/media/android/remote/record_cast_action.cc +++ b/chrome/browser/media/android/remote/record_cast_action.cc @@ -43,18 +43,19 @@ enum RemotePlaybackDeviceType { } // namespace namespace remote_media { -static void RecordRemotePlaybackDeviceSelected( - JNIEnv*, jclass, jint device_type) { +static void RecordRemotePlaybackDeviceSelected(JNIEnv*, + const JavaParamRef<jclass>&, + jint device_type) { UMA_HISTOGRAM_ENUMERATION( "Cast.Sender.DeviceType", device_type, REMOTE_PLAYBACK_DEVICE_TYPE_COUNT); } -static void RecordCastPlayRequested(JNIEnv*, jclass) { +static void RecordCastPlayRequested(JNIEnv*, const JavaParamRef<jclass>&) { RecordAction(UserMetricsAction("Cast_Sender_CastPlayRequested")); } static void RecordCastDefaultPlayerResult(JNIEnv*, - jclass, + const JavaParamRef<jclass>&, jboolean cast_success) { if (cast_success) { UMA_HISTOGRAM_ENUMERATION("Cast.Sender.CastPlayerResult", @@ -68,7 +69,7 @@ static void RecordCastDefaultPlayerResult(JNIEnv*, } static void RecordCastYouTubePlayerResult(JNIEnv*, - jclass, + const JavaParamRef<jclass>&, jboolean cast_success) { if (cast_success) { UMA_HISTOGRAM_ENUMERATION("Cast.Sender.CastPlayerResult", YT_PLAYER_SUCCESS, @@ -79,13 +80,15 @@ static void RecordCastYouTubePlayerResult(JNIEnv*, } } -static void RecordCastMediaType(JNIEnv*, jclass, jint media_type) { +static void RecordCastMediaType(JNIEnv*, + const JavaParamRef<jclass>&, + jint media_type) { UMA_HISTOGRAM_ENUMERATION("Cast.Sender.CastMediaType", media_type, media::container_names::CONTAINER_MAX); } static void RecordCastEndedTimeRemaining(JNIEnv*, - jclass, + const JavaParamRef<jclass>&, jint video_total_time, jint time_left_in_video) { int percent_remaining = 100; diff --git a/chrome/browser/net/spdyproxy/data_reduction_proxy_settings_android.cc b/chrome/browser/net/spdyproxy/data_reduction_proxy_settings_android.cc index 06948a3..da7995e 100644 --- a/chrome/browser/net/spdyproxy/data_reduction_proxy_settings_android.cc +++ b/chrome/browser/net/spdyproxy/data_reduction_proxy_settings_android.cc @@ -198,6 +198,6 @@ DataReductionProxySettingsAndroid::GetLastBypassEvent(JNIEnv* env, } // Used by generated jni code. -static jlong Init(JNIEnv* env, jobject obj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { return reinterpret_cast<intptr_t>(new DataReductionProxySettingsAndroid()); } diff --git a/chrome/browser/notifications/notification_ui_manager_android.cc b/chrome/browser/notifications/notification_ui_manager_android.cc index 0529ff2..fe4f32a 100644 --- a/chrome/browser/notifications/notification_ui_manager_android.cc +++ b/chrome/browser/notifications/notification_ui_manager_android.cc @@ -29,7 +29,8 @@ using base::android::ConvertUTF8ToJavaString; // Called by the Java side when a notification event has been received, but the // NotificationUIManager has not been initialized yet. Enforce initialization of // the class. -static void InitializeNotificationUIManager(JNIEnv* env, jclass clazz) { +static void InitializeNotificationUIManager(JNIEnv* env, + const JavaParamRef<jclass>& clazz) { g_browser_process->notification_ui_manager(); } diff --git a/chrome/browser/prerender/external_prerender_handler_android.cc b/chrome/browser/prerender/external_prerender_handler_android.cc index 9ff7c0d..e02dfee 100644 --- a/chrome/browser/prerender/external_prerender_handler_android.cc +++ b/chrome/browser/prerender/external_prerender_handler_android.cc @@ -69,10 +69,10 @@ void ExternalPrerenderHandlerAndroid::CancelCurrentPrerender(JNIEnv* env, } static jboolean HasPrerenderedUrl(JNIEnv* env, - jclass clazz, - jobject jprofile, - jstring jurl, - jobject jweb_contents) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& jprofile, + const JavaParamRef<jstring>& jurl, + const JavaParamRef<jobject>& jweb_contents) { if (jurl == NULL) return false; @@ -93,7 +93,7 @@ ExternalPrerenderHandlerAndroid::ExternalPrerenderHandlerAndroid() {} ExternalPrerenderHandlerAndroid::~ExternalPrerenderHandlerAndroid() {} -static jlong Init(JNIEnv* env, jclass clazz) { +static jlong Init(JNIEnv* env, const JavaParamRef<jclass>& clazz) { ExternalPrerenderHandlerAndroid* external_handler = new ExternalPrerenderHandlerAndroid(); return reinterpret_cast<intptr_t>(external_handler); diff --git a/chrome/browser/profiles/profile_android.cc b/chrome/browser/profiles/profile_android.cc index 5bda90a..9c92901 100644 --- a/chrome/browser/profiles/profile_android.cc +++ b/chrome/browser/profiles/profile_android.cc @@ -96,7 +96,9 @@ jboolean ProfileAndroid::IsOffTheRecord(JNIEnv* env, jobject obj) { } // static -ScopedJavaLocalRef<jobject> GetLastUsedProfile(JNIEnv* env, jclass clazz) { +ScopedJavaLocalRef<jobject> GetLastUsedProfile( + JNIEnv* env, + const JavaParamRef<jclass>& clazz) { return ProfileAndroid::GetLastUsedProfile(env, clazz); } diff --git a/chrome/browser/search_engines/template_url_service_android.cc b/chrome/browser/search_engines/template_url_service_android.cc index ec59259..b157f89 100644 --- a/chrome/browser/search_engines/template_url_service_android.cc +++ b/chrome/browser/search_engines/template_url_service_android.cc @@ -257,7 +257,7 @@ TemplateUrlServiceAndroid::GetSearchEngineUrlFromTemplateUrl( return base::android::ConvertUTF8ToJavaString(env, url); } -static jlong Init(JNIEnv* env, jobject obj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { TemplateUrlServiceAndroid* template_url_service_android = new TemplateUrlServiceAndroid(env, obj); return reinterpret_cast<intptr_t>(template_url_service_android); diff --git a/chrome/browser/signin/oauth2_token_service_delegate_android.cc b/chrome/browser/signin/oauth2_token_service_delegate_android.cc index 2e80b1f..58d6f6e 100644 --- a/chrome/browser/signin/oauth2_token_service_delegate_android.cc +++ b/chrome/browser/signin/oauth2_token_service_delegate_android.cc @@ -162,9 +162,10 @@ ScopedJavaLocalRef<jobject> OAuth2TokenServiceDelegateAndroid::GetForProfile( static_cast<OAuth2TokenServiceDelegateAndroid*>(delegate)->java_ref_); } -static ScopedJavaLocalRef<jobject> GetForProfile(JNIEnv* env, - jclass clazz, - jobject j_profile_android) { +static ScopedJavaLocalRef<jobject> GetForProfile( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& j_profile_android) { return OAuth2TokenServiceDelegateAndroid::GetForProfile(env, clazz, j_profile_android); } @@ -461,8 +462,8 @@ void OAuth2TokenServiceDelegateAndroid::RevokeAllCredentials() { // Called from Java when fetching of an OAuth2 token is finished. The // |authToken| param is only valid when |result| is true. void OAuth2TokenFetched(JNIEnv* env, - jclass clazz, - jstring authToken, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& authToken, jboolean isTransientError, jlong nativeCallback) { std::string token; diff --git a/chrome/browser/ssl/connection_security_android.cc b/chrome/browser/ssl/connection_security_android.cc index 1d3c056..edce54c 100644 --- a/chrome/browser/ssl/connection_security_android.cc +++ b/chrome/browser/ssl/connection_security_android.cc @@ -15,9 +15,10 @@ bool RegisterConnectionSecurityAndroid(JNIEnv* env) { } // static -jint GetSecurityLevelForWebContents(JNIEnv* env, - jclass jcaller, - jobject jweb_contents) { +jint GetSecurityLevelForWebContents( + JNIEnv* env, + const JavaParamRef<jclass>& jcaller, + const JavaParamRef<jobject>& jweb_contents) { content::WebContents* web_contents = content::WebContents::FromJavaWebContents(jweb_contents); DCHECK(web_contents); diff --git a/chrome/browser/supervised_user/child_accounts/child_account_service_android.cc b/chrome/browser/supervised_user/child_accounts/child_account_service_android.cc index 0642bd4..6abbec9 100644 --- a/chrome/browser/supervised_user/child_accounts/child_account_service_android.cc +++ b/chrome/browser/supervised_user/child_accounts/child_account_service_android.cc @@ -17,16 +17,19 @@ bool g_has_child_account_status = false; } // namespace -jboolean IsChildAccountDetectionEnabled(JNIEnv* env, jobject obj) { +jboolean IsChildAccountDetectionEnabled(JNIEnv* env, + const JavaParamRef<jobject>& obj) { return ChildAccountService::IsChildAccountDetectionEnabled(); } -jboolean GetIsChildAccount(JNIEnv* env, jobject obj) { +jboolean GetIsChildAccount(JNIEnv* env, const JavaParamRef<jobject>& obj) { ProfileManager* profile_manager = g_browser_process->profile_manager(); return profile_manager->GetLastUsedProfile()->IsChild(); } -void SetIsChildAccount(JNIEnv* env, jobject obj, jboolean is_child) { +void SetIsChildAccount(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jboolean is_child) { VLOG(1) << "OnChildAccountSigninComplete"; // If the browser process has not been created yet, store the child account diff --git a/chrome/browser/sync/profile_sync_service_android.cc b/chrome/browser/sync/profile_sync_service_android.cc index b6745df..1b65f6b 100644 --- a/chrome/browser/sync/profile_sync_service_android.cc +++ b/chrome/browser/sync/profile_sync_service_android.cc @@ -464,7 +464,7 @@ ProfileSyncServiceAndroid* AttachCurrentThread())); } -static jlong Init(JNIEnv* env, jobject obj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { ProfileSyncServiceAndroid* profile_sync_service_android = new ProfileSyncServiceAndroid(env, obj); profile_sync_service_android->Init(); diff --git a/chrome/browser/ui/android/certificate_viewer_android.cc b/chrome/browser/ui/android/certificate_viewer_android.cc index f4a1380..fa22770 100644 --- a/chrome/browser/ui/android/certificate_viewer_android.cc +++ b/chrome/browser/ui/android/certificate_viewer_android.cc @@ -21,69 +21,86 @@ void ShowCertificateViewer(content::WebContents* web_contents, NOTREACHED(); } -static ScopedJavaLocalRef<jstring> GetCertIssuedToText(JNIEnv* env, jclass) { +static ScopedJavaLocalRef<jstring> GetCertIssuedToText( + JNIEnv* env, + const JavaParamRef<jclass>&) { return ConvertUTF8ToJavaString( env, l10n_util::GetStringUTF8(IDS_CERT_INFO_SUBJECT_GROUP)); } -static ScopedJavaLocalRef<jstring> GetCertInfoCommonNameText(JNIEnv* env, - jclass) { +static ScopedJavaLocalRef<jstring> GetCertInfoCommonNameText( + JNIEnv* env, + const JavaParamRef<jclass>&) { return ConvertUTF8ToJavaString( env, l10n_util::GetStringUTF8(IDS_CERT_INFO_COMMON_NAME_LABEL)); } -static ScopedJavaLocalRef<jstring> GetCertInfoOrganizationText(JNIEnv* env, - jclass) { +static ScopedJavaLocalRef<jstring> GetCertInfoOrganizationText( + JNIEnv* env, + const JavaParamRef<jclass>&) { return ConvertUTF8ToJavaString( env, l10n_util::GetStringUTF8(IDS_CERT_INFO_ORGANIZATION_LABEL)); } -static ScopedJavaLocalRef<jstring> GetCertInfoSerialNumberText(JNIEnv* env, - jclass) { +static ScopedJavaLocalRef<jstring> GetCertInfoSerialNumberText( + JNIEnv* env, + const JavaParamRef<jclass>&) { return ConvertUTF8ToJavaString( env, l10n_util::GetStringUTF8(IDS_CERT_INFO_SERIAL_NUMBER_LABEL)); } -static ScopedJavaLocalRef<jstring> GetCertInfoOrganizationUnitText(JNIEnv* env, - jclass) { +static ScopedJavaLocalRef<jstring> GetCertInfoOrganizationUnitText( + JNIEnv* env, + const JavaParamRef<jclass>&) { return ConvertUTF8ToJavaString( env, l10n_util::GetStringUTF8(IDS_CERT_INFO_ORGANIZATIONAL_UNIT_LABEL)); } -static ScopedJavaLocalRef<jstring> GetCertIssuedByText(JNIEnv* env, jclass) { +static ScopedJavaLocalRef<jstring> GetCertIssuedByText( + JNIEnv* env, + const JavaParamRef<jclass>&) { return ConvertUTF8ToJavaString( env, l10n_util::GetStringUTF8(IDS_CERT_INFO_ISSUER_GROUP)); } -static ScopedJavaLocalRef<jstring> GetCertValidityText(JNIEnv* env, jclass) { +static ScopedJavaLocalRef<jstring> GetCertValidityText( + JNIEnv* env, + const JavaParamRef<jclass>&) { return ConvertUTF8ToJavaString( env, l10n_util::GetStringUTF8(IDS_CERT_INFO_VALIDITY_GROUP)); } -static ScopedJavaLocalRef<jstring> GetCertIssuedOnText(JNIEnv* env, jclass) { +static ScopedJavaLocalRef<jstring> GetCertIssuedOnText( + JNIEnv* env, + const JavaParamRef<jclass>&) { return ConvertUTF8ToJavaString( env, l10n_util::GetStringUTF8(IDS_CERT_INFO_ISSUED_ON_LABEL)); } -static ScopedJavaLocalRef<jstring> GetCertExpiresOnText(JNIEnv* env, jclass) { +static ScopedJavaLocalRef<jstring> GetCertExpiresOnText( + JNIEnv* env, + const JavaParamRef<jclass>&) { return ConvertUTF8ToJavaString( env, l10n_util::GetStringUTF8(IDS_CERT_INFO_EXPIRES_ON_LABEL)); } -static ScopedJavaLocalRef<jstring> GetCertFingerprintsText(JNIEnv* env, - jclass) { +static ScopedJavaLocalRef<jstring> GetCertFingerprintsText( + JNIEnv* env, + const JavaParamRef<jclass>&) { return ConvertUTF8ToJavaString( env, l10n_util::GetStringUTF8(IDS_CERT_INFO_FINGERPRINTS_GROUP)); } -static ScopedJavaLocalRef<jstring> GetCertSHA256FingerprintText(JNIEnv* env, - jclass) { +static ScopedJavaLocalRef<jstring> GetCertSHA256FingerprintText( + JNIEnv* env, + const JavaParamRef<jclass>&) { return ConvertUTF8ToJavaString( env, l10n_util::GetStringUTF8(IDS_CERT_INFO_SHA256_FINGERPRINT_LABEL)); } -static ScopedJavaLocalRef<jstring> GetCertSHA1FingerprintText(JNIEnv* env, - jclass) { +static ScopedJavaLocalRef<jstring> GetCertSHA1FingerprintText( + JNIEnv* env, + const JavaParamRef<jclass>&) { return ConvertUTF8ToJavaString( env, l10n_util::GetStringUTF8(IDS_CERT_INFO_SHA1_FINGERPRINT_LABEL)); } diff --git a/chrome/browser/ui/android/connection_info_popup_android.cc b/chrome/browser/ui/android/connection_info_popup_android.cc index 9e41c35..d049fdf 100644 --- a/chrome/browser/ui/android/connection_info_popup_android.cc +++ b/chrome/browser/ui/android/connection_info_popup_android.cc @@ -30,8 +30,10 @@ using base::android::ScopedJavaLocalRef; using content::CertStore; using content::WebContents; -static ScopedJavaLocalRef<jobjectArray> -GetCertificateChain(JNIEnv* env, jobject obj, jobject java_web_contents) { +static ScopedJavaLocalRef<jobjectArray> GetCertificateChain( + JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& java_web_contents) { content::WebContents* web_contents = content::WebContents::FromJavaWebContents(java_web_contents); if (!web_contents) @@ -66,9 +68,9 @@ GetCertificateChain(JNIEnv* env, jobject obj, jobject java_web_contents) { // static static jlong Init(JNIEnv* env, - jclass clazz, - jobject obj, - jobject java_web_contents) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& java_web_contents) { content::WebContents* web_contents = content::WebContents::FromJavaWebContents(java_web_contents); diff --git a/chrome/browser/ui/android/infobars/data_reduction_proxy_infobar.cc b/chrome/browser/ui/android/infobars/data_reduction_proxy_infobar.cc index f123334..1f669b8 100644 --- a/chrome/browser/ui/android/infobars/data_reduction_proxy_infobar.cc +++ b/chrome/browser/ui/android/infobars/data_reduction_proxy_infobar.cc @@ -63,7 +63,9 @@ scoped_ptr<infobars::InfoBar> DataReductionProxyInfoBarDelegate::CreateInfoBar( // JNI for DataReductionProxyInfoBarDelegate. -void -Launch(JNIEnv* env, jclass clazz, jobject jweb_contents, jstring jlink_url) { +void Launch(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& jweb_contents, + const JavaParamRef<jstring>& jlink_url) { DataReductionProxyInfoBar::Launch(env, clazz, jweb_contents, jlink_url); } diff --git a/chrome/browser/ui/android/infobars/infobar_container_android.cc b/chrome/browser/ui/android/infobars/infobar_container_android.cc index d30b8ee..6288aab 100644 --- a/chrome/browser/ui/android/infobars/infobar_container_android.cc +++ b/chrome/browser/ui/android/infobars/infobar_container_android.cc @@ -82,7 +82,7 @@ void InfoBarContainerAndroid::PlatformSpecificRemoveInfoBar( // Native JNI methods --------------------------------------------------------- -static jlong Init(JNIEnv* env, jobject obj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { InfoBarContainerAndroid* infobar_container = new InfoBarContainerAndroid(env, obj); return reinterpret_cast<intptr_t>(infobar_container); diff --git a/chrome/browser/ui/android/javascript_app_modal_dialog_android.cc b/chrome/browser/ui/android/javascript_app_modal_dialog_android.cc index 7b62d8b..297a6d0 100644 --- a/chrome/browser/ui/android/javascript_app_modal_dialog_android.cc +++ b/chrome/browser/ui/android/javascript_app_modal_dialog_android.cc @@ -136,7 +136,9 @@ const ScopedJavaGlobalRef<jobject>& } // static -ScopedJavaLocalRef<jobject> GetCurrentModalDialog(JNIEnv* env, jclass clazz) { +ScopedJavaLocalRef<jobject> GetCurrentModalDialog( + JNIEnv* env, + const JavaParamRef<jclass>& clazz) { app_modal::AppModalDialog* dialog = app_modal::AppModalDialogQueue::GetInstance()->active_dialog(); if (!dialog || !dialog->native_dialog()) diff --git a/chrome/browser/ui/android/omnibox/omnibox_url_emphasizer.cc b/chrome/browser/ui/android/omnibox/omnibox_url_emphasizer.cc index 73cb692..fe2cb4f 100644 --- a/chrome/browser/ui/android/omnibox/omnibox_url_emphasizer.cc +++ b/chrome/browser/ui/android/omnibox/omnibox_url_emphasizer.cc @@ -12,10 +12,11 @@ #include "jni/OmniboxUrlEmphasizer_jni.h" // static -ScopedJavaLocalRef<jintArray> ParseForEmphasizeComponents(JNIEnv* env, - jclass clazz, - jobject jprofile, - jstring jtext) { +ScopedJavaLocalRef<jintArray> ParseForEmphasizeComponents( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& jprofile, + const JavaParamRef<jstring>& jtext) { Profile* profile = ProfileAndroid::FromProfileAndroid(jprofile); DCHECK(profile); diff --git a/chrome/browser/ui/android/omnibox/omnibox_view_util.cc b/chrome/browser/ui/android/omnibox/omnibox_view_util.cc index 5a19a5b..c80cccd 100644 --- a/chrome/browser/ui/android/omnibox/omnibox_view_util.cc +++ b/chrome/browser/ui/android/omnibox/omnibox_view_util.cc @@ -9,9 +9,10 @@ #include "jni/OmniboxViewUtil_jni.h" // static -ScopedJavaLocalRef<jstring> SanitizeTextForPaste(JNIEnv* env, - jclass clazz, - jstring jtext) { +ScopedJavaLocalRef<jstring> SanitizeTextForPaste( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jtext) { base::string16 pasted_text( base::android::ConvertJavaStringToUTF16(env, jtext)); pasted_text = OmniboxView::SanitizeTextForPaste(pasted_text); diff --git a/chrome/browser/ui/android/ssl_client_certificate_request.cc b/chrome/browser/ui/android/ssl_client_certificate_request.cc index 6ffdd57..9956db1 100644 --- a/chrome/browser/ui/android/ssl_client_certificate_request.cc +++ b/chrome/browser/ui/android/ssl_client_certificate_request.cc @@ -121,10 +121,10 @@ namespace android { // the user didn't select a certificate. static void OnSystemRequestCompletion( JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jlong request_id, - jobjectArray encoded_chain_ref, - jobject private_key_ref) { + const JavaParamRef<jobjectArray>& encoded_chain_ref, + const JavaParamRef<jobject>& private_key_ref) { DCHECK_CURRENTLY_ON(content::BrowserThread::UI); // Take back ownership of the delegate object. @@ -179,7 +179,9 @@ static void NotifyClientCertificatesChanged() { net::CertDatabase::GetInstance()->OnAndroidKeyStoreChanged(); } -static void NotifyClientCertificatesChangedOnIOThread(JNIEnv* env, jclass) { +static void NotifyClientCertificatesChangedOnIOThread( + JNIEnv* env, + const JavaParamRef<jclass>&) { if (content::BrowserThread::CurrentlyOn(content::BrowserThread::IO)) { NotifyClientCertificatesChanged(); } else { diff --git a/chrome/browser/ui/android/tab_model/single_tab_model.cc b/chrome/browser/ui/android/tab_model/single_tab_model.cc index 2aaa1ae..b99af80 100644 --- a/chrome/browser/ui/android/tab_model/single_tab_model.cc +++ b/chrome/browser/ui/android/tab_model/single_tab_model.cc @@ -10,9 +10,10 @@ #include "content/public/browser/web_contents.h" #include "jni/SingleTabModel_jni.h" -static void PermanentlyBlockAllNewWindows(JNIEnv* env, - jclass clazz, - jobject j_tab_android) { +static void PermanentlyBlockAllNewWindows( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& j_tab_android) { TabAndroid* tab = TabAndroid::GetNativeTab(env, j_tab_android); if (!tab) return; diff --git a/chrome/browser/ui/android/tab_model/tab_model_jni_bridge.cc b/chrome/browser/ui/android/tab_model/tab_model_jni_bridge.cc index 2f90009..1f2fa2d 100644 --- a/chrome/browser/ui/android/tab_model/tab_model_jni_bridge.cc +++ b/chrome/browser/ui/android/tab_model/tab_model_jni_bridge.cc @@ -158,7 +158,7 @@ inline static base::TimeDelta GetTimeDelta(jlong ms) { } void LogFromCloseMetric(JNIEnv* env, - jclass jcaller, + const JavaParamRef<jclass>& jcaller, jlong ms, jboolean perceived) { if (perceived) { @@ -171,7 +171,7 @@ void LogFromCloseMetric(JNIEnv* env, } void LogFromExitMetric(JNIEnv* env, - jclass jcaller, + const JavaParamRef<jclass>& jcaller, jlong ms, jboolean perceived) { if (perceived) { @@ -184,7 +184,7 @@ void LogFromExitMetric(JNIEnv* env, } void LogFromNewMetric(JNIEnv* env, - jclass jcaller, + const JavaParamRef<jclass>& jcaller, jlong ms, jboolean perceived) { if (perceived) { @@ -197,7 +197,7 @@ void LogFromNewMetric(JNIEnv* env, } void LogFromUserMetric(JNIEnv* env, - jclass jcaller, + const JavaParamRef<jclass>& jcaller, jlong ms, jboolean perceived) { if (perceived) { @@ -217,7 +217,9 @@ bool TabModelJniBridge::Register(JNIEnv* env) { return RegisterNativesImpl(env); } -static jlong Init(JNIEnv* env, jobject obj, jboolean is_incognito) { +static jlong Init(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jboolean is_incognito) { TabModel* tab_model = new TabModelJniBridge(env, obj, is_incognito); return reinterpret_cast<intptr_t>(tab_model); } diff --git a/chrome/browser/ui/android/toolbar/toolbar_model_android.cc b/chrome/browser/ui/android/toolbar/toolbar_model_android.cc index 2ce0ed4..293eaf8 100644 --- a/chrome/browser/ui/android/toolbar/toolbar_model_android.cc +++ b/chrome/browser/ui/android/toolbar/toolbar_model_android.cc @@ -65,7 +65,9 @@ bool ToolbarModelAndroid::RegisterToolbarModelAndroid(JNIEnv* env) { } // static -jlong Init(JNIEnv* env, jobject obj, jobject delegate) { +jlong Init(JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& delegate) { ToolbarModelAndroid* toolbar_model = new ToolbarModelAndroid(env, delegate); return reinterpret_cast<intptr_t>(toolbar_model); } @@ -79,8 +81,8 @@ jlong Init(JNIEnv* env, jobject obj, jobject delegate) { // static jboolean IsDeprecatedSHA1Present(JNIEnv* env, - jclass jcaller, - jobject jweb_contents) { + const JavaParamRef<jclass>& jcaller, + const JavaParamRef<jobject>& jweb_contents) { content::WebContents* web_contents = content::WebContents::FromJavaWebContents(jweb_contents); DCHECK(web_contents); diff --git a/chrome/browser/ui/android/website_settings_popup_android.cc b/chrome/browser/ui/android/website_settings_popup_android.cc index 4b4c9f1..3b1c91c 100644 --- a/chrome/browser/ui/android/website_settings_popup_android.cc +++ b/chrome/browser/ui/android/website_settings_popup_android.cc @@ -27,9 +27,9 @@ using base::android::ConvertUTF8ToJavaString; // static static jlong Init(JNIEnv* env, - jclass clazz, - jobject obj, - jobject java_web_contents) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& java_web_contents) { content::WebContents* web_contents = content::WebContents::FromJavaWebContents(java_web_contents); diff --git a/chromecast/android/cast_metrics_helper_android.cc b/chromecast/android/cast_metrics_helper_android.cc index 62530bd..439303f 100644 --- a/chromecast/android/cast_metrics_helper_android.cc +++ b/chromecast/android/cast_metrics_helper_android.cc @@ -14,11 +14,11 @@ bool CastMetricsHelperAndroid::RegisterJni(JNIEnv* env) { return RegisterNativesImpl(env); } -void LogMediaPlay(JNIEnv* env, jclass clazz) { +void LogMediaPlay(JNIEnv* env, const JavaParamRef<jclass>& clazz) { metrics::CastMetricsHelper::GetInstance()->LogMediaPlay(); } -void LogMediaPause(JNIEnv* env, jclass clazz) { +void LogMediaPause(JNIEnv* env, const JavaParamRef<jclass>& clazz) { metrics::CastMetricsHelper::GetInstance()->LogMediaPause(); } diff --git a/chromecast/base/chromecast_config_android.cc b/chromecast/base/chromecast_config_android.cc index f16b473..168faa2 100644 --- a/chromecast/base/chromecast_config_android.cc +++ b/chromecast/base/chromecast_config_android.cc @@ -47,7 +47,9 @@ void ChromecastConfigAndroid::SetSendUsageStatsChangedCallback( } // Called from Java. -void SetSendUsageStatsEnabled(JNIEnv* env, jclass caller, jboolean enabled) { +void SetSendUsageStatsEnabled(JNIEnv* env, + const JavaParamRef<jclass>& caller, + jboolean enabled) { ChromecastConfigAndroid::GetInstance()-> send_usage_stats_changed_callback().Run(enabled); } diff --git a/chromecast/browser/android/cast_window_manager.cc b/chromecast/browser/android/cast_window_manager.cc index c53005b..c4e2f12 100644 --- a/chromecast/browser/android/cast_window_manager.cc +++ b/chromecast/browser/android/cast_window_manager.cc @@ -52,12 +52,16 @@ bool RegisterCastWindowManager(JNIEnv* env) { return RegisterNativesImpl(env); } -void Init(JNIEnv* env, jclass clazz, jobject obj) { +void Init(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& obj) { g_window_manager.Get().Reset( base::android::ScopedJavaLocalRef<jobject>(env, obj)); } -jlong LaunchCastWindow(JNIEnv* env, jclass clazz, jstring jurl) { +jlong LaunchCastWindow(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jurl) { GURL url(base::android::ConvertJavaStringToUTF8(env, jurl)); return reinterpret_cast<jlong>( CastWindowAndroid::CreateNewWindow( @@ -65,8 +69,10 @@ jlong LaunchCastWindow(JNIEnv* env, jclass clazz, jstring jurl) { url)); } -void StopCastWindow(JNIEnv* env, jclass clazz, - jlong nativeCastWindow, jboolean gracefully) { +void StopCastWindow(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + jlong nativeCastWindow, + jboolean gracefully) { CastWindowAndroid* window = reinterpret_cast<CastWindowAndroid*>(nativeCastWindow); DCHECK(window); @@ -76,7 +82,9 @@ void StopCastWindow(JNIEnv* env, jclass clazz, window->Destroy(); } -void EnableDevTools(JNIEnv* env, jclass clazz, jboolean enable) { +void EnableDevTools(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + jboolean enable) { DCHECK_CURRENTLY_ON(content::BrowserThread::UI); CastBrowserProcess::GetInstance()->pref_service()->SetBoolean( prefs::kEnableRemoteDebugging, enable); diff --git a/components/cronet/android/chromium_url_request.cc b/components/cronet/android/chromium_url_request.cc index a536c89..2e82409 100644 --- a/components/cronet/android/chromium_url_request.cc +++ b/components/cronet/android/chromium_url_request.cc @@ -107,9 +107,9 @@ bool ChromiumUrlRequestRegisterJni(JNIEnv* env) { } static jlong CreateRequestAdapter(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_context_adapter, - jstring jurl, + const JavaParamRef<jstring>& jurl, jint jrequest_priority) { URLRequestContextAdapter* context_adapter = reinterpret_cast<URLRequestContextAdapter*>(jurl_request_context_adapter); @@ -128,10 +128,10 @@ static jlong CreateRequestAdapter(JNIEnv* env, // synchronized static void AddHeader(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_adapter, - jstring jheader_name, - jstring jheader_value) { + const JavaParamRef<jstring>& jheader_name, + const JavaParamRef<jstring>& jheader_value) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); DCHECK(request_adapter); @@ -143,9 +143,9 @@ static void AddHeader(JNIEnv* env, } static void SetMethod(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_adapter, - jstring jmethod) { + const JavaParamRef<jstring>& jmethod) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); DCHECK(request_adapter); @@ -156,10 +156,10 @@ static void SetMethod(JNIEnv* env, } static void SetUploadData(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_adapter, - jstring jcontent_type, - jbyteArray jcontent) { + const JavaParamRef<jstring>& jcontent_type, + const JavaParamRef<jbyteArray>& jcontent) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); DCHECK(request_adapter); @@ -177,9 +177,9 @@ static void SetUploadData(JNIEnv* env, } static void SetUploadChannel(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_adapter, - jstring jcontent_type, + const JavaParamRef<jstring>& jcontent_type, jlong jcontent_length) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); @@ -190,9 +190,9 @@ static void SetUploadChannel(JNIEnv* env, } static void EnableChunkedUpload(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_adapter, - jstring jcontent_type) { + const JavaParamRef<jstring>& jcontent_type) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); DCHECK(request_adapter); @@ -202,9 +202,9 @@ static void EnableChunkedUpload(JNIEnv* env, } static void AppendChunk(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_adapter, - jobject jchunk_byte_buffer, + const JavaParamRef<jobject>& jchunk_byte_buffer, jint jchunk_size, jboolean jis_last_chunk) { URLRequestAdapter* request_adapter = @@ -218,7 +218,9 @@ static void AppendChunk(JNIEnv* env, } /* synchronized */ -static void Start(JNIEnv* env, jobject jcaller, jlong jurl_request_adapter) { +static void Start(JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jlong jurl_request_adapter) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); if (request_adapter != NULL) @@ -227,7 +229,7 @@ static void Start(JNIEnv* env, jobject jcaller, jlong jurl_request_adapter) { /* synchronized */ static void DestroyRequestAdapter(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_adapter) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); @@ -236,7 +238,9 @@ static void DestroyRequestAdapter(JNIEnv* env, } /* synchronized */ -static void Cancel(JNIEnv* env, jobject jcaller, jlong jurl_request_adapter) { +static void Cancel(JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jlong jurl_request_adapter) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); if (request_adapter != NULL) @@ -244,7 +248,7 @@ static void Cancel(JNIEnv* env, jobject jcaller, jlong jurl_request_adapter) { } static jint GetErrorCode(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_adapter) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); @@ -284,9 +288,10 @@ static jint GetErrorCode(JNIEnv* env, return REQUEST_ERROR_UNKNOWN; } -static ScopedJavaLocalRef<jstring> GetErrorString(JNIEnv* env, - jobject jcaller, - jlong jurl_request_adapter) { +static ScopedJavaLocalRef<jstring> GetErrorString( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jlong jurl_request_adapter) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); DCHECK(request_adapter); @@ -302,7 +307,7 @@ static ScopedJavaLocalRef<jstring> GetErrorString(JNIEnv* env, } static jint GetHttpStatusCode(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_adapter) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); @@ -310,17 +315,20 @@ static jint GetHttpStatusCode(JNIEnv* env, return request_adapter->http_status_code(); } -static ScopedJavaLocalRef<jstring> -GetHttpStatusText(JNIEnv* env, jobject jcaller, jlong jurl_request_adapter) { +static ScopedJavaLocalRef<jstring> GetHttpStatusText( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jlong jurl_request_adapter) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); DCHECK(request_adapter); return ConvertUTF8ToJavaString(env, request_adapter->http_status_text()); } -static ScopedJavaLocalRef<jstring> GetContentType(JNIEnv* env, - jobject jcaller, - jlong jurl_request_adapter) { +static ScopedJavaLocalRef<jstring> GetContentType( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jlong jurl_request_adapter) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); DCHECK(request_adapter); @@ -333,7 +341,7 @@ static ScopedJavaLocalRef<jstring> GetContentType(JNIEnv* env, } static jlong GetContentLength(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_adapter) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); @@ -341,10 +349,11 @@ static jlong GetContentLength(JNIEnv* env, return request_adapter->content_length(); } -static ScopedJavaLocalRef<jstring> GetHeader(JNIEnv* env, - jobject jcaller, - jlong jurl_request_adapter, - jstring jheader_name) { +static ScopedJavaLocalRef<jstring> GetHeader( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jlong jurl_request_adapter, + const JavaParamRef<jstring>& jheader_name) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); DCHECK(request_adapter); @@ -356,9 +365,9 @@ static ScopedJavaLocalRef<jstring> GetHeader(JNIEnv* env, } static void GetAllHeaders(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_adapter, - jobject jheaders_map) { + const JavaParamRef<jobject>& jheaders_map) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); DCHECK(request_adapter); @@ -389,7 +398,7 @@ static void GetAllHeaders(JNIEnv* env, static ScopedJavaLocalRef<jstring> GetNegotiatedProtocol( JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_adapter) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); @@ -400,7 +409,7 @@ static ScopedJavaLocalRef<jstring> GetNegotiatedProtocol( } static jboolean GetWasCached(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_adapter) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jurl_request_adapter); @@ -410,7 +419,8 @@ static jboolean GetWasCached(JNIEnv* env, return was_cached ? JNI_TRUE : JNI_FALSE; } -static void DisableRedirects(JNIEnv* env, jobject jcaller, +static void DisableRedirects(JNIEnv* env, + const JavaParamRef<jobject>& jcaller, jlong jrequest_adapter) { URLRequestAdapter* request_adapter = reinterpret_cast<URLRequestAdapter*>(jrequest_adapter); diff --git a/components/cronet/android/chromium_url_request_context.cc b/components/cronet/android/chromium_url_request_context.cc index d94f84d..247077d 100644 --- a/components/cronet/android/chromium_url_request_context.cc +++ b/components/cronet/android/chromium_url_request_context.cc @@ -61,11 +61,12 @@ bool ChromiumUrlRequestContextRegisterJni(JNIEnv* env) { } // Sets global user-agent to be used for all subsequent requests. -static jlong CreateRequestContextAdapter(JNIEnv* env, - jobject jcaller, - jstring juser_agent, - jint jlog_level, - jstring jconfig) { +static jlong CreateRequestContextAdapter( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + const JavaParamRef<jstring>& juser_agent, + jint jlog_level, + const JavaParamRef<jstring>& jconfig) { std::string user_agent = ConvertJavaStringToUTF8(env, juser_agent); std::string config = ConvertJavaStringToUTF8(env, jconfig); @@ -98,7 +99,7 @@ static jlong CreateRequestContextAdapter(JNIEnv* env, // Releases native objects. static void ReleaseRequestContextAdapter(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_context_adapter) { URLRequestContextAdapter* context_adapter = reinterpret_cast<URLRequestContextAdapter*>(jurl_request_context_adapter); @@ -111,15 +112,17 @@ static void ReleaseRequestContextAdapter(JNIEnv* env, } // Starts recording statistics. -static void InitializeStatistics(JNIEnv* env, jobject jcaller) { +static void InitializeStatistics(JNIEnv* env, + const JavaParamRef<jobject>& jcaller) { base::StatisticsRecorder::Initialize(); } // Gets current statistics with |jfilter| as a substring as JSON text (an empty // |jfilter| will include all registered histograms). -static ScopedJavaLocalRef<jstring> GetStatisticsJSON(JNIEnv* env, - jobject jcaller, - jstring jfilter) { +static ScopedJavaLocalRef<jstring> GetStatisticsJSON( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + const JavaParamRef<jstring>& jfilter) { std::string query = ConvertJavaStringToUTF8(env, jfilter); std::string json = base::StatisticsRecorder::ToJSON(query); return ConvertUTF8ToJavaString(env, json); @@ -127,9 +130,9 @@ static ScopedJavaLocalRef<jstring> GetStatisticsJSON(JNIEnv* env, // Starts recording NetLog into file with |jfilename|. static void StartNetLogToFile(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_context_adapter, - jstring jfilename, + const JavaParamRef<jstring>& jfilename, jboolean jlog_all) { URLRequestContextAdapter* context_adapter = reinterpret_cast<URLRequestContextAdapter*>(jurl_request_context_adapter); @@ -139,7 +142,7 @@ static void StartNetLogToFile(JNIEnv* env, // Stops recording NetLog. static void StopNetLog(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_context_adapter) { URLRequestContextAdapter* context_adapter = reinterpret_cast<URLRequestContextAdapter*>(jurl_request_context_adapter); @@ -148,7 +151,7 @@ static void StopNetLog(JNIEnv* env, // Called on application's main Java thread. static void InitRequestContextOnMainThread(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong jurl_request_context_adapter) { URLRequestContextAdapter* context_adapter = reinterpret_cast<URLRequestContextAdapter*>(jurl_request_context_adapter); diff --git a/components/cronet/android/cronet_histogram_manager.cc b/components/cronet/android/cronet_histogram_manager.cc index ae0de70..ca7c3f0 100644 --- a/components/cronet/android/cronet_histogram_manager.cc +++ b/components/cronet/android/cronet_histogram_manager.cc @@ -20,12 +20,14 @@ bool CronetHistogramManagerRegisterJni(JNIEnv* env) { return RegisterNativesImpl(env); } -static void EnsureInitialized(JNIEnv* env, jobject jcaller) { +static void EnsureInitialized(JNIEnv* env, + const JavaParamRef<jobject>& jcaller) { base::StatisticsRecorder::Initialize(); } -static ScopedJavaLocalRef<jbyteArray> GetHistogramDeltas(JNIEnv* env, - jobject jcaller) { +static ScopedJavaLocalRef<jbyteArray> GetHistogramDeltas( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller) { std::vector<uint8> data; if (!HistogramManager::GetInstance()->GetDeltas(&data)) return ScopedJavaLocalRef<jbyteArray>(); diff --git a/components/cronet/android/cronet_library_loader.cc b/components/cronet/android/cronet_library_loader.cc index 8e38125..aff1ffc 100644 --- a/components/cronet/android/cronet_library_loader.cc +++ b/components/cronet/android/cronet_library_loader.cc @@ -87,15 +87,15 @@ void CronetOnUnLoad(JavaVM* jvm, void* reserved) { } void CronetInitApplicationContext(JNIEnv* env, - jclass jcaller, - jobject japp_context) { + const JavaParamRef<jclass>& jcaller, + const JavaParamRef<jobject>& japp_context) { // Set application context. base::android::ScopedJavaLocalRef<jobject> scoped_app_context(env, japp_context); base::android::InitApplicationContext(env, scoped_app_context); } -void CronetInitOnMainThread(JNIEnv* env, jclass jcaller) { +void CronetInitOnMainThread(JNIEnv* env, const JavaParamRef<jclass>& jcaller) { #if !defined(USE_ICU_ALTERNATIVES_ON_ANDROID) base::i18n::InitializeICU(); #endif @@ -113,7 +113,9 @@ void CronetInitOnMainThread(JNIEnv* env, jclass jcaller) { g_network_change_notifier = net::NetworkChangeNotifier::Create(); } -ScopedJavaLocalRef<jstring> GetCronetVersion(JNIEnv* env, jclass jcaller) { +ScopedJavaLocalRef<jstring> GetCronetVersion( + JNIEnv* env, + const JavaParamRef<jclass>& jcaller) { return base::android::ConvertUTF8ToJavaString(env, CRONET_VERSION); } diff --git a/components/cronet/android/cronet_upload_data_stream_adapter.cc b/components/cronet/android/cronet_upload_data_stream_adapter.cc index 35bc6ce..70f98d3 100644 --- a/components/cronet/android/cronet_upload_data_stream_adapter.cc +++ b/components/cronet/android/cronet_upload_data_stream_adapter.cc @@ -99,10 +99,11 @@ bool CronetUploadDataStreamAdapterRegisterJni(JNIEnv* env) { return RegisterNativesImpl(env); } -static jlong AttachUploadDataToRequest(JNIEnv* env, - jobject jupload_data_stream, - jlong jcronet_url_request_adapter, - jlong jlength) { +static jlong AttachUploadDataToRequest( + JNIEnv* env, + const JavaParamRef<jobject>& jupload_data_stream, + jlong jcronet_url_request_adapter, + jlong jlength) { CronetURLRequestAdapter* request_adapter = reinterpret_cast<CronetURLRequestAdapter*>(jcronet_url_request_adapter); DCHECK(request_adapter != nullptr); @@ -118,17 +119,19 @@ static jlong AttachUploadDataToRequest(JNIEnv* env, return reinterpret_cast<jlong>(adapter); } -static jlong CreateAdapterForTesting(JNIEnv* env, - jobject jupload_data_stream) { +static jlong CreateAdapterForTesting( + JNIEnv* env, + const JavaParamRef<jobject>& jupload_data_stream) { CronetUploadDataStreamAdapter* adapter = new CronetUploadDataStreamAdapter(env, jupload_data_stream); return reinterpret_cast<jlong>(adapter); } -static jlong CreateUploadDataStreamForTesting(JNIEnv* env, - jobject jupload_data_stream, - jlong jlength, - jlong jadapter) { +static jlong CreateUploadDataStreamForTesting( + JNIEnv* env, + const JavaParamRef<jobject>& jupload_data_stream, + jlong jlength, + jlong jadapter) { CronetUploadDataStreamAdapter* adapter = reinterpret_cast<CronetUploadDataStreamAdapter*>(jadapter); CronetUploadDataStream* upload_data_stream = @@ -136,9 +139,10 @@ static jlong CreateUploadDataStreamForTesting(JNIEnv* env, return reinterpret_cast<jlong>(upload_data_stream); } -static void DestroyAdapter(JNIEnv* env, - jclass jcronet_url_request_adapter, - jlong jupload_data_stream_adapter) { +static void DestroyAdapter( + JNIEnv* env, + const JavaParamRef<jclass>& jcronet_url_request_adapter, + jlong jupload_data_stream_adapter) { CronetUploadDataStreamAdapter* adapter = reinterpret_cast<CronetUploadDataStreamAdapter*>( jupload_data_stream_adapter); diff --git a/components/cronet/android/cronet_url_request_adapter.cc b/components/cronet/android/cronet_url_request_adapter.cc index f3f1749..14115e0 100644 --- a/components/cronet/android/cronet_url_request_adapter.cc +++ b/components/cronet/android/cronet_url_request_adapter.cc @@ -33,9 +33,9 @@ bool CronetUrlRequestAdapterRegisterJni(JNIEnv* env) { } static jlong CreateRequestAdapter(JNIEnv* env, - jobject jurl_request, + const JavaParamRef<jobject>& jurl_request, jlong jurl_request_context_adapter, - jstring jurl_string, + const JavaParamRef<jstring>& jurl_string, jint jpriority) { CronetURLRequestContextAdapter* context_adapter = reinterpret_cast<CronetURLRequestContextAdapter*>( diff --git a/components/cronet/android/cronet_url_request_context_adapter.cc b/components/cronet/android/cronet_url_request_context_adapter.cc index 0cb2892..c100849 100644 --- a/components/cronet/android/cronet_url_request_context_adapter.cc +++ b/components/cronet/android/cronet_url_request_context_adapter.cc @@ -398,8 +398,8 @@ base::Thread* CronetURLRequestContextAdapter::GetFileThread() { // Creates RequestContextAdater if config is valid URLRequestContextConfig, // returns 0 otherwise. static jlong CreateRequestContextAdapter(JNIEnv* env, - jclass jcaller, - jstring jconfig) { + const JavaParamRef<jclass>& jcaller, + const JavaParamRef<jstring>& jconfig) { std::string config_string = base::android::ConvertJavaStringToUTF8(env, jconfig); scoped_ptr<URLRequestContextConfig> context_config( @@ -412,7 +412,9 @@ static jlong CreateRequestContextAdapter(JNIEnv* env, return reinterpret_cast<jlong>(context_adapter); } -static jint SetMinLogLevel(JNIEnv* env, jclass jcaller, jint jlog_level) { +static jint SetMinLogLevel(JNIEnv* env, + const JavaParamRef<jclass>& jcaller, + jint jlog_level) { jint old_log_level = static_cast<jint>(logging::GetMinLogLevel()); // MinLogLevel is global, shared by all URLRequestContexts. logging::SetMinLogLevel(static_cast<int>(jlog_level)); diff --git a/components/cronet/android/test/mock_url_request_job_factory.cc b/components/cronet/android/test/mock_url_request_job_factory.cc index 14fbfe1..716faa8 100644 --- a/components/cronet/android/test/mock_url_request_job_factory.cc +++ b/components/cronet/android/test/mock_url_request_job_factory.cc @@ -14,34 +14,37 @@ namespace cronet { -void AddUrlInterceptors(JNIEnv* env, jclass jcaller) { +void AddUrlInterceptors(JNIEnv* env, const JavaParamRef<jclass>& jcaller) { net::URLRequestMockDataJob::AddUrlHandler(); net::URLRequestFailedJob::AddUrlHandler(); net::SSLCertificateErrorJob::AddUrlHandler(); } -ScopedJavaLocalRef<jstring> GetMockUrlWithFailure(JNIEnv* jenv, - jclass jcaller, - jint jphase, - jint jnet_error) { +ScopedJavaLocalRef<jstring> GetMockUrlWithFailure( + JNIEnv* jenv, + const JavaParamRef<jclass>& jcaller, + jint jphase, + jint jnet_error) { GURL url(net::URLRequestFailedJob::GetMockHttpUrlWithFailurePhase( static_cast<net::URLRequestFailedJob::FailurePhase>(jphase), static_cast<int>(jnet_error))); return base::android::ConvertUTF8ToJavaString(jenv, url.spec()); } -ScopedJavaLocalRef<jstring> GetMockUrlForData(JNIEnv* jenv, - jclass jcaller, - jstring jdata, - jint jdata_repeat_count) { +ScopedJavaLocalRef<jstring> GetMockUrlForData( + JNIEnv* jenv, + const JavaParamRef<jclass>& jcaller, + const JavaParamRef<jstring>& jdata, + jint jdata_repeat_count) { std::string data(base::android::ConvertJavaStringToUTF8(jenv, jdata)); GURL url(net::URLRequestMockDataJob::GetMockHttpUrl(data, jdata_repeat_count)); return base::android::ConvertUTF8ToJavaString(jenv, url.spec()); } -ScopedJavaLocalRef<jstring> GetMockUrlForSSLCertificateError(JNIEnv* jenv, - jclass jcaller) { +ScopedJavaLocalRef<jstring> GetMockUrlForSSLCertificateError( + JNIEnv* jenv, + const JavaParamRef<jclass>& jcaller) { GURL url(net::SSLCertificateErrorJob::GetMockUrl()); return base::android::ConvertUTF8ToJavaString(jenv, url.spec()); } diff --git a/components/cronet/android/test/native_test_server.cc b/components/cronet/android/test/native_test_server.cc index 756442b..5c8c6d4 100644 --- a/components/cronet/android/test/native_test_server.cc +++ b/components/cronet/android/test/native_test_server.cc @@ -210,8 +210,8 @@ void RegisterHostResolverProcOnNetworkThreadLegacyAPI( } // namespace jboolean StartNativeTestServer(JNIEnv* env, - jclass jcaller, - jstring jtest_files_root) { + const JavaParamRef<jclass>& jcaller, + const JavaParamRef<jstring>& jtest_files_root) { // Shouldn't happen. if (g_test_server) return false; @@ -229,7 +229,7 @@ jboolean StartNativeTestServer(JNIEnv* env, } void RegisterHostResolverProc(JNIEnv* env, - jclass jcaller, + const JavaParamRef<jclass>& jcaller, jlong jadapter, jboolean jlegacy_api) { if (jlegacy_api == JNI_TRUE) { @@ -247,22 +247,26 @@ void RegisterHostResolverProc(JNIEnv* env, } } -void ShutdownNativeTestServer(JNIEnv* env, jclass jcaller) { +void ShutdownNativeTestServer(JNIEnv* env, + const JavaParamRef<jclass>& jcaller) { if (!g_test_server) return; delete g_test_server; g_test_server = NULL; } -ScopedJavaLocalRef<jstring> GetEchoBodyURL(JNIEnv* env, jclass jcaller) { +ScopedJavaLocalRef<jstring> GetEchoBodyURL( + JNIEnv* env, + const JavaParamRef<jclass>& jcaller) { DCHECK(g_test_server); GURL url = g_test_server->GetURL(kEchoBodyPath); return base::android::ConvertUTF8ToJavaString(env, url.spec()); } -ScopedJavaLocalRef<jstring> GetEchoHeaderURL(JNIEnv* env, - jclass jcaller, - jstring jheader) { +ScopedJavaLocalRef<jstring> GetEchoHeaderURL( + JNIEnv* env, + const JavaParamRef<jclass>& jcaller, + const JavaParamRef<jstring>& jheader) { DCHECK(g_test_server); GURL url = g_test_server->GetURL(kEchoHeaderPath); GURL::Replacements replacements; @@ -272,48 +276,58 @@ ScopedJavaLocalRef<jstring> GetEchoHeaderURL(JNIEnv* env, return base::android::ConvertUTF8ToJavaString(env, url.spec()); } -ScopedJavaLocalRef<jstring> GetEchoAllHeadersURL(JNIEnv* env, jclass jcaller) { +ScopedJavaLocalRef<jstring> GetEchoAllHeadersURL( + JNIEnv* env, + const JavaParamRef<jclass>& jcaller) { DCHECK(g_test_server); GURL url = g_test_server->GetURL(kEchoAllHeadersPath); return base::android::ConvertUTF8ToJavaString(env, url.spec()); } -ScopedJavaLocalRef<jstring> GetEchoMethodURL(JNIEnv* env, jclass jcaller) { +ScopedJavaLocalRef<jstring> GetEchoMethodURL( + JNIEnv* env, + const JavaParamRef<jclass>& jcaller) { DCHECK(g_test_server); GURL url = g_test_server->GetURL(kEchoMethodPath); return base::android::ConvertUTF8ToJavaString(env, url.spec()); } -ScopedJavaLocalRef<jstring> GetRedirectToEchoBody(JNIEnv* env, jclass jcaller) { +ScopedJavaLocalRef<jstring> GetRedirectToEchoBody( + JNIEnv* env, + const JavaParamRef<jclass>& jcaller) { DCHECK(g_test_server); GURL url = g_test_server->GetURL(kRedirectToEchoBodyPath); return base::android::ConvertUTF8ToJavaString(env, url.spec()); } -ScopedJavaLocalRef<jstring> GetFileURL(JNIEnv* env, - jclass jcaller, - jstring jfile_path) { +ScopedJavaLocalRef<jstring> GetFileURL( + JNIEnv* env, + const JavaParamRef<jclass>& jcaller, + const JavaParamRef<jstring>& jfile_path) { DCHECK(g_test_server); std::string file = base::android::ConvertJavaStringToUTF8(env, jfile_path); GURL url = g_test_server->GetURL(file); return base::android::ConvertUTF8ToJavaString(env, url.spec()); } -ScopedJavaLocalRef<jstring> GetSdchURL(JNIEnv* env, jclass jcaller) { +ScopedJavaLocalRef<jstring> GetSdchURL(JNIEnv* env, + const JavaParamRef<jclass>& jcaller) { DCHECK(g_test_server); std::string url(base::StringPrintf("http://%s:%d", kFakeSdchDomain, g_test_server->port())); return base::android::ConvertUTF8ToJavaString(env, url); } -ScopedJavaLocalRef<jstring> GetHostPort(JNIEnv* env, jclass jcaller) { +ScopedJavaLocalRef<jstring> GetHostPort(JNIEnv* env, + const JavaParamRef<jclass>& jcaller) { DCHECK(g_test_server); std::string host_port = net::HostPortPair::FromURL(g_test_server->base_url()).ToString(); return base::android::ConvertUTF8ToJavaString(env, host_port); } -jboolean IsDataReductionProxySupported(JNIEnv* env, jclass jcaller) { +jboolean IsDataReductionProxySupported(JNIEnv* env, + const JavaParamRef<jclass>& jcaller) { #if defined(DATA_REDUCTION_PROXY_SUPPORT) return JNI_TRUE; #else diff --git a/components/cronet/android/test/network_change_notifier_util.cc b/components/cronet/android/test/network_change_notifier_util.cc index 07f41d7..b6444aa 100644 --- a/components/cronet/android/test/network_change_notifier_util.cc +++ b/components/cronet/android/test/network_change_notifier_util.cc @@ -45,7 +45,9 @@ class TestIPAddressObserver // Adds a TestIPAddressObserver to the list of IPAddressObservers, and returns // a boolean indicating whether the TestIPAddressObserver has received // notification when network changes. -static jboolean IsTestIPAddressObserverCalled(JNIEnv* jenv, jclass jcaller) { +static jboolean IsTestIPAddressObserverCalled( + JNIEnv* jenv, + const JavaParamRef<jclass>& jcaller) { // This method is called on a Java thread with no MessageLoop, but we need // one for the NetworkChangeNotifier to call the observer on. base::MessageLoop loop; diff --git a/components/cronet/android/test/quic_test_server.cc b/components/cronet/android/test/quic_test_server.cc index b26a90d..cb6d926 100644 --- a/components/cronet/android/test/quic_test_server.cc +++ b/components/cronet/android/test/quic_test_server.cc @@ -56,8 +56,8 @@ void ShutdownOnServerThread() { // Quic server is currently hardcoded to run on port 6121 of the localhost on // the device. void StartQuicTestServer(JNIEnv* env, - jclass /*jcaller*/, - jstring jtest_files_root) { + const JavaParamRef<jclass>& /*jcaller*/, + const JavaParamRef<jstring>& jtest_files_root) { DCHECK(!g_quic_server_thread); g_quic_server_thread = new base::Thread("quic server thread"); base::Thread::Options thread_options; @@ -70,18 +70,21 @@ void StartQuicTestServer(JNIEnv* env, FROM_HERE, base::Bind(&ServeFilesFromDirectory, test_files_root)); } -void ShutdownQuicTestServer(JNIEnv* env, jclass /*jcaller*/) { +void ShutdownQuicTestServer(JNIEnv* env, + const JavaParamRef<jclass>& /*jcaller*/) { DCHECK(!g_quic_server_thread->task_runner()->BelongsToCurrentThread()); g_quic_server_thread->task_runner()->PostTask( FROM_HERE, base::Bind(&ShutdownOnServerThread)); delete g_quic_server_thread; } -ScopedJavaLocalRef<jstring> GetServerHost(JNIEnv* env, jclass /*jcaller*/) { +ScopedJavaLocalRef<jstring> GetServerHost( + JNIEnv* env, + const JavaParamRef<jclass>& /*jcaller*/) { return base::android::ConvertUTF8ToJavaString(env, kServerHost); } -int GetServerPort(JNIEnv* env, jclass /*jcaller*/) { +int GetServerPort(JNIEnv* env, const JavaParamRef<jclass>& /*jcaller*/) { return kServerPort; } diff --git a/components/cronet/android/test/sdch_test_util.cc b/components/cronet/android/test/sdch_test_util.cc index e794e25..1aef480 100644 --- a/components/cronet/android/test/sdch_test_util.cc +++ b/components/cronet/android/test/sdch_test_util.cc @@ -100,8 +100,8 @@ void AddSdchObserverOnNetworkThreadLegacyAPI( } // namespace void AddSdchObserver(JNIEnv* env, - jobject jsdch_observer, - jstring jtarget_url, + const JavaParamRef<jobject>& jsdch_observer, + const JavaParamRef<jstring>& jtarget_url, jlong jadapter) { base::android::ScopedJavaGlobalRef<jobject> jsdch_observer_ref; // ScopedJavaGlobalRef do not hold onto the env reference, so it is safe to @@ -119,8 +119,8 @@ void AddSdchObserver(JNIEnv* env, } void AddSdchObserverLegacyAPI(JNIEnv* env, - jobject jsdch_observer, - jstring jtarget_url, + const JavaParamRef<jobject>& jsdch_observer, + const JavaParamRef<jstring>& jtarget_url, jlong jadapter) { base::android::ScopedJavaGlobalRef<jobject> jsdch_observer_ref; // ScopedJavaGlobalRef do not hold onto the env reference, so it is safe to diff --git a/components/cronet/android/test/test_upload_data_stream_handler.cc b/components/cronet/android/test/test_upload_data_stream_handler.cc index 1c3e683..5658e9e 100644 --- a/components/cronet/android/test/test_upload_data_stream_handler.cc +++ b/components/cronet/android/test/test_upload_data_stream_handler.cc @@ -169,7 +169,7 @@ void TestUploadDataStreamHandler::NotifyJavaReadCompleted() { static jlong CreateTestUploadDataStreamHandler( JNIEnv* env, - jobject jtest_upload_data_stream_handler, + const JavaParamRef<jobject>& jtest_upload_data_stream_handler, jlong jupload_data_stream) { scoped_ptr<net::UploadDataStream> upload_data_stream( reinterpret_cast<net::UploadDataStream*>(jupload_data_stream)); diff --git a/components/dom_distiller/content/browser/distillable_page_utils_android.cc b/components/dom_distiller/content/browser/distillable_page_utils_android.cc index bf1f80d..56dfffa 100644 --- a/components/dom_distiller/content/browser/distillable_page_utils_android.cc +++ b/components/dom_distiller/content/browser/distillable_page_utils_android.cc @@ -25,10 +25,10 @@ void OnIsPageDistillableResult( } // namespace static void IsPageDistillable(JNIEnv* env, - jclass jcaller, - jobject webContents, + const JavaParamRef<jclass>& jcaller, + const JavaParamRef<jobject>& webContents, jboolean is_mobile_optimized, - jobject callback) { + const JavaParamRef<jobject>& callback) { content::WebContents* web_contents( content::WebContents::FromJavaWebContents(webContents)); scoped_ptr<ScopedJavaGlobalRef<jobject>> callback_holder( diff --git a/components/dom_distiller/core/distilled_page_prefs_android.cc b/components/dom_distiller/core/distilled_page_prefs_android.cc index 051d821c..50adbd0 100644 --- a/components/dom_distiller/core/distilled_page_prefs_android.cc +++ b/components/dom_distiller/core/distilled_page_prefs_android.cc @@ -42,7 +42,9 @@ jint DistilledPagePrefsAndroid::GetTheme(JNIEnv* env, jobject obj) { return (int) distilled_page_prefs_->GetTheme(); } -jlong Init(JNIEnv* env, jobject obj, jlong distilled_page_prefs_ptr) { +jlong Init(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jlong distilled_page_prefs_ptr) { DistilledPagePrefs* distilled_page_prefs = reinterpret_cast<DistilledPagePrefs*>(distilled_page_prefs_ptr); DistilledPagePrefsAndroid* distilled_page_prefs_android = @@ -97,7 +99,7 @@ void DistilledPagePrefsObserverAndroid::OnChangeTheme( env, java_ref_.obj(), (int)new_theme); } -jlong InitObserverAndroid(JNIEnv* env, jobject obj) { +jlong InitObserverAndroid(JNIEnv* env, const JavaParamRef<jobject>& obj) { DistilledPagePrefsObserverAndroid* observer_android = new DistilledPagePrefsObserverAndroid(env, obj); return reinterpret_cast<intptr_t>(observer_android); diff --git a/components/dom_distiller/core/url_utils_android.cc b/components/dom_distiller/core/url_utils_android.cc index 9ddf8ee..fc38786 100644 --- a/components/dom_distiller/core/url_utils_android.cc +++ b/components/dom_distiller/core/url_utils_android.cc @@ -19,10 +19,11 @@ namespace url_utils { namespace android { -ScopedJavaLocalRef<jstring> GetDistillerViewUrlFromUrl(JNIEnv* env, - jclass clazz, - jstring j_scheme, - jstring j_url) { +ScopedJavaLocalRef<jstring> GetDistillerViewUrlFromUrl( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& j_scheme, + const JavaParamRef<jstring>& j_url) { std::string scheme(base::android::ConvertJavaStringToUTF8(env, j_scheme)); GURL url(base::android::ConvertJavaStringToUTF8(env, j_url)); if (!url.is_valid()) { @@ -36,9 +37,10 @@ ScopedJavaLocalRef<jstring> GetDistillerViewUrlFromUrl(JNIEnv* env, return base::android::ConvertUTF8ToJavaString(env, view_url.spec()); } -ScopedJavaLocalRef<jstring> GetOriginalUrlFromDistillerUrl(JNIEnv* env, - jclass clazz, - jstring j_url) { +ScopedJavaLocalRef<jstring> GetOriginalUrlFromDistillerUrl( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& j_url) { GURL url(base::android::ConvertJavaStringToUTF8(env, j_url)); if (!url.is_valid()) return ScopedJavaLocalRef<jstring>(); @@ -51,25 +53,32 @@ ScopedJavaLocalRef<jstring> GetOriginalUrlFromDistillerUrl(JNIEnv* env, return base::android::ConvertUTF8ToJavaString(env, original_url.spec()); } -jboolean IsDistilledPage(JNIEnv* env, jclass clazz, jstring j_url) { +jboolean IsDistilledPage(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& j_url) { GURL url(base::android::ConvertJavaStringToUTF8(env, j_url)); return dom_distiller::url_utils::IsDistilledPage(url); } -jboolean IsUrlDistillable(JNIEnv* env, jclass clazz, jstring j_url) { +jboolean IsUrlDistillable(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& j_url) { GURL url(base::android::ConvertJavaStringToUTF8(env, j_url)); return dom_distiller::url_utils::IsUrlDistillable(url); } -ScopedJavaLocalRef<jstring> GetIsDistillableJs(JNIEnv* env, jclass clazz) { +ScopedJavaLocalRef<jstring> GetIsDistillableJs( + JNIEnv* env, + const JavaParamRef<jclass>& clazz) { return base::android::ConvertUTF8ToJavaString( env, dom_distiller::url_utils::GetIsDistillableJs()); } -ScopedJavaLocalRef<jstring> GetValueForKeyInUrl(JNIEnv* env, - jclass clazz, - jstring j_url, - jstring j_key) { +ScopedJavaLocalRef<jstring> GetValueForKeyInUrl( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& j_url, + const JavaParamRef<jstring>& j_key) { GURL url(base::android::ConvertJavaStringToUTF8(env, j_url)); std::string key = base::android::ConvertJavaStringToUTF8(env, j_key); return base::android::ConvertUTF8ToJavaString( diff --git a/components/safe_json/json_sanitizer_android.cc b/components/safe_json/json_sanitizer_android.cc index 9ccad08..7b07d21 100644 --- a/components/safe_json/json_sanitizer_android.cc +++ b/components/safe_json/json_sanitizer_android.cc @@ -84,13 +84,19 @@ void JsonSanitizerAndroid::OnError(const std::string& error) { } // namespace -void OnSuccess(JNIEnv* env, jclass clazz, jlong jsanitizer, jstring json) { +void OnSuccess(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + jlong jsanitizer, + const JavaParamRef<jstring>& json) { JsonSanitizerAndroid* sanitizer = reinterpret_cast<JsonSanitizerAndroid*>(jsanitizer); sanitizer->OnSuccess(base::android::ConvertJavaStringToUTF8(env, json)); } -void OnError(JNIEnv* env, jclass clazz, jlong jsanitizer, jstring error) { +void OnError(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + jlong jsanitizer, + const JavaParamRef<jstring>& error) { JsonSanitizerAndroid* sanitizer = reinterpret_cast<JsonSanitizerAndroid*>(jsanitizer); sanitizer->OnError(base::android::ConvertJavaStringToUTF8(env, error)); diff --git a/components/service_tab_launcher/browser/android/service_tab_launcher.cc b/components/service_tab_launcher/browser/android/service_tab_launcher.cc index 7a1bc0f..8408e6b 100644 --- a/components/service_tab_launcher/browser/android/service_tab_launcher.cc +++ b/components/service_tab_launcher/browser/android/service_tab_launcher.cc @@ -17,7 +17,10 @@ using base::android::GetApplicationContext; // Called by Java when the WebContents instance for a request Id is available. void OnWebContentsForRequestAvailable( - JNIEnv* env, jclass clazz, jint request_id, jobject android_web_contents) { + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + jint request_id, + const JavaParamRef<jobject>& android_web_contents) { service_tab_launcher::ServiceTabLauncher::GetInstance()->OnTabLaunched( request_id, content::WebContents::FromJavaWebContents(android_web_contents)); diff --git a/components/signin/core/browser/child_account_info_fetcher_android.cc b/components/signin/core/browser/child_account_info_fetcher_android.cc index 8b30e12..39ec8c4 100644 --- a/components/signin/core/browser/child_account_info_fetcher_android.cc +++ b/components/signin/core/browser/child_account_info_fetcher_android.cc @@ -33,9 +33,9 @@ bool ChildAccountInfoFetcherAndroid::Register(JNIEnv* env) { } void SetIsChildAccount(JNIEnv* env, - jclass caller, + const JavaParamRef<jclass>& caller, jlong native_service, - jstring j_account_id, + const JavaParamRef<jstring>& j_account_id, jboolean is_child_account) { AccountFetcherService* service = reinterpret_cast<AccountFetcherService*>(native_service); diff --git a/components/variations/android/variations_associated_data_android.cc b/components/variations/android/variations_associated_data_android.cc index 7bd2800..0693f20 100644 --- a/components/variations/android/variations_associated_data_android.cc +++ b/components/variations/android/variations_associated_data_android.cc @@ -17,10 +17,11 @@ namespace variations { namespace android { -ScopedJavaLocalRef<jstring> GetVariationParamValue(JNIEnv* env, - jclass clazz, - jstring jtrial_name, - jstring jparam_name) { +ScopedJavaLocalRef<jstring> GetVariationParamValue( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jtrial_name, + const JavaParamRef<jstring>& jparam_name) { std::string trial_name(ConvertJavaStringToUTF8(env, jtrial_name)); std::string param_name(ConvertJavaStringToUTF8(env, jparam_name)); std::string param_value = diff --git a/content/app/android/child_process_service.cc b/content/app/android/child_process_service.cc index d3e6a1b..68bf0c0 100644 --- a/content/app/android/child_process_service.cc +++ b/content/app/android/child_process_service.cc @@ -149,7 +149,7 @@ void InternalInitChildProcess(JNIEnv* env, } // namespace <anonymous> void RegisterGlobalFileDescriptor(JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jint id, jint fd, jlong offset, @@ -159,14 +159,14 @@ void RegisterGlobalFileDescriptor(JNIEnv* env, } void InitChildProcess(JNIEnv* env, - jclass clazz, - jobject service, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& service, jint cpu_count, jlong cpu_features) { InternalInitChildProcess(env, clazz, service, cpu_count, cpu_features); } -void ExitChildProcess(JNIEnv* env, jclass clazz) { +void ExitChildProcess(JNIEnv* env, const JavaParamRef<jclass>& clazz) { VLOG(0) << "ChildProcessService: Exiting child process."; base::android::LibraryLoaderExitHook(); _exit(0); @@ -176,7 +176,7 @@ bool RegisterChildProcessService(JNIEnv* env) { return RegisterNativesImpl(env); } -void ShutdownMainThread(JNIEnv* env, jobject obj) { +void ShutdownMainThread(JNIEnv* env, const JavaParamRef<jobject>& obj) { ChildThreadImpl::ShutdownThread(); } diff --git a/content/app/android/content_main.cc b/content/app/android/content_main.cc index 13f20b6..986474f 100644 --- a/content/app/android/content_main.cc +++ b/content/app/android/content_main.cc @@ -28,13 +28,15 @@ LazyInstance<scoped_ptr<ContentMainDelegate> > g_content_main_delegate = } // namespace -static void InitApplicationContext(JNIEnv* env, jclass clazz, jobject context) { +static void InitApplicationContext(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& context) { base::android::ScopedJavaLocalRef<jobject> scoped_context( env, env->NewLocalRef(context)); base::android::InitApplicationContext(env, scoped_context); } -static jint Start(JNIEnv* env, jclass clazz) { +static jint Start(JNIEnv* env, const JavaParamRef<jclass>& clazz) { TRACE_EVENT0("startup", "content::Start"); // On Android we can have multiple requests to start the browser in process diff --git a/content/browser/android/browser_startup_controller.cc b/content/browser/android/browser_startup_controller.cc index 74e38e6..124b519 100644 --- a/content/browser/android/browser_startup_controller.cc +++ b/content/browser/android/browser_startup_controller.cc @@ -26,10 +26,11 @@ bool RegisterBrowserStartupController(JNIEnv* env) { return RegisterNativesImpl(env); } -static void SetCommandLineFlags(JNIEnv* env, - jclass clazz, - jboolean single_process, - jstring plugin_descriptor) { +static void SetCommandLineFlags( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + jboolean single_process, + const JavaParamRef<jstring>& plugin_descriptor) { std::string plugin_str = (plugin_descriptor == NULL ? std::string() @@ -37,7 +38,8 @@ static void SetCommandLineFlags(JNIEnv* env, SetContentCommandLineFlags(static_cast<bool>(single_process), plugin_str); } -static jboolean IsOfficialBuild(JNIEnv* env, jclass clazz) { +static jboolean IsOfficialBuild(JNIEnv* env, + const JavaParamRef<jclass>& clazz) { #if defined(OFFICIAL_BUILD) return true; #else @@ -45,7 +47,8 @@ static jboolean IsOfficialBuild(JNIEnv* env, jclass clazz) { #endif } -static jboolean IsPluginEnabled(JNIEnv* env, jclass clazz) { +static jboolean IsPluginEnabled(JNIEnv* env, + const JavaParamRef<jclass>& clazz) { #if defined(ENABLE_PLUGINS) return true; #else diff --git a/content/browser/android/child_process_launcher_android.cc b/content/browser/android/child_process_launcher_android.cc index 3b0473a..44e1bd3 100644 --- a/content/browser/android/child_process_launcher_android.cc +++ b/content/browser/android/child_process_launcher_android.cc @@ -89,7 +89,7 @@ static void SetSurfacePeer( // |handle| is the processID of the child process as originated in Java, 0 if // the ChildProcess could not be created. static void OnChildProcessStarted(JNIEnv*, - jclass, + const JavaParamRef<jclass>&, jlong client_context, jint handle) { StartChildProcessCallback* callback = @@ -169,9 +169,12 @@ void SetChildProcessInForeground(base::ProcessHandle handle, static_cast<jint>(handle), static_cast<jboolean>(in_foreground)); } -void EstablishSurfacePeer( - JNIEnv* env, jclass clazz, - jint pid, jobject surface, jint primary_id, jint secondary_id) { +void EstablishSurfacePeer(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + jint pid, + const JavaParamRef<jobject>& surface, + jint primary_id, + jint secondary_id) { ScopedJavaGlobalRef<jobject> jsurface; jsurface.Reset(env, surface); if (jsurface.is_null()) @@ -222,7 +225,7 @@ gfx::ScopedJavaSurface GetSurfaceTextureSurface(int surface_texture_id, env, surface_texture_id, client_id).obj()); } -jboolean IsSingleProcess(JNIEnv* env, jclass clazz) { +jboolean IsSingleProcess(JNIEnv* env, const JavaParamRef<jclass>& clazz) { return base::CommandLine::ForCurrentProcess()->HasSwitch( switches::kSingleProcess); } diff --git a/content/browser/android/content_readback_handler.cc b/content/browser/android/content_readback_handler.cc index 6ff62e4..568b7d3 100644 --- a/content/browser/android/content_readback_handler.cc +++ b/content/browser/android/content_readback_handler.cc @@ -115,7 +115,7 @@ void ContentReadbackHandler::OnFinishReadback(int readback_id, } // static -static jlong Init(JNIEnv* env, jobject obj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { ContentReadbackHandler* content_readback_handler = new ContentReadbackHandler(env, obj); return reinterpret_cast<intptr_t>(content_readback_handler); diff --git a/content/browser/android/content_video_view.cc b/content/browser/android/content_video_view.cc index ef5369e..8a9eb42 100644 --- a/content/browser/android/content_video_view.cc +++ b/content/browser/android/content_video_view.cc @@ -31,8 +31,9 @@ ContentVideoView* g_content_video_view = NULL; } // namespace -static ScopedJavaLocalRef<jobject> GetSingletonJavaContentVideoView(JNIEnv* env, - jclass) { +static ScopedJavaLocalRef<jobject> GetSingletonJavaContentVideoView( + JNIEnv* env, + const JavaParamRef<jclass>&) { if (g_content_video_view) return g_content_video_view->GetJavaObject(env); else diff --git a/content/browser/android/content_view_core_impl.cc b/content/browser/android/content_view_core_impl.cc index a1a84e7..5997c99 100644 --- a/content/browser/android/content_view_core_impl.cc +++ b/content/browser/android/content_view_core_impl.cc @@ -1450,11 +1450,11 @@ void ContentViewCoreImpl::PullReset() { // This is called for each ContentView. jlong Init(JNIEnv* env, - jobject obj, - jobject web_contents, - jobject view_android_delegate, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& web_contents, + const JavaParamRef<jobject>& view_android_delegate, jlong window_android, - jobject retained_objects_set) { + const JavaParamRef<jobject>& retained_objects_set) { ContentViewCoreImpl* view = new ContentViewCoreImpl( env, obj, WebContents::FromJavaWebContents(web_contents), view_android_delegate, @@ -1463,8 +1463,10 @@ jlong Init(JNIEnv* env, return reinterpret_cast<intptr_t>(view); } -static ScopedJavaLocalRef<jobject> -FromWebContentsAndroid(JNIEnv* env, jclass clazz, jobject jweb_contents) { +static ScopedJavaLocalRef<jobject> FromWebContentsAndroid( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& jweb_contents) { WebContents* web_contents = WebContents::FromJavaWebContents(jweb_contents); if (!web_contents) return ScopedJavaLocalRef<jobject>(); diff --git a/content/browser/android/content_view_render_view.cc b/content/browser/android/content_view_render_view.cc index eb6a695..8b1ea2b 100644 --- a/content/browser/android/content_view_render_view.cc +++ b/content/browser/android/content_view_render_view.cc @@ -43,7 +43,7 @@ ContentViewRenderView::~ContentViewRenderView() { // static static jlong Init(JNIEnv* env, - jobject obj, + const JavaParamRef<jobject>& obj, jlong native_root_window) { gfx::NativeWindow root_window = reinterpret_cast<gfx::NativeWindow>(native_root_window); diff --git a/content/browser/android/content_view_statics.cc b/content/browser/android/content_view_statics.cc index 6040e64..e34ccf8 100644 --- a/content/browser/android/content_view_statics.cc +++ b/content/browser/android/content_view_statics.cc @@ -96,9 +96,10 @@ base::LazyInstance<SuspendedProcessWatcher> g_suspended_processes_watcher = } // namespace // Returns the first substring consisting of the address of a physical location. -static ScopedJavaLocalRef<jstring> FindAddress(JNIEnv* env, - jclass clazz, - jstring addr) { +static ScopedJavaLocalRef<jstring> FindAddress( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& addr) { base::string16 content_16 = ConvertJavaStringToUTF16(env, addr); base::string16 result_16; if (content::address_parser::FindAddress(content_16, &result_16)) @@ -107,7 +108,7 @@ static ScopedJavaLocalRef<jstring> FindAddress(JNIEnv* env, } static void SetWebKitSharedTimersSuspended(JNIEnv* env, - jclass obj, + const JavaParamRef<jclass>& obj, jboolean suspend) { if (suspend) { g_suspended_processes_watcher.Pointer()->SuspendWebKitSharedTimers(); diff --git a/content/browser/android/download_controller_android_impl.cc b/content/browser/android/download_controller_android_impl.cc index 5d21117..13037ca 100644 --- a/content/browser/android/download_controller_android_impl.cc +++ b/content/browser/android/download_controller_android_impl.cc @@ -99,12 +99,14 @@ void CreateContextMenuDownload(int render_process_id, namespace content { // JNI methods -static void Init(JNIEnv* env, jobject obj) { +static void Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { DownloadControllerAndroidImpl::GetInstance()->Init(env, obj); } -static void OnRequestFileAccessResult( - JNIEnv* env, jobject obj, jlong callback_id, jboolean granted) { +static void OnRequestFileAccessResult(JNIEnv* env, + const JavaParamRef<jobject>& obj, + jlong callback_id, + jboolean granted) { DCHECK_CURRENTLY_ON(BrowserThread::UI); DCHECK(callback_id); diff --git a/content/browser/android/interstitial_page_delegate_android.cc b/content/browser/android/interstitial_page_delegate_android.cc index f598cd3..ce727ef 100644 --- a/content/browser/android/interstitial_page_delegate_android.cc +++ b/content/browser/android/interstitial_page_delegate_android.cc @@ -84,7 +84,9 @@ bool InterstitialPageDelegateAndroid return RegisterNativesImpl(env); } -static jlong Init(JNIEnv* env, jobject obj, jstring html_content) { +static jlong Init(JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jstring>& html_content) { InterstitialPageDelegateAndroid* delegate = new InterstitialPageDelegateAndroid( env, obj, base::android::ConvertJavaStringToUTF8(env, html_content)); diff --git a/content/browser/android/load_url_params.cc b/content/browser/android/load_url_params.cc index 67802ea..2f08725 100644 --- a/content/browser/android/load_url_params.cc +++ b/content/browser/android/load_url_params.cc @@ -18,7 +18,9 @@ bool RegisterLoadUrlParams(JNIEnv* env) { return RegisterNativesImpl(env); } -jboolean IsDataScheme(JNIEnv* env, jclass clazz, jstring jurl) { +jboolean IsDataScheme(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jurl) { GURL url(base::android::ConvertJavaStringToUTF8(env, jurl)); return url.SchemeIs(url::kDataScheme); } diff --git a/content/browser/android/tracing_controller_android.cc b/content/browser/android/tracing_controller_android.cc index ac814d1..0aeeda7 100644 --- a/content/browser/android/tracing_controller_android.cc +++ b/content/browser/android/tracing_controller_android.cc @@ -14,7 +14,7 @@ namespace content { -static jlong Init(JNIEnv* env, jobject obj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { TracingControllerAndroid* profiler = new TracingControllerAndroid(env, obj); return reinterpret_cast<intptr_t>(profiler); } @@ -102,8 +102,9 @@ void TracingControllerAndroid::OnKnownCategoriesReceived( LOG(WARNING) << "{\"traceCategoriesList\": " << received_category_list << "}"; } -static ScopedJavaLocalRef<jstring> GetDefaultCategories(JNIEnv* env, - jobject obj) { +static ScopedJavaLocalRef<jstring> GetDefaultCategories( + JNIEnv* env, + const JavaParamRef<jobject>& obj) { base::trace_event::TraceConfig trace_config; return base::android::ConvertUTF8ToJavaString( env, trace_config.ToCategoryFilterString()); diff --git a/content/browser/android/web_contents_observer_proxy.cc b/content/browser/android/web_contents_observer_proxy.cc index f5ef696..c04f926 100644 --- a/content/browser/android/web_contents_observer_proxy.cc +++ b/content/browser/android/web_contents_observer_proxy.cc @@ -36,7 +36,9 @@ WebContentsObserverProxy::WebContentsObserverProxy(JNIEnv* env, WebContentsObserverProxy::~WebContentsObserverProxy() { } -jlong Init(JNIEnv* env, jobject obj, jobject java_web_contents) { +jlong Init(JNIEnv* env, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jobject>& java_web_contents) { WebContents* web_contents = WebContents::FromJavaWebContents(java_web_contents); CHECK(web_contents); diff --git a/content/browser/gamepad/gamepad_platform_data_fetcher_android.cc b/content/browser/gamepad/gamepad_platform_data_fetcher_android.cc index 46df9e5..471a041 100644 --- a/content/browser/gamepad/gamepad_platform_data_fetcher_android.cc +++ b/content/browser/gamepad/gamepad_platform_data_fetcher_android.cc @@ -63,15 +63,15 @@ void GamepadPlatformDataFetcherAndroid::PauseHint(bool paused) { } static void SetGamepadData(JNIEnv* env, - jobject obj, + const JavaParamRef<jobject>& obj, jlong gamepads, jint index, jboolean mapping, jboolean connected, - jstring devicename, + const JavaParamRef<jstring>& devicename, jlong timestamp, - jfloatArray jaxes, - jfloatArray jbuttons) { + const JavaParamRef<jfloatArray>& jaxes, + const JavaParamRef<jfloatArray>& jbuttons) { DCHECK(gamepads); blink::WebGamepads* pads = reinterpret_cast<WebGamepads*>(gamepads); DCHECK_EQ(pads->length, unsigned(index)); diff --git a/content/browser/geolocation/location_api_adapter_android.cc b/content/browser/geolocation/location_api_adapter_android.cc index a78cae2..9732678 100644 --- a/content/browser/geolocation/location_api_adapter_android.cc +++ b/content/browser/geolocation/location_api_adapter_android.cc @@ -17,20 +17,27 @@ using base::android::CheckException; using base::android::ClearException; using content::AndroidLocationApiAdapter; -static void NewLocationAvailable(JNIEnv* env, jclass, +static void NewLocationAvailable(JNIEnv* env, + const JavaParamRef<jclass>&, jdouble latitude, jdouble longitude, jdouble time_stamp, - jboolean has_altitude, jdouble altitude, - jboolean has_accuracy, jdouble accuracy, - jboolean has_heading, jdouble heading, - jboolean has_speed, jdouble speed) { + jboolean has_altitude, + jdouble altitude, + jboolean has_accuracy, + jdouble accuracy, + jboolean has_heading, + jdouble heading, + jboolean has_speed, + jdouble speed) { AndroidLocationApiAdapter::OnNewLocationAvailable(latitude, longitude, time_stamp, has_altitude, altitude, has_accuracy, accuracy, has_heading, heading, has_speed, speed); } -static void NewErrorAvailable(JNIEnv* env, jclass, jstring message) { +static void NewErrorAvailable(JNIEnv* env, + const JavaParamRef<jclass>&, + const JavaParamRef<jstring>& message) { AndroidLocationApiAdapter::OnNewErrorAvailable(env, message); } diff --git a/content/browser/media/android/media_drm_credential_manager.cc b/content/browser/media/android/media_drm_credential_manager.cc index 50d6653..d2e6dec 100644 --- a/content/browser/media/android/media_drm_credential_manager.cc +++ b/content/browser/media/android/media_drm_credential_manager.cc @@ -60,8 +60,8 @@ void MediaDrmCredentialManager::ResetCredentials( // static void ResetCredentials( JNIEnv* env, - jclass clazz, - jobject j_media_drm_credential_manager_callback) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& j_media_drm_credential_manager_callback) { MediaDrmCredentialManager* media_drm_credential_manager = MediaDrmCredentialManager::GetInstance(); diff --git a/content/browser/renderer_host/ime_adapter_android.cc b/content/browser/renderer_host/ime_adapter_android.cc index 88b1e12..f9519c0 100644 --- a/content/browser/renderer_host/ime_adapter_android.cc +++ b/content/browser/renderer_host/ime_adapter_android.cc @@ -72,7 +72,7 @@ bool RegisterImeAdapter(JNIEnv* env) { // Callback from Java to convert BackgroundColorSpan data to a // blink::WebCompositionUnderline instance, and append it to |underlines_ptr|. void AppendBackgroundColorSpan(JNIEnv*, - jclass, + const JavaParamRef<jclass>&, jlong underlines_ptr, jint start, jint end, @@ -94,7 +94,7 @@ void AppendBackgroundColorSpan(JNIEnv*, // Callback from Java to convert UnderlineSpan data to a // blink::WebCompositionUnderline instance, and append it to |underlines_ptr|. void AppendUnderlineSpan(JNIEnv*, - jclass, + const JavaParamRef<jclass>&, jlong underlines_ptr, jint start, jint end) { diff --git a/content/browser/web_contents/web_contents_android.cc b/content/browser/web_contents/web_contents_android.cc index 0131bf9..ff58da2 100644 --- a/content/browser/web_contents/web_contents_android.cc +++ b/content/browser/web_contents/web_contents_android.cc @@ -156,7 +156,7 @@ WebContents* WebContents::FromJavaWebContents( // static static void DestroyWebContents(JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jlong jweb_contents_android_ptr) { WebContentsAndroid* web_contents_android = reinterpret_cast<WebContentsAndroid*>(jweb_contents_android_ptr); @@ -172,7 +172,7 @@ static void DestroyWebContents(JNIEnv* env, // static ScopedJavaLocalRef<jobject> FromNativePtr(JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jlong web_contents_ptr) { WebContentsAndroid* web_contents_android = reinterpret_cast<WebContentsAndroid*>(web_contents_ptr); diff --git a/content/shell/android/linker_test_apk/chromium_linker_test_linker_tests.cc b/content/shell/android/linker_test_apk/chromium_linker_test_linker_tests.cc index 167d926..6a45851 100644 --- a/content/shell/android/linker_test_apk/chromium_linker_test_linker_tests.cc +++ b/content/shell/android/linker_test_apk/chromium_linker_test_linker_tests.cc @@ -196,13 +196,13 @@ jboolean RunChecks(bool in_browser_process, bool need_relros) { } // namespace jboolean CheckForSharedRelros(JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jboolean in_browser_process) { return RunChecks(in_browser_process, true); } jboolean CheckForNoSharedRelros(JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jboolean in_browser_process) { return RunChecks(in_browser_process, false); } diff --git a/content/shell/android/shell_manager.cc b/content/shell/android/shell_manager.cc index b262c88..eb9e636 100644 --- a/content/shell/android/shell_manager.cc +++ b/content/shell/android/shell_manager.cc @@ -49,12 +49,16 @@ bool RegisterShellManager(JNIEnv* env) { return RegisterNativesImpl(env); } -static void Init(JNIEnv* env, jclass clazz, jobject obj) { +static void Init(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& obj) { g_global_state.Get().j_shell_manager.Reset( base::android::ScopedJavaLocalRef<jobject>(env, obj)); } -void LaunchShell(JNIEnv* env, jclass clazz, jstring jurl) { +void LaunchShell(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jurl) { ShellBrowserContext* browserContext = ShellContentBrowserClient::Get()->browser_context(); GURL url(base::android::ConvertJavaStringToUTF8(env, jurl)); diff --git a/content/shell/browser/shell_android.cc b/content/shell/browser/shell_android.cc index 6139c8d..b1a2348 100644 --- a/content/shell/browser/shell_android.cc +++ b/content/shell/browser/shell_android.cc @@ -104,7 +104,9 @@ bool Shell::Register(JNIEnv* env) { } // static -void CloseShell(JNIEnv* env, jclass clazz, jlong shellPtr) { +void CloseShell(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + jlong shellPtr) { Shell* shell = reinterpret_cast<Shell*>(shellPtr); shell->Close(); } diff --git a/content/shell/browser/shell_mojo_test_utils_android.cc b/content/shell/browser/shell_mojo_test_utils_android.cc index 04d3ad6..ba8f5e9 100644 --- a/content/shell/browser/shell_mojo_test_utils_android.cc +++ b/content/shell/browser/shell_mojo_test_utils_android.cc @@ -23,19 +23,20 @@ struct TestEnvironment { namespace content { -static jlong SetupTestEnvironment(JNIEnv* env, jclass jcaller) { +static jlong SetupTestEnvironment(JNIEnv* env, + const JavaParamRef<jclass>& jcaller) { return reinterpret_cast<intptr_t>(new TestEnvironment()); } static void TearDownTestEnvironment(JNIEnv* env, - jclass jcaller, + const JavaParamRef<jclass>& jcaller, jlong test_environment) { delete reinterpret_cast<TestEnvironment*>(test_environment); } static ScopedJavaLocalRef<jobject> CreateServiceRegistryPair( JNIEnv* env, - jclass jcaller, + const JavaParamRef<jclass>& jcaller, jlong native_test_environment) { TestEnvironment* test_environment = reinterpret_cast<TestEnvironment*>(native_test_environment); @@ -64,7 +65,9 @@ static ScopedJavaLocalRef<jobject> CreateServiceRegistryPair( wrapper_b->GetObj().obj()); } -static void RunLoop(JNIEnv* env, jclass jcaller, jlong timeout_ms) { +static void RunLoop(JNIEnv* env, + const JavaParamRef<jclass>& jcaller, + jlong timeout_ms) { base::MessageLoop::current()->PostDelayedTask( FROM_HERE, base::MessageLoop::QuitClosure(), diff --git a/mandoline/app/android/mandoline_activity.cc b/mandoline/app/android/mandoline_activity.cc index f7e19f6..0d05724 100644 --- a/mandoline/app/android/mandoline_activity.cc +++ b/mandoline/app/android/mandoline_activity.cc @@ -10,7 +10,9 @@ namespace mandoline { -static void LaunchURL(JNIEnv* env, jclass clazz, jstring jurl) { +static void LaunchURL(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jurl) { LaunchHandlerPtr launch_handler; mojo::runner::GetContext()->application_manager()->ConnectToService( GURL("mojo:phone_ui"), &launch_handler); diff --git a/mojo/android/javatests/mojo_test_case.cc b/mojo/android/javatests/mojo_test_case.cc index 3408227..1297a04 100644 --- a/mojo/android/javatests/mojo_test_case.cc +++ b/mojo/android/javatests/mojo_test_case.cc @@ -31,24 +31,27 @@ namespace mojo { namespace android { static void InitApplicationContext(JNIEnv* env, - jobject jcaller, - jobject context) { + const JavaParamRef<jobject>& jcaller, + const JavaParamRef<jobject>& context) { base::android::ScopedJavaLocalRef<jobject> scoped_context(env, context); base::android::InitApplicationContext(env, scoped_context); base::InitAndroidTestMessageLoop(); } -static jlong SetupTestEnvironment(JNIEnv* env, jobject jcaller) { +static jlong SetupTestEnvironment(JNIEnv* env, + const JavaParamRef<jobject>& jcaller) { return reinterpret_cast<intptr_t>(new TestEnvironment()); } static void TearDownTestEnvironment(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong test_environment) { delete reinterpret_cast<TestEnvironment*>(test_environment); } -static void RunLoop(JNIEnv* env, jobject jcaller, jlong timeout_ms) { +static void RunLoop(JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jlong timeout_ms) { base::RunLoop run_loop; if (timeout_ms) { base::MessageLoop::current()->PostDelayedTask( diff --git a/mojo/android/javatests/validation_test_util.cc b/mojo/android/javatests/validation_test_util.cc index dec90cc3..1fb0abf 100644 --- a/mojo/android/javatests/validation_test_util.cc +++ b/mojo/android/javatests/validation_test_util.cc @@ -18,9 +18,10 @@ bool RegisterValidationTestUtil(JNIEnv* env) { return RegisterNativesImpl(env); } -ScopedJavaLocalRef<jobject> ParseData(JNIEnv* env, - jclass jcaller, - jstring data_as_string) { +ScopedJavaLocalRef<jobject> ParseData( + JNIEnv* env, + const JavaParamRef<jclass>& jcaller, + const JavaParamRef<jstring>& data_as_string) { std::string input = base::android::ConvertJavaStringToUTF8(env, data_as_string); std::vector<uint8_t> data; diff --git a/mojo/android/system/base_run_loop.cc b/mojo/android/system/base_run_loop.cc index 2bc2fb4..df78561b 100644 --- a/mojo/android/system/base_run_loop.cc +++ b/mojo/android/system/base_run_loop.cc @@ -17,21 +17,28 @@ namespace mojo { namespace android { -static jlong CreateBaseRunLoop(JNIEnv* env, jobject jcaller) { +static jlong CreateBaseRunLoop(JNIEnv* env, + const JavaParamRef<jobject>& jcaller) { base::MessageLoop* message_loop = new base::MessageLoop(common::MessagePumpMojo::Create()); return reinterpret_cast<uintptr_t>(message_loop); } -static void Run(JNIEnv* env, jobject jcaller, jlong runLoopID) { +static void Run(JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jlong runLoopID) { reinterpret_cast<base::MessageLoop*>(runLoopID)->Run(); } -static void RunUntilIdle(JNIEnv* env, jobject jcaller, jlong runLoopID) { +static void RunUntilIdle(JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jlong runLoopID) { reinterpret_cast<base::MessageLoop*>(runLoopID)->RunUntilIdle(); } -static void Quit(JNIEnv* env, jobject jcaller, jlong runLoopID) { +static void Quit(JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jlong runLoopID) { reinterpret_cast<base::MessageLoop*>(runLoopID)->Quit(); } @@ -42,9 +49,9 @@ static void RunJavaRunnable( } static void PostDelayedTask(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong runLoopID, - jobject runnable, + const JavaParamRef<jobject>& runnable, jlong delay) { base::android::ScopedJavaGlobalRef<jobject> runnable_ref; // ScopedJavaGlobalRef do not hold onto the env reference, so it is safe to @@ -56,7 +63,9 @@ static void PostDelayedTask(JNIEnv* env, base::TimeDelta::FromMicroseconds(delay)); } -static void DeleteMessageLoop(JNIEnv* env, jobject jcaller, jlong runLoopID) { +static void DeleteMessageLoop(JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jlong runLoopID) { base::MessageLoop* message_loop = reinterpret_cast<base::MessageLoop*>(runLoopID); delete message_loop; diff --git a/mojo/android/system/core_impl.cc b/mojo/android/system/core_impl.cc index 6319116..2158987 100644 --- a/mojo/android/system/core_impl.cc +++ b/mojo/android/system/core_impl.cc @@ -49,13 +49,14 @@ void AsyncWaitCallback(void* data, MojoResult result) { namespace mojo { namespace android { -static jlong GetTimeTicksNow(JNIEnv* env, jobject jcaller) { +static jlong GetTimeTicksNow(JNIEnv* env, + const JavaParamRef<jobject>& jcaller) { return MojoGetTimeTicksNow(); } static jint WaitMany(JNIEnv* env, - jobject jcaller, - jobject buffer, + const JavaParamRef<jobject>& jcaller, + const JavaParamRef<jobject>& buffer, jlong deadline) { // |buffer| contains, in this order // input: The array of N handles (MojoHandle, 4 bytes each) @@ -88,9 +89,10 @@ static jint WaitMany(JNIEnv* env, result_index, states_start); } -static ScopedJavaLocalRef<jobject> CreateMessagePipe(JNIEnv* env, - jobject jcaller, - jobject options_buffer) { +static ScopedJavaLocalRef<jobject> CreateMessagePipe( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + const JavaParamRef<jobject>& options_buffer) { const MojoCreateMessagePipeOptions* options = NULL; if (options_buffer) { const void* buffer_start = env->GetDirectBufferAddress(options_buffer); @@ -107,9 +109,10 @@ static ScopedJavaLocalRef<jobject> CreateMessagePipe(JNIEnv* env, return Java_CoreImpl_newNativeCreationResult(env, result, handle1, handle2); } -static ScopedJavaLocalRef<jobject> CreateDataPipe(JNIEnv* env, - jobject jcaller, - jobject options_buffer) { +static ScopedJavaLocalRef<jobject> CreateDataPipe( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + const JavaParamRef<jobject>& options_buffer) { const MojoCreateDataPipeOptions* options = NULL; if (options_buffer) { const void* buffer_start = env->GetDirectBufferAddress(options_buffer); @@ -126,10 +129,11 @@ static ScopedJavaLocalRef<jobject> CreateDataPipe(JNIEnv* env, return Java_CoreImpl_newNativeCreationResult(env, result, handle1, handle2); } -static ScopedJavaLocalRef<jobject> CreateSharedBuffer(JNIEnv* env, - jobject jcaller, - jobject options_buffer, - jlong num_bytes) { +static ScopedJavaLocalRef<jobject> CreateSharedBuffer( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + const JavaParamRef<jobject>& options_buffer, + jlong num_bytes) { const MojoCreateSharedBufferOptions* options = 0; if (options_buffer) { const void* buffer_start = env->GetDirectBufferAddress(options_buffer); @@ -145,13 +149,15 @@ static ScopedJavaLocalRef<jobject> CreateSharedBuffer(JNIEnv* env, return Java_CoreImpl_newResultAndInteger(env, result, handle); } -static jint Close(JNIEnv* env, jobject jcaller, jint mojo_handle) { +static jint Close(JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jint mojo_handle) { return MojoClose(mojo_handle); } static jint Wait(JNIEnv* env, - jobject jcaller, - jobject buffer, + const JavaParamRef<jobject>& jcaller, + const JavaParamRef<jobject>& buffer, jint mojo_handle, jint signals, jlong deadline) { @@ -167,11 +173,11 @@ static jint Wait(JNIEnv* env, } static jint WriteMessage(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jint mojo_handle, - jobject bytes, + const JavaParamRef<jobject>& bytes, jint num_bytes, - jobject handles_buffer, + const JavaParamRef<jobject>& handles_buffer, jint flags) { const void* buffer_start = 0; uint32_t buffer_size = 0; @@ -193,12 +199,13 @@ static jint WriteMessage(JNIEnv* env, mojo_handle, buffer_start, buffer_size, handles, num_handles, flags); } -static ScopedJavaLocalRef<jobject> ReadMessage(JNIEnv* env, - jobject jcaller, - jint mojo_handle, - jobject bytes, - jobject handles_buffer, - jint flags) { +static ScopedJavaLocalRef<jobject> ReadMessage( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jint mojo_handle, + const JavaParamRef<jobject>& bytes, + const JavaParamRef<jobject>& handles_buffer, + jint flags) { void* buffer_start = 0; uint32_t buffer_size = 0; if (bytes) { @@ -220,12 +227,13 @@ static ScopedJavaLocalRef<jobject> ReadMessage(JNIEnv* env, num_handles); } -static ScopedJavaLocalRef<jobject> ReadData(JNIEnv* env, - jobject jcaller, - jint mojo_handle, - jobject elements, - jint elements_capacity, - jint flags) { +static ScopedJavaLocalRef<jobject> ReadData( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jint mojo_handle, + const JavaParamRef<jobject>& elements, + jint elements_capacity, + jint flags) { void* buffer_start = 0; uint32_t buffer_size = elements_capacity; if (elements) { @@ -239,11 +247,12 @@ static ScopedJavaLocalRef<jobject> ReadData(JNIEnv* env, env, result, (result == MOJO_RESULT_OK) ? buffer_size : 0); } -static ScopedJavaLocalRef<jobject> BeginReadData(JNIEnv* env, - jobject jcaller, - jint mojo_handle, - jint num_bytes, - jint flags) { +static ScopedJavaLocalRef<jobject> BeginReadData( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jint mojo_handle, + jint num_bytes, + jint flags) { void const* buffer = 0; uint32_t buffer_size = num_bytes; MojoResult result = @@ -257,18 +266,19 @@ static ScopedJavaLocalRef<jobject> BeginReadData(JNIEnv* env, } static jint EndReadData(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jint mojo_handle, jint num_bytes_read) { return MojoEndReadData(mojo_handle, num_bytes_read); } -static ScopedJavaLocalRef<jobject> WriteData(JNIEnv* env, - jobject jcaller, - jint mojo_handle, - jobject elements, - jint limit, - jint flags) { +static ScopedJavaLocalRef<jobject> WriteData( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jint mojo_handle, + const JavaParamRef<jobject>& elements, + jint limit, + jint flags) { void* buffer_start = env->GetDirectBufferAddress(elements); DCHECK(buffer_start); DCHECK(limit <= env->GetDirectBufferCapacity(elements)); @@ -279,11 +289,12 @@ static ScopedJavaLocalRef<jobject> WriteData(JNIEnv* env, env, result, (result == MOJO_RESULT_OK) ? buffer_size : 0); } -static ScopedJavaLocalRef<jobject> BeginWriteData(JNIEnv* env, - jobject jcaller, - jint mojo_handle, - jint num_bytes, - jint flags) { +static ScopedJavaLocalRef<jobject> BeginWriteData( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jint mojo_handle, + jint num_bytes, + jint flags) { void* buffer = 0; uint32_t buffer_size = num_bytes; MojoResult result = @@ -296,16 +307,17 @@ static ScopedJavaLocalRef<jobject> BeginWriteData(JNIEnv* env, } static jint EndWriteData(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jint mojo_handle, jint num_bytes_written) { return MojoEndWriteData(mojo_handle, num_bytes_written); } -static ScopedJavaLocalRef<jobject> Duplicate(JNIEnv* env, - jobject jcaller, - jint mojo_handle, - jobject options_buffer) { +static ScopedJavaLocalRef<jobject> Duplicate( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jint mojo_handle, + const JavaParamRef<jobject>& options_buffer) { const MojoDuplicateBufferHandleOptions* options = 0; if (options_buffer) { const void* buffer_start = env->GetDirectBufferAddress(options_buffer); @@ -322,7 +334,7 @@ static ScopedJavaLocalRef<jobject> Duplicate(JNIEnv* env, } static ScopedJavaLocalRef<jobject> Map(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jint mojo_handle, jlong offset, jlong num_bytes, @@ -337,18 +349,21 @@ static ScopedJavaLocalRef<jobject> Map(JNIEnv* env, return Java_CoreImpl_newResultAndBuffer(env, result, byte_buffer); } -static int Unmap(JNIEnv* env, jobject jcaller, jobject buffer) { +static int Unmap(JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + const JavaParamRef<jobject>& buffer) { void* buffer_start = env->GetDirectBufferAddress(buffer); DCHECK(buffer_start); return MojoUnmapBuffer(buffer_start); } -static ScopedJavaLocalRef<jobject> AsyncWait(JNIEnv* env, - jobject jcaller, - jint mojo_handle, - jint signals, - jlong deadline, - jobject callback) { +static ScopedJavaLocalRef<jobject> AsyncWait( + JNIEnv* env, + const JavaParamRef<jobject>& jcaller, + jint mojo_handle, + jint signals, + jlong deadline, + const JavaParamRef<jobject>& callback) { AsyncWaitCallbackData* callback_data = new AsyncWaitCallbackData(env, jcaller, callback); MojoAsyncWaitID cancel_id; @@ -370,7 +385,7 @@ static ScopedJavaLocalRef<jobject> AsyncWait(JNIEnv* env, } static void CancelAsyncWait(JNIEnv* env, - jobject jcaller, + const JavaParamRef<jobject>& jcaller, jlong id, jlong data_ptr) { if (id == 0) { @@ -385,8 +400,8 @@ static void CancelAsyncWait(JNIEnv* env, } static jint GetNativeBufferOffset(JNIEnv* env, - jobject jcaller, - jobject buffer, + const JavaParamRef<jobject>& jcaller, + const JavaParamRef<jobject>& buffer, jint alignment) { jint offset = reinterpret_cast<uintptr_t>(env->GetDirectBufferAddress(buffer)) % diff --git a/mojo/runner/android/bootstrap.cc b/mojo/runner/android/bootstrap.cc index adcf81f..39890c8 100644 --- a/mojo/runner/android/bootstrap.cc +++ b/mojo/runner/android/bootstrap.cc @@ -13,9 +13,9 @@ namespace mojo { namespace runner { void Bootstrap(JNIEnv* env, - jobject, - jobject j_context, - jstring j_native_library_path, + const JavaParamRef<jobject>&, + const JavaParamRef<jobject>& j_context, + const JavaParamRef<jstring>& j_native_library_path, jint j_handle, jlong j_run_application_ptr, jboolean is_cached_app) { diff --git a/mojo/runner/android/main.cc b/mojo/runner/android/main.cc index 8f4db82..b5717cc 100644 --- a/mojo/runner/android/main.cc +++ b/mojo/runner/android/main.cc @@ -99,12 +99,12 @@ void InitializeRedirection() { } // namespace static void Init(JNIEnv* env, - jclass clazz, - jobject activity, - jstring mojo_shell_path, - jobjectArray jparameters, - jstring j_local_apps_directory, - jstring j_tmp_dir) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& activity, + const JavaParamRef<jstring>& mojo_shell_path, + const JavaParamRef<jobjectArray>& jparameters, + const JavaParamRef<jstring>& j_local_apps_directory, + const JavaParamRef<jstring>& j_tmp_dir) { g_main_activiy.Get().Reset(env, activity); // Setting the TMPDIR environment variable so that applications can use it. @@ -155,7 +155,7 @@ static void Init(JNIEnv* env, gfx::GLSurface::InitializeOneOff(); } -static void Start(JNIEnv* env, jclass clazz) { +static void Start(JNIEnv* env, const JavaParamRef<jclass>& clazz) { #if defined(MOJO_SHELL_DEBUG_URL) base::CommandLine::ForCurrentProcess()->AppendArg(MOJO_SHELL_DEBUG_URL); // Sleep for 5 seconds to give the debugger a chance to attach. @@ -166,7 +166,9 @@ static void Start(JNIEnv* env, jclass clazz) { context->RunCommandLineApplication(base::Bind(ExitShell)); } -static void AddApplicationURL(JNIEnv* env, jclass clazz, jstring jurl) { +static void AddApplicationURL(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& jurl) { base::CommandLine::ForCurrentProcess()->AppendArg( base::android::ConvertJavaStringToUTF8(env, jurl)); } diff --git a/net/android/gurl_utils.cc b/net/android/gurl_utils.cc index 8fcfe0d..5b2ff3f 100644 --- a/net/android/gurl_utils.cc +++ b/net/android/gurl_utils.cc @@ -10,13 +10,17 @@ namespace net { -ScopedJavaLocalRef<jstring> GetOrigin(JNIEnv* env, jclass clazz, jstring url) { +ScopedJavaLocalRef<jstring> GetOrigin(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& url) { GURL host(base::android::ConvertJavaStringToUTF16(env, url)); return base::android::ConvertUTF8ToJavaString(env, host.GetOrigin().spec()); } -ScopedJavaLocalRef<jstring> GetScheme(JNIEnv* env, jclass clazz, jstring url) { +ScopedJavaLocalRef<jstring> GetScheme(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& url) { GURL host(base::android::ConvertJavaStringToUTF16(env, url)); return base::android::ConvertUTF8ToJavaString(env, host.scheme()); diff --git a/net/android/network_change_notifier_delegate_android.cc b/net/android/network_change_notifier_delegate_android.cc index 856acfe..ec8a729 100644 --- a/net/android/network_change_notifier_delegate_android.cc +++ b/net/android/network_change_notifier_delegate_android.cc @@ -45,7 +45,7 @@ NetworkChangeNotifier::ConnectionSubtype ConvertConnectionSubtype( } // namespace jdouble GetMaxBandwidthForConnectionSubtype(JNIEnv* env, - jclass caller, + const JavaParamRef<jclass>& caller, jint subtype) { return NetworkChangeNotifierAndroid::GetMaxBandwidthForConnectionSubtype( ConvertConnectionSubtype(subtype)); diff --git a/net/cert/x509_util_android.cc b/net/cert/x509_util_android.cc index 9648ffb..2a91f4a 100644 --- a/net/cert/x509_util_android.cc +++ b/net/cert/x509_util_android.cc @@ -12,12 +12,12 @@ namespace net { -void NotifyKeyChainChanged(JNIEnv* env, jclass clazz) { +void NotifyKeyChainChanged(JNIEnv* env, const JavaParamRef<jclass>& clazz) { CertDatabase::GetInstance()->OnAndroidKeyChainChanged(); } void RecordCertVerifyCapabilitiesHistogram(JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jboolean found_system_trust_roots) { // Only record the histogram for 4.2 and up. Before 4.2, the platform doesn't // return the certificate chain anyway. @@ -27,7 +27,9 @@ void RecordCertVerifyCapabilitiesHistogram(JNIEnv* env, } } -ScopedJavaLocalRef<jobject> GetApplicationContext(JNIEnv* env, jclass clazz) { +ScopedJavaLocalRef<jobject> GetApplicationContext( + JNIEnv* env, + const JavaParamRef<jclass>& clazz) { ScopedJavaLocalRef<jobject> r; // Must use Reset to force creation of a new local ref, instead of trying to // adopt the global-ref'ed jobject as a local ref as the constructor would. diff --git a/net/test/embedded_test_server/android/embedded_test_server_android.cc b/net/test/embedded_test_server/android/embedded_test_server_android.cc index 7cca9d9..9ba3886 100644 --- a/net/test/embedded_test_server/android/embedded_test_server_android.cc +++ b/net/test/embedded_test_server/android/embedded_test_server_android.cc @@ -57,7 +57,7 @@ void EmbeddedTestServerAndroid::Destroy(JNIEnv* env, jobject jobj) { delete this; } -static void Init(JNIEnv* env, jobject jobj) { +static void Init(JNIEnv* env, const JavaParamRef<jobject>& jobj) { TRACE_EVENT0("native", "EmbeddedTestServerAndroid::Init"); new EmbeddedTestServerAndroid(env, jobj); } diff --git a/remoting/client/jni/chromoting_jni_runtime.cc b/remoting/client/jni/chromoting_jni_runtime.cc index 6bdf286..0d6f9b0 100644 --- a/remoting/client/jni/chromoting_jni_runtime.cc +++ b/remoting/client/jni/chromoting_jni_runtime.cc @@ -37,7 +37,9 @@ bool RegisterChromotingJniRuntime(JNIEnv* env) { // Implementation of stubs defined in JniInterface_jni.h. These are the entry // points for JNI calls from Java into C++. -static void LoadNative(JNIEnv* env, jclass clazz, jobject context) { +static void LoadNative(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jobject>& context) { base::android::ScopedJavaLocalRef<jobject> context_activity(env, context); base::android::InitApplicationContext(env, context_activity); @@ -51,32 +53,38 @@ static void LoadNative(JNIEnv* env, jclass clazz, jobject context) { remoting::ChromotingJniRuntime::GetInstance(); } -static ScopedJavaLocalRef<jstring> GetApiKey(JNIEnv* env, jclass clazz) { +static ScopedJavaLocalRef<jstring> GetApiKey( + JNIEnv* env, + const JavaParamRef<jclass>& clazz) { return ConvertUTF8ToJavaString(env, google_apis::GetAPIKey().c_str()); } -static ScopedJavaLocalRef<jstring> GetClientId(JNIEnv* env, jclass clazz) { +static ScopedJavaLocalRef<jstring> GetClientId( + JNIEnv* env, + const JavaParamRef<jclass>& clazz) { return ConvertUTF8ToJavaString( env, google_apis::GetOAuth2ClientID(google_apis::CLIENT_REMOTING).c_str()); } -static ScopedJavaLocalRef<jstring> GetClientSecret(JNIEnv* env, jclass clazz) { +static ScopedJavaLocalRef<jstring> GetClientSecret( + JNIEnv* env, + const JavaParamRef<jclass>& clazz) { return ConvertUTF8ToJavaString( env, google_apis::GetOAuth2ClientSecret(google_apis::CLIENT_REMOTING).c_str()); } static void Connect(JNIEnv* env, - jclass clazz, - jstring username, - jstring authToken, - jstring hostJid, - jstring hostId, - jstring hostPubkey, - jstring pairId, - jstring pairSecret, - jstring capabilities) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& username, + const JavaParamRef<jstring>& authToken, + const JavaParamRef<jstring>& hostJid, + const JavaParamRef<jstring>& hostId, + const JavaParamRef<jstring>& hostPubkey, + const JavaParamRef<jstring>& pairId, + const JavaParamRef<jstring>& pairSecret, + const JavaParamRef<jstring>& capabilities) { remoting::ChromotingJniRuntime::GetInstance()->ConnectToHost( ConvertJavaStringToUTF8(env, username).c_str(), ConvertJavaStringToUTF8(env, authToken).c_str(), @@ -88,26 +96,26 @@ static void Connect(JNIEnv* env, ConvertJavaStringToUTF8(env, capabilities).c_str()); } -static void Disconnect(JNIEnv* env, jclass clazz) { +static void Disconnect(JNIEnv* env, const JavaParamRef<jclass>& clazz) { remoting::ChromotingJniRuntime::GetInstance()->DisconnectFromHost(); } static void AuthenticationResponse(JNIEnv* env, - jclass clazz, - jstring pin, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& pin, jboolean createPair, - jstring deviceName) { + const JavaParamRef<jstring>& deviceName) { remoting::ChromotingJniRuntime::GetInstance()->session()->ProvideSecret( ConvertJavaStringToUTF8(env, pin).c_str(), createPair, ConvertJavaStringToUTF8(env, deviceName)); } -static void ScheduleRedraw(JNIEnv* env, jclass clazz) { +static void ScheduleRedraw(JNIEnv* env, const JavaParamRef<jclass>& clazz) { remoting::ChromotingJniRuntime::GetInstance()->session()->RedrawDesktop(); } static void SendMouseEvent(JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jint x, jint y, jint whichButton, @@ -122,7 +130,7 @@ static void SendMouseEvent(JNIEnv* env, } static void SendMouseWheelEvent(JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jint delta_x, jint delta_y) { remoting::ChromotingJniRuntime::GetInstance()->session()->SendMouseWheelEvent( @@ -130,31 +138,32 @@ static void SendMouseWheelEvent(JNIEnv* env, } static jboolean SendKeyEvent(JNIEnv* env, - jclass clazz, - jint keyCode, - jboolean keyDown) { + const JavaParamRef<jclass>& clazz, + jint keyCode, + jboolean keyDown) { return remoting::ChromotingJniRuntime::GetInstance()->session()->SendKeyEvent( keyCode, keyDown); } static void SendTextEvent(JNIEnv* env, - jclass clazz, - jstring text) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& text) { remoting::ChromotingJniRuntime::GetInstance()->session()->SendTextEvent( ConvertJavaStringToUTF8(env, text)); } static void EnableVideoChannel(JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jboolean enable) { remoting::ChromotingJniRuntime::GetInstance()->session()->EnableVideoChannel( enable); } -static void OnThirdPartyTokenFetched(JNIEnv* env, - jclass clazz, - jstring token, - jstring shared_secret) { +static void OnThirdPartyTokenFetched( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& token, + const JavaParamRef<jstring>& shared_secret) { ChromotingJniRuntime* runtime = remoting::ChromotingJniRuntime::GetInstance(); runtime->network_task_runner()->PostTask(FROM_HERE, base::Bind( &ChromotingJniInstance::HandleOnThirdPartyTokenFetched, @@ -164,9 +173,9 @@ static void OnThirdPartyTokenFetched(JNIEnv* env, } static void SendExtensionMessage(JNIEnv* env, - jclass clazz, - jstring type, - jstring data) { + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& type, + const JavaParamRef<jstring>& data) { remoting::ChromotingJniRuntime::GetInstance()->session()->SendClientMessage( ConvertJavaStringToUTF8(env, type), ConvertJavaStringToUTF8(env, data)); diff --git a/remoting/client/jni/jni_client.cc b/remoting/client/jni/jni_client.cc index 0f634ff..4af5d86 100644 --- a/remoting/client/jni/jni_client.cc +++ b/remoting/client/jni/jni_client.cc @@ -23,7 +23,7 @@ void JniClient::Destroy(JNIEnv* env, jobject caller) { delete this; } -static jlong Init(JNIEnv* env, jobject caller) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& caller) { return reinterpret_cast<intptr_t>(new JniClient()); } diff --git a/sync/android/model_type_helper.cc b/sync/android/model_type_helper.cc index 37650cb..64d808f 100644 --- a/sync/android/model_type_helper.cc +++ b/sync/android/model_type_helper.cc @@ -11,8 +11,10 @@ namespace syncer { -static ScopedJavaLocalRef<jstring> -ModelTypeToNotificationType(JNIEnv* env, jclass clazz, jint model_type_int) { +static ScopedJavaLocalRef<jstring> ModelTypeToNotificationType( + JNIEnv* env, + const JavaParamRef<jclass>& clazz, + jint model_type_int) { std::string model_type_string; ModelType model_type = static_cast<ModelType>(model_type_int); if (!RealModelTypeToNotificationType(model_type, &model_type_string)) { diff --git a/sync/test/fake_server/android/fake_server_helper_android.cc b/sync/test/fake_server/android/fake_server_helper_android.cc index 18539ff..4254295 100644 --- a/sync/test/fake_server/android/fake_server_helper_android.cc +++ b/sync/test/fake_server/android/fake_server_helper_android.cc @@ -30,7 +30,7 @@ FakeServerHelperAndroid::FakeServerHelperAndroid(JNIEnv* env, jobject obj) { FakeServerHelperAndroid::~FakeServerHelperAndroid() { } -static jlong Init(JNIEnv* env, jobject obj) { +static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { FakeServerHelperAndroid* fake_server_android = new FakeServerHelperAndroid(env, obj); return reinterpret_cast<intptr_t>(fake_server_android); diff --git a/testing/android/native_test/native_test_launcher.cc b/testing/android/native_test/native_test_launcher.cc index 343f118..52b419d 100644 --- a/testing/android/native_test/native_test_launcher.cc +++ b/testing/android/native_test/native_test_launcher.cc @@ -70,12 +70,12 @@ void AndroidLog(int priority, const char* format, ...) { } // namespace static void RunTests(JNIEnv* env, - jobject obj, - jstring jcommand_line_flags, - jstring jcommand_line_file_path, - jstring jstdout_file_path, + const JavaParamRef<jobject>& obj, + const JavaParamRef<jstring>& jcommand_line_flags, + const JavaParamRef<jstring>& jcommand_line_file_path, + const JavaParamRef<jstring>& jstdout_file_path, jboolean jstdout_fifo, - jobject app_context) { + const JavaParamRef<jobject>& app_context) { // Command line initialized basically, will be fully initialized later. static const char* const kInitialArgv[] = { "ChromeTestActivity" }; base::CommandLine::Init(arraysize(kInitialArgv), kInitialArgv); diff --git a/ui/android/window_android.cc b/ui/android/window_android.cc index 0106ba1..5fe7779 100644 --- a/ui/android/window_android.cc +++ b/ui/android/window_android.cc @@ -136,7 +136,7 @@ bool WindowAndroid::CanRequestPermission(const std::string& permission) { // Native JNI methods // ---------------------------------------------------------------------------- -jlong Init(JNIEnv* env, jobject obj) { +jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) { WindowAndroid* window = new WindowAndroid(env, obj); return reinterpret_cast<intptr_t>(window); } diff --git a/ui/base/l10n/l10n_util_android.cc b/ui/base/l10n/l10n_util_android.cc index 55cd4b2..a568541 100644 --- a/ui/base/l10n/l10n_util_android.cc +++ b/ui/base/l10n/l10n_util_android.cc @@ -17,8 +17,9 @@ namespace l10n_util { -jint GetFirstStrongCharacterDirection(JNIEnv* env, jclass clazz, - jstring string) { +jint GetFirstStrongCharacterDirection(JNIEnv* env, + const JavaParamRef<jclass>& clazz, + const JavaParamRef<jstring>& string) { return base::i18n::GetFirstStrongCharacterDirection( base::android::ConvertJavaStringToUTF16(env, string)); } @@ -93,7 +94,7 @@ base::string16 GetDisplayNameForLocale(const std::string& locale, } ScopedJavaLocalRef<jstring> GetDurationString(JNIEnv* env, - jclass clazz, + const JavaParamRef<jclass>& clazz, jlong timeInMillis) { ScopedJavaLocalRef<jstring> jtime_remaining = base::android::ConvertUTF16ToJavaString( diff --git a/ui/gfx/android/shared_device_display_info.cc b/ui/gfx/android/shared_device_display_info.cc index c58813d..0f7d3ab 100644 --- a/ui/gfx/android/shared_device_display_info.cc +++ b/ui/gfx/android/shared_device_display_info.cc @@ -13,7 +13,7 @@ namespace gfx { // static JNI call static void UpdateSharedDeviceDisplayInfo(JNIEnv* env, - jobject obj, + const JavaParamRef<jobject>& obj, jint display_height, jint display_width, jint physical_display_height, diff --git a/ui/gfx/android/view_configuration.cc b/ui/gfx/android/view_configuration.cc index 538cd59..df9581b 100644 --- a/ui/gfx/android/view_configuration.cc +++ b/ui/gfx/android/view_configuration.cc @@ -143,7 +143,7 @@ base::LazyInstance<ViewConfigurationData>::Leaky g_view_configuration = } // namespace static void UpdateSharedViewConfiguration(JNIEnv* env, - jobject obj, + const JavaParamRef<jobject>& obj, jfloat maximum_fling_velocity, jfloat minimum_fling_velocity, jfloat touch_slop, |