Pass method parameters as JavaParamRef in chrome/browser (part 2).

chrome/browser/sync/profile_sync_service_android.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/sync/profile_sync_service_android.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
@@ skipping 106 matching lines @@
 void ProfileSyncServiceAndroid::OnStateChanged() {
   // Notify the java world that our sync state has changed.
   JNIEnv* env = AttachCurrentThread();
   Java_ProfileSyncService_syncStateChanged(
       env, weak_java_profile_sync_service_.get(env).obj());
 }
 
 // Pure ProfileSyncService calls.
 
 jboolean ProfileSyncServiceAndroid::IsSyncRequested(
-    JNIEnv* env, jobject obj) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return sync_service_->IsSyncRequested();
 }
 
-void ProfileSyncServiceAndroid::RequestStart(JNIEnv* env, jobject) {
+void ProfileSyncServiceAndroid::RequestStart(JNIEnv* env,
+                                             const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   sync_service_->RequestStart();
 }
 
-void ProfileSyncServiceAndroid::RequestStop(JNIEnv* env, jobject) {
+void ProfileSyncServiceAndroid::RequestStop(JNIEnv* env,
+                                            const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   sync_service_->RequestStop(ProfileSyncService::KEEP_DATA);
 }
 
-void ProfileSyncServiceAndroid::SignOutSync(JNIEnv* env, jobject) {
+void ProfileSyncServiceAndroid::SignOutSync(JNIEnv* env,
+                                            const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(profile_);
   sync_service_->RequestStop(ProfileSyncService::CLEAR_DATA);
 }
 
-jboolean ProfileSyncServiceAndroid::IsSyncActive(JNIEnv* env, jobject obj) {
+jboolean ProfileSyncServiceAndroid::IsSyncActive(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return sync_service_->IsSyncActive();
 }
 
-jboolean ProfileSyncServiceAndroid::IsBackendInitialized(JNIEnv* env, jobject) {
+jboolean ProfileSyncServiceAndroid::IsBackendInitialized(
+    JNIEnv* env,
+    const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return sync_service_->IsBackendInitialized();
 }
 
 jboolean ProfileSyncServiceAndroid::IsFirstSetupInProgress(
-    JNIEnv* env, jobject) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return sync_service_->IsFirstSetupInProgress();
 }
 
 void ProfileSyncServiceAndroid::SetSetupInProgress(
-    JNIEnv* env, jobject obj, jboolean in_progress) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    jboolean in_progress) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   sync_service_->SetSetupInProgress(in_progress);
 }
 
 jboolean ProfileSyncServiceAndroid::HasSyncSetupCompleted(
-    JNIEnv* env, jobject obj) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return sync_service_->HasSyncSetupCompleted();
 }
 
 void ProfileSyncServiceAndroid::SetSyncSetupCompleted(
-    JNIEnv* env, jobject obj) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   sync_service_->SetSyncSetupCompleted();
 }
 
 ScopedJavaLocalRef<jintArray> ProfileSyncServiceAndroid::GetActiveDataTypes(
-      JNIEnv* env, jobject obj) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj) {
   syncer::ModelTypeSet types = sync_service_->GetActiveDataTypes();
   return ModelTypeSetToJavaIntArray(env, types);
 }
 
 ScopedJavaLocalRef<jintArray> ProfileSyncServiceAndroid::GetPreferredDataTypes(
-      JNIEnv* env, jobject obj) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj) {
   syncer::ModelTypeSet types = sync_service_->GetPreferredDataTypes();
   return ModelTypeSetToJavaIntArray(env, types);
 }
 
 void ProfileSyncServiceAndroid::SetPreferredDataTypes(
-    JNIEnv* env, jobject obj,
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
     jboolean sync_everything,
-    jintArray model_type_array) {
+    const JavaParamRef<jintArray>& model_type_array) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   std::vector<int> types_vector;
   base::android::JavaIntArrayToIntVector(env, model_type_array, &types_vector);
   syncer::ModelTypeSet types;
   for (size_t i = 0; i < types_vector.size(); i++) {
     types.Put(static_cast<syncer::ModelType>(types_vector[i]));
   }
   sync_service_->OnUserChoseDatatypes(sync_everything, types);
 }
 
-jboolean ProfileSyncServiceAndroid::IsCryptographerReady(JNIEnv* env, jobject) {
+jboolean ProfileSyncServiceAndroid::IsCryptographerReady(
+    JNIEnv* env,
+    const JavaParamRef<jobject>&) {
   syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
   return sync_service_->IsCryptographerReady(&trans);
 }
 
 jboolean ProfileSyncServiceAndroid::IsEncryptEverythingAllowed(
-    JNIEnv* env, jobject obj) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return sync_service_->IsEncryptEverythingAllowed();
 }
 
 jboolean ProfileSyncServiceAndroid::IsEncryptEverythingEnabled(
-    JNIEnv* env, jobject) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return sync_service_->IsEncryptEverythingEnabled();
 }
 
 void ProfileSyncServiceAndroid::EnableEncryptEverything(
-    JNIEnv* env, jobject obj) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   sync_service_->EnableEncryptEverything();
 }
 
 jboolean ProfileSyncServiceAndroid::IsPassphraseRequired(JNIEnv* env, jobject) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return sync_service_->IsPassphraseRequired();
 }
 
 jboolean ProfileSyncServiceAndroid::IsPassphraseRequiredForDecryption(
-    JNIEnv* env, jobject obj) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return sync_service_->IsPassphraseRequiredForDecryption();
 }
 
 jboolean ProfileSyncServiceAndroid::IsUsingSecondaryPassphrase(
-    JNIEnv* env, jobject) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return sync_service_->IsUsingSecondaryPassphrase();
 }
 
 ScopedJavaLocalRef<jbyteArray>
-ProfileSyncServiceAndroid::GetCustomPassphraseKey(JNIEnv* env, jobject obj) {
+ProfileSyncServiceAndroid::GetCustomPassphraseKey(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj) {
   std::string key = sync_service_->GetCustomPassphraseKey();
   return base::android::ToJavaByteArray(
       env, reinterpret_cast<const uint8_t*>(key.data()), key.size());
 }
 
-jint ProfileSyncServiceAndroid::GetPassphraseType(JNIEnv* env, jobject) {
+jint ProfileSyncServiceAndroid::GetPassphraseType(
+    JNIEnv* env,
+    const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return sync_service_->GetPassphraseType();
 }
 
 void ProfileSyncServiceAndroid::SetEncryptionPassphrase(
-    JNIEnv* env, jobject obj, jstring passphrase) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    const JavaParamRef<jstring>& passphrase) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   std::string key = ConvertJavaStringToUTF8(env, passphrase);
   sync_service_->SetEncryptionPassphrase(key, ProfileSyncService::EXPLICIT);
 }
 
 jboolean ProfileSyncServiceAndroid::SetDecryptionPassphrase(
-    JNIEnv* env, jobject obj, jstring passphrase) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    const JavaParamRef<jstring>& passphrase) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   std::string key = ConvertJavaStringToUTF8(env, passphrase);
   return sync_service_->SetDecryptionPassphrase(key);
 }
 
 jboolean ProfileSyncServiceAndroid::HasExplicitPassphraseTime(
-    JNIEnv* env, jobject) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::Time passphrase_time = sync_service_->GetExplicitPassphraseTime();
   return !passphrase_time.is_null();
 }
 
 jlong ProfileSyncServiceAndroid::GetExplicitPassphraseTime(
-        JNIEnv* env, jobject) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::Time passphrase_time = sync_service_->GetExplicitPassphraseTime();
   return passphrase_time.ToJavaTime();
 }
 
-void ProfileSyncServiceAndroid::FlushDirectory(JNIEnv* env, jobject) {
+void ProfileSyncServiceAndroid::FlushDirectory(JNIEnv* env,
+                                               const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   sync_service_->FlushDirectory();
 }
 
 ScopedJavaLocalRef<jstring> ProfileSyncServiceAndroid::QuerySyncStatusSummary(
-    JNIEnv* env, jobject) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(profile_);
   std::string status(sync_service_->QuerySyncStatusSummaryString());
   return ConvertUTF8ToJavaString(env, status);
 }
 
-void ProfileSyncServiceAndroid::GetAllNodes(JNIEnv* env,
-                                            jobject obj,
-                                            jobject callback) {
+void ProfileSyncServiceAndroid::GetAllNodes(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    const JavaParamRef<jobject>& callback) {
   base::android::ScopedJavaGlobalRef<jobject> java_callback;
   java_callback.Reset(env, callback);
 
   base::Callback<void(scoped_ptr<base::ListValue>)> native_callback =
       base::Bind(&NativeGetAllNodesCallback, java_callback);
   sync_service_->GetAllNodes(native_callback);
 }
 
-jint ProfileSyncServiceAndroid::GetAuthError(JNIEnv* env, jobject) {
+jint ProfileSyncServiceAndroid::GetAuthError(JNIEnv* env,
+                                             const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return sync_service_->GetAuthError().state();
 }
 
 jboolean ProfileSyncServiceAndroid::HasUnrecoverableError(
-    JNIEnv* env, jobject) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return sync_service_->HasUnrecoverableError();
 }
 
 // Pure SyncPrefs calls.
 
-jboolean ProfileSyncServiceAndroid::IsPassphrasePrompted(JNIEnv* env,
-                                                         jobject obj) {
+jboolean ProfileSyncServiceAndroid::IsPassphrasePrompted(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj) {
   return sync_prefs_->IsPassphrasePrompted();
 }
 
-void ProfileSyncServiceAndroid::SetPassphrasePrompted(JNIEnv* env,
-                                                      jobject obj,
-                                                      jboolean prompted) {
+void ProfileSyncServiceAndroid::SetPassphrasePrompted(
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    jboolean prompted) {
   sync_prefs_->SetPassphrasePrompted(prompted);
 }
 
 void ProfileSyncServiceAndroid::SetSyncSessionsId(
-    JNIEnv* env, jobject obj, jstring tag) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj,
+    const JavaParamRef<jstring>& tag) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(profile_);
   std::string machine_tag = ConvertJavaStringToUTF8(env, tag);
   sync_prefs_->SetSyncSessionsGUID(machine_tag);
 }
 
 jboolean ProfileSyncServiceAndroid::HasKeepEverythingSynced(
-    JNIEnv* env, jobject) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return sync_prefs_->HasKeepEverythingSynced();
 }
 
 // UI string getters.
 
 ScopedJavaLocalRef<jstring>
-    ProfileSyncServiceAndroid::GetSyncEnterGooglePassphraseBodyWithDateText(
-        JNIEnv* env, jobject) {
+ProfileSyncServiceAndroid::GetSyncEnterGooglePassphraseBodyWithDateText(
+    JNIEnv* env,
+    const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::Time passphrase_time = sync_service_->GetExplicitPassphraseTime();
   base::string16 passphrase_time_str =
       base::TimeFormatShortDate(passphrase_time);
   return base::android::ConvertUTF16ToJavaString(env,
       l10n_util::GetStringFUTF16(
         IDS_SYNC_ENTER_GOOGLE_PASSPHRASE_BODY_WITH_DATE,
         passphrase_time_str));
 }
 
 ScopedJavaLocalRef<jstring>
-    ProfileSyncServiceAndroid::GetSyncEnterCustomPassphraseBodyWithDateText(
-        JNIEnv* env, jobject) {
+ProfileSyncServiceAndroid::GetSyncEnterCustomPassphraseBodyWithDateText(
+    JNIEnv* env,
+    const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::Time passphrase_time = sync_service_->GetExplicitPassphraseTime();
   base::string16 passphrase_time_str =
       base::TimeFormatShortDate(passphrase_time);
   return base::android::ConvertUTF16ToJavaString(env,
       l10n_util::GetStringFUTF16(IDS_SYNC_ENTER_PASSPHRASE_BODY_WITH_DATE,
         passphrase_time_str));
 }
 
 ScopedJavaLocalRef<jstring>
-    ProfileSyncServiceAndroid::GetCurrentSignedInAccountText(
-        JNIEnv* env, jobject) {
+ProfileSyncServiceAndroid::GetCurrentSignedInAccountText(
+    JNIEnv* env,
+    const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   const std::string& sync_username =
       SigninManagerFactory::GetForProfile(profile_)
           ->GetAuthenticatedAccountInfo()
           .email;
   return base::android::ConvertUTF16ToJavaString(env,
       l10n_util::GetStringFUTF16(
           IDS_SYNC_ACCOUNT_SYNCING_TO_USER,
           base::ASCIIToUTF16(sync_username)));
 }
 
 ScopedJavaLocalRef<jstring>
-    ProfileSyncServiceAndroid::GetSyncEnterCustomPassphraseBodyText(
-        JNIEnv* env, jobject) {
+ProfileSyncServiceAndroid::GetSyncEnterCustomPassphraseBodyText(
+    JNIEnv* env,
+    const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return ConvertUTF8ToJavaString(
       env, l10n_util::GetStringUTF8(IDS_SYNC_ENTER_PASSPHRASE_BODY));
 }
 
 // Functionality only available for testing purposes.
 
 ScopedJavaLocalRef<jstring> ProfileSyncServiceAndroid::GetAboutInfoForTest(
-    JNIEnv* env, jobject) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>&) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   scoped_ptr<base::DictionaryValue> about_info =
       sync_driver::sync_ui_util::ConstructAboutInformation(
           sync_service_, sync_service_->signin(), chrome::GetChannel());
   std::string about_info_json;
   base::JSONWriter::Write(*about_info, &about_info_json);
 
   return ConvertUTF8ToJavaString(env, about_info_json);
 }
 
 jlong ProfileSyncServiceAndroid::GetLastSyncedTimeForTest(
-    JNIEnv* env, jobject obj) {
+    JNIEnv* env,
+    const JavaParamRef<jobject>& obj) {
   // Use profile preferences here instead of SyncPrefs to avoid an extra
   // conversion, since SyncPrefs::GetLastSyncedTime() converts the stored value
   // to to base::Time.
   return static_cast<jlong>(
       profile_->GetPrefs()->GetInt64(sync_driver::prefs::kSyncLastSyncedTime));
 }
 
 void ProfileSyncServiceAndroid::OverrideNetworkResourcesForTest(
     JNIEnv* env,
-    jobject obj,
+    const JavaParamRef<jobject>& obj,
     jlong network_resources) {
   syncer::NetworkResources* resources =
       reinterpret_cast<syncer::NetworkResources*>(network_resources);
   sync_service_->OverrideNetworkResourcesForTest(
       make_scoped_ptr<syncer::NetworkResources>(resources));
 }
 
 // static
 ProfileSyncServiceAndroid*
     ProfileSyncServiceAndroid::GetProfileSyncServiceAndroid() {
@@ skipping 10 matching lines @@
 static jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   ProfileSyncServiceAndroid* profile_sync_service_android =
       new ProfileSyncServiceAndroid(env, obj);
   if (profile_sync_service_android->Init()) {
     return reinterpret_cast<intptr_t>(profile_sync_service_android);
   } else {
     delete profile_sync_service_android;
     return 0;
   }
 }