jni_generator: Pass object parameters as JavaParamRef.

chrome/browser/android/preferences/website_preference_bridge.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/android/preferences/website_preference_bridge.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/bind.h"
@@ skipping 157 matching lines @@
       NOTREACHED();
   }
   GetHostContentSettingsMap(is_incognito)
       ->SetContentSetting(ContentSettingsPattern::FromURLNoWildcard(url),
                           secondary_pattern, content_type, std::string(),
                           setting);
   WebSiteSettingsUmaUtil::LogPermissionChange(content_type, setting);
 }
 
 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));
   SetSettingForOrigin(env, CONTENT_SETTINGS_TYPE_FULLSCREEN, origin,
                       ContentSettingsPattern::FromURLNoWildcard(embedder_url),
                       value, is_incognito);
 }
 
 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));
   SetSettingForOrigin(env, CONTENT_SETTINGS_TYPE_MIDI_SYSEX, origin,
                       ContentSettingsPattern::FromURLNoWildcard(embedder_url),
                       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,
                       ContentSettingsPattern::FromURLNoWildcard(embedder_url),
                       value, is_incognito);
 }
 
 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);
   GURL url = GURL(ConvertJavaStringToUTF8(env, origin));
   ContentSetting setting = CONTENT_SETTING_DEFAULT;
   switch (value) {
     case -1:
       DesktopNotificationProfileUtil::ClearSetting(
           profile, ContentSettingsPattern::FromURLNoWildcard(url));
       break;
     case 1:
       DesktopNotificationProfileUtil::GrantPermission(profile, url);
       setting = CONTENT_SETTING_ALLOW;
       break;
     case 2:
       DesktopNotificationProfileUtil::DenyPermission(profile, url);
       setting = CONTENT_SETTING_BLOCK;
       break;
     default:
       NOTREACHED();
   }
   WebSiteSettingsUmaUtil::LogPermissionChange(
       CONTENT_SETTINGS_TYPE_NOTIFICATIONS, setting);
 }
 
 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,
                       ContentSettingsPattern::Wildcard(), value, is_incognito);
 }
 
 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,
                       ContentSettingsPattern::Wildcard(), value, is_incognito);
 }
 
 static scoped_refptr<content_settings::CookieSettings> GetCookieSettings() {
   // A single cookie setting applies to both incognito and non-incognito.
   Profile* profile = ProfileManager::GetActiveUserProfile();
   return CookieSettingsFactory::GetForProfile(profile);
 }
 
 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);
   const ContentSetting default_setting =
       GetCookieSettings()->GetDefaultCookieSetting(nullptr);
   for (const auto& settings_it : all_settings) {
     if (settings_it.setting == default_setting)
       continue;
     if (managedOnly &&
         HostContentSettingsMap::GetProviderTypeFromSource(settings_it.source) !=
             HostContentSettingsMap::ProviderType::POLICY_PROVIDER) {
       continue;
     }
     const std::string& origin = settings_it.primary_pattern.ToString();
     const std::string& embedder = settings_it.secondary_pattern.ToString();
     ScopedJavaLocalRef<jstring> jorigin = ConvertUTF8ToJavaString(env, origin);
     ScopedJavaLocalRef<jstring> jembedder;
     if (embedder != origin)
       jembedder = ConvertUTF8ToJavaString(env, embedder);
     Java_WebsitePreferenceBridge_insertCookieInfoIntoList(env, list,
         jorigin.obj(), jembedder.obj());
   }
 }
 
 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));
   ContentSettingsPattern primary_pattern(
       ContentSettingsPattern::FromURLNoWildcard(url));
   ContentSettingsPattern secondary_pattern(ContentSettingsPattern::Wildcard());
   ContentSetting setting = CONTENT_SETTING_DEFAULT;
   if (value == -1) {
     GetCookieSettings()->ResetCookieSetting(primary_pattern, secondary_pattern);
   } else {
     setting = value ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK;
     GetCookieSettings()->SetCookieSetting(primary_pattern, secondary_pattern,
                                           setting);
   }
   WebSiteSettingsUmaUtil::LogPermissionChange(
       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)));
 }
 
 namespace {
 
 class SiteDataDeleteHelper :
       public base::RefCountedThreadSafe<SiteDataDeleteHelper>,
       public CookiesTreeModel::Observer {
@@ skipping 257 matching lines @@
 // TODO(jknotten): These methods should not be static. Instead we should
 // expose a class to Java so that the fetch requests can be cancelled,
 // and manage the lifetimes of the callback (and indirectly the helper
 // by having a reference to it).
 
 // The helper methods (StartFetching, DeleteLocalStorageFile, DeleteDatabase)
 // are asynchronous. A "use after free" error is not possible because the
 // 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));
   // local_storage_callback will delete itself when it is run.
   LocalStorageInfoReadyCallback* local_storage_callback =
       new LocalStorageInfoReadyCallback(
           ScopedJavaLocalRef<jobject>(env, java_callback));
   local_storage_helper->StartFetching(
       base::Bind(&LocalStorageInfoReadyCallback::OnLocalStorageModelInfoLoaded,
                  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(
           profile)->GetQuotaManager(),
       ScopedJavaLocalRef<jobject>(env, 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);
   GURL origin_url = GURL(ConvertJavaStringToUTF8(env, jorigin));
   local_storage_helper->DeleteOrigin(origin_url);
 }
 
 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(
       content::BrowserContext::GetDefaultStoragePartition(
           profile)->GetQuotaManager(),
       host,
       static_cast<storage::StorageType>(type),
       ScopedJavaLocalRef<jobject>(env, java_callback)));
   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(
       new SiteDataDeleteHelper(profile, url));
   site_data_deleter->Run();
 }
 
 // Register native methods
 bool RegisterWebsitePreferenceBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }