Home | History | Annotate | Download | only in sync 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/sync/profile_sync_service_android.h"
      6 
      7 #include "base/android/jni_android.h"
      8 #include "base/android/jni_string.h"
      9 #include "base/bind.h"
     10 #include "base/i18n/time_formatting.h"
     11 #include "base/json/json_writer.h"
     12 #include "base/logging.h"
     13 #include "base/memory/scoped_ptr.h"
     14 #include "base/prefs/pref_service.h"
     15 #include "base/strings/utf_string_conversions.h"
     16 #include "base/time/time.h"
     17 #include "chrome/browser/browser_process.h"
     18 #include "chrome/browser/chrome_notification_types.h"
     19 #include "chrome/browser/profiles/profile_manager.h"
     20 #include "chrome/browser/signin/signin_manager_factory.h"
     21 #include "chrome/browser/sync/about_sync_util.h"
     22 #include "chrome/browser/sync/profile_sync_service.h"
     23 #include "chrome/browser/sync/profile_sync_service_factory.h"
     24 #include "chrome/browser/sync/sync_ui_util.h"
     25 #include "components/signin/core/browser/signin_manager.h"
     26 #include "components/sync_driver/pref_names.h"
     27 #include "components/sync_driver/sync_prefs.h"
     28 #include "content/public/browser/browser_thread.h"
     29 #include "content/public/browser/notification_service.h"
     30 #include "content/public/browser/notification_source.h"
     31 #include "google/cacheinvalidation/types.pb.h"
     32 #include "google_apis/gaia/gaia_constants.h"
     33 #include "google_apis/gaia/google_service_auth_error.h"
     34 #include "grit/generated_resources.h"
     35 #include "jni/ProfileSyncService_jni.h"
     36 #include "sync/internal_api/public/read_transaction.h"
     37 #include "sync/notifier/object_id_invalidation_map.h"
     38 #include "ui/base/l10n/l10n_util.h"
     39 
     40 using base::android::AttachCurrentThread;
     41 using base::android::CheckException;
     42 using base::android::ConvertJavaStringToUTF8;
     43 using base::android::ConvertUTF8ToJavaString;
     44 using base::android::ScopedJavaLocalRef;
     45 using content::BrowserThread;
     46 
     47 namespace {
     48 
     49 enum {
     50 #define DEFINE_MODEL_TYPE_SELECTION(name,value)  name = value,
     51 #include "chrome/browser/sync/profile_sync_service_model_type_selection_android.h"
     52 #undef DEFINE_MODEL_TYPE_SELECTION
     53 };
     54 
     55 }  // namespace
     56 
     57 ProfileSyncServiceAndroid::ProfileSyncServiceAndroid(JNIEnv* env, jobject obj)
     58     : profile_(NULL),
     59       sync_service_(NULL),
     60       weak_java_profile_sync_service_(env, obj) {
     61   if (g_browser_process == NULL ||
     62       g_browser_process->profile_manager() == NULL) {
     63     NOTREACHED() << "Browser process or profile manager not initialized";
     64     return;
     65   }
     66 
     67   profile_ = ProfileManager::GetActiveUserProfile();
     68   if (profile_ == NULL) {
     69     NOTREACHED() << "Sync Init: Profile not found.";
     70     return;
     71   }
     72 
     73   sync_prefs_.reset(new sync_driver::SyncPrefs(profile_->GetPrefs()));
     74 
     75   sync_service_ =
     76       ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile_);
     77   DCHECK(sync_service_);
     78 }
     79 
     80 void ProfileSyncServiceAndroid::Init() {
     81   sync_service_->AddObserver(this);
     82 }
     83 
     84 void ProfileSyncServiceAndroid::RemoveObserver() {
     85   if (sync_service_->HasObserver(this)) {
     86     sync_service_->RemoveObserver(this);
     87   }
     88 }
     89 
     90 ProfileSyncServiceAndroid::~ProfileSyncServiceAndroid() {
     91   RemoveObserver();
     92 }
     93 
     94 void ProfileSyncServiceAndroid::SendNudgeNotification(
     95     int object_source,
     96     const std::string& str_object_id,
     97     int64 version,
     98     const std::string& state) {
     99   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    100 
    101   // TODO(nileshagrawal): Merge this with ChromeInvalidationClient::Invalidate.
    102   // Construct the ModelTypeStateMap and send it over with the notification.
    103   invalidation::ObjectId object_id(
    104       object_source,
    105       str_object_id);
    106   syncer::ObjectIdInvalidationMap object_ids_with_states;
    107   if (version == ipc::invalidation::Constants::UNKNOWN) {
    108     object_ids_with_states.Insert(
    109         syncer::Invalidation::InitUnknownVersion(object_id));
    110   } else {
    111     ObjectIdVersionMap::iterator it =
    112         max_invalidation_versions_.find(object_id);
    113     if ((it != max_invalidation_versions_.end()) &&
    114         (version <= it->second)) {
    115       DVLOG(1) << "Dropping redundant invalidation with version " << version;
    116       return;
    117     }
    118     max_invalidation_versions_[object_id] = version;
    119     object_ids_with_states.Insert(
    120         syncer::Invalidation::Init(object_id, version, state));
    121   }
    122 
    123   content::NotificationService::current()->Notify(
    124       chrome::NOTIFICATION_SYNC_REFRESH_REMOTE,
    125       content::Source<Profile>(profile_),
    126       content::Details<const syncer::ObjectIdInvalidationMap>(
    127           &object_ids_with_states));
    128 }
    129 
    130 void ProfileSyncServiceAndroid::OnStateChanged() {
    131   // Notify the java world that our sync state has changed.
    132   JNIEnv* env = AttachCurrentThread();
    133   Java_ProfileSyncService_syncStateChanged(
    134       env, weak_java_profile_sync_service_.get(env).obj());
    135 }
    136 
    137 void ProfileSyncServiceAndroid::EnableSync(JNIEnv* env, jobject) {
    138   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    139   // Don't need to do anything if we're already enabled.
    140   if (sync_prefs_->IsStartSuppressed())
    141     sync_service_->UnsuppressAndStart();
    142   else
    143     DVLOG(2) << "Ignoring call to EnableSync() because sync is already enabled";
    144 }
    145 
    146 void ProfileSyncServiceAndroid::DisableSync(JNIEnv* env, jobject) {
    147   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    148   // Don't need to do anything if we're already disabled.
    149   if (!sync_prefs_->IsStartSuppressed()) {
    150     sync_service_->StopAndSuppress();
    151   } else {
    152     DVLOG(2)
    153         << "Ignoring call to DisableSync() because sync is already disabled";
    154   }
    155 }
    156 
    157 void ProfileSyncServiceAndroid::SignInSync(JNIEnv* env, jobject) {
    158   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    159   // Just return if sync already has everything it needs to start up (sync
    160   // should start up automatically as long as it has credentials). This can
    161   // happen normally if (for example) the user closes and reopens the sync
    162   // settings window quickly during initial startup.
    163   if (sync_service_->IsSyncEnabledAndLoggedIn() &&
    164       sync_service_->IsOAuthRefreshTokenAvailable() &&
    165       sync_service_->HasSyncSetupCompleted()) {
    166     return;
    167   }
    168 
    169   // Enable sync (if we don't have credentials yet, this will enable sync but
    170   // will not start it up - sync will start once credentials arrive).
    171   sync_service_->UnsuppressAndStart();
    172 }
    173 
    174 void ProfileSyncServiceAndroid::SignOutSync(JNIEnv* env, jobject) {
    175   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    176   DCHECK(profile_);
    177   sync_service_->DisableForUser();
    178 
    179   // Need to clear suppress start flag manually
    180   sync_prefs_->SetStartSuppressed(false);
    181 }
    182 
    183 ScopedJavaLocalRef<jstring> ProfileSyncServiceAndroid::QuerySyncStatusSummary(
    184     JNIEnv* env, jobject) {
    185   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    186   DCHECK(profile_);
    187   std::string status(sync_service_->QuerySyncStatusSummaryString());
    188   return ConvertUTF8ToJavaString(env, status);
    189 }
    190 
    191 jboolean ProfileSyncServiceAndroid::SetSyncSessionsId(
    192     JNIEnv* env, jobject obj, jstring tag) {
    193   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    194   DCHECK(profile_);
    195   std::string machine_tag = ConvertJavaStringToUTF8(env, tag);
    196   sync_prefs_->SetSyncSessionsGUID(machine_tag);
    197   return true;
    198 }
    199 
    200 jint ProfileSyncServiceAndroid::GetAuthError(JNIEnv* env, jobject) {
    201   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    202   return sync_service_->GetAuthError().state();
    203 }
    204 
    205 jboolean ProfileSyncServiceAndroid::IsEncryptEverythingEnabled(
    206     JNIEnv* env, jobject) {
    207   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    208   return sync_service_->EncryptEverythingEnabled();
    209 }
    210 
    211 jboolean ProfileSyncServiceAndroid::IsSyncInitialized(JNIEnv* env, jobject) {
    212   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    213   return sync_service_->sync_initialized();
    214 }
    215 
    216 jboolean ProfileSyncServiceAndroid::IsFirstSetupInProgress(
    217     JNIEnv* env, jobject) {
    218   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    219   return sync_service_->FirstSetupInProgress();
    220 }
    221 
    222 jboolean ProfileSyncServiceAndroid::IsPassphraseRequired(JNIEnv* env, jobject) {
    223   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    224   return sync_service_->IsPassphraseRequired();
    225 }
    226 
    227 jboolean ProfileSyncServiceAndroid::IsPassphraseRequiredForDecryption(
    228     JNIEnv* env, jobject obj) {
    229   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    230   // In case of CUSTOM_PASSPHRASE we always sync passwords. Prompt the user for
    231   // a passphrase if cryptographer has any pending keys.
    232   if (sync_service_->GetPassphraseType() == syncer::CUSTOM_PASSPHRASE) {
    233     return !IsCryptographerReady(env, obj);
    234   }
    235   if (sync_service_->IsPassphraseRequiredForDecryption()) {
    236     // Passwords datatype should never prompt for a passphrase, except when
    237     // user is using a custom passphrase. Do not prompt for a passphrase if
    238     // passwords are the only encrypted datatype. This prevents a temporary
    239     // notification for passphrase  when PSS has not completed configuring
    240     // DataTypeManager, after configuration password datatype shall be disabled.
    241     const syncer::ModelTypeSet encrypted_types =
    242         sync_service_->GetEncryptedDataTypes();
    243     return !encrypted_types.Equals(syncer::ModelTypeSet(syncer::PASSWORDS));
    244   }
    245   return false;
    246 }
    247 
    248 jboolean ProfileSyncServiceAndroid::IsPassphraseRequiredForExternalType(
    249     JNIEnv* env, jobject) {
    250   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    251   return
    252       sync_service_->passphrase_required_reason() == syncer::REASON_DECRYPTION;
    253 }
    254 
    255 jboolean ProfileSyncServiceAndroid::IsUsingSecondaryPassphrase(
    256     JNIEnv* env, jobject) {
    257   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    258   return sync_service_->IsUsingSecondaryPassphrase();
    259 }
    260 
    261 jboolean ProfileSyncServiceAndroid::SetDecryptionPassphrase(
    262     JNIEnv* env, jobject obj, jstring passphrase) {
    263   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    264   std::string key = ConvertJavaStringToUTF8(env, passphrase);
    265   return sync_service_->SetDecryptionPassphrase(key);
    266 }
    267 
    268 void ProfileSyncServiceAndroid::SetEncryptionPassphrase(
    269     JNIEnv* env, jobject obj, jstring passphrase, jboolean is_gaia) {
    270   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    271   std::string key = ConvertJavaStringToUTF8(env, passphrase);
    272   sync_service_->SetEncryptionPassphrase(
    273       key,
    274       is_gaia ? ProfileSyncService::IMPLICIT : ProfileSyncService::EXPLICIT);
    275 }
    276 
    277 jboolean ProfileSyncServiceAndroid::IsCryptographerReady(JNIEnv* env, jobject) {
    278   syncer::ReadTransaction trans(FROM_HERE, sync_service_->GetUserShare());
    279   return sync_service_->IsCryptographerReady(&trans);
    280 }
    281 
    282 jint ProfileSyncServiceAndroid::GetPassphraseType(JNIEnv* env, jobject) {
    283   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    284   return sync_service_->GetPassphraseType();
    285 }
    286 
    287 jboolean ProfileSyncServiceAndroid::HasExplicitPassphraseTime(
    288     JNIEnv* env, jobject) {
    289   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    290   base::Time passphrase_time = sync_service_->GetExplicitPassphraseTime();
    291   return !passphrase_time.is_null();
    292 }
    293 
    294 ScopedJavaLocalRef<jstring>
    295     ProfileSyncServiceAndroid::GetSyncEnterGooglePassphraseBodyWithDateText(
    296         JNIEnv* env, jobject) {
    297   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    298   base::Time passphrase_time = sync_service_->GetExplicitPassphraseTime();
    299   base::string16 passphrase_time_str =
    300       base::TimeFormatShortDate(passphrase_time);
    301   return base::android::ConvertUTF16ToJavaString(env,
    302       l10n_util::GetStringFUTF16(
    303         IDS_SYNC_ENTER_GOOGLE_PASSPHRASE_BODY_WITH_DATE,
    304         passphrase_time_str));
    305 }
    306 
    307 ScopedJavaLocalRef<jstring>
    308     ProfileSyncServiceAndroid::GetSyncEnterCustomPassphraseBodyWithDateText(
    309         JNIEnv* env, jobject) {
    310   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    311   base::Time passphrase_time = sync_service_->GetExplicitPassphraseTime();
    312   base::string16 passphrase_time_str =
    313       base::TimeFormatShortDate(passphrase_time);
    314   return base::android::ConvertUTF16ToJavaString(env,
    315       l10n_util::GetStringFUTF16(IDS_SYNC_ENTER_PASSPHRASE_BODY_WITH_DATE,
    316         passphrase_time_str));
    317 }
    318 
    319 ScopedJavaLocalRef<jstring>
    320     ProfileSyncServiceAndroid::GetCurrentSignedInAccountText(
    321         JNIEnv* env, jobject) {
    322   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    323   const std::string& sync_username =
    324       SigninManagerFactory::GetForProfile(profile_)->GetAuthenticatedUsername();
    325   return base::android::ConvertUTF16ToJavaString(env,
    326       l10n_util::GetStringFUTF16(
    327           IDS_SYNC_ACCOUNT_SYNCING_TO_USER,
    328           base::ASCIIToUTF16(sync_username)));
    329 }
    330 
    331 ScopedJavaLocalRef<jstring>
    332     ProfileSyncServiceAndroid::GetSyncEnterCustomPassphraseBodyText(
    333         JNIEnv* env, jobject) {
    334   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    335   return ConvertUTF8ToJavaString(
    336       env, l10n_util::GetStringUTF8(IDS_SYNC_ENTER_PASSPHRASE_BODY));
    337 }
    338 
    339 jboolean ProfileSyncServiceAndroid::IsSyncKeystoreMigrationDone(
    340       JNIEnv* env, jobject) {
    341   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    342   syncer::SyncStatus status;
    343   bool is_status_valid = sync_service_->QueryDetailedSyncStatus(&status);
    344   return is_status_valid && !status.keystore_migration_time.is_null();
    345 }
    346 
    347 jlong ProfileSyncServiceAndroid::GetEnabledDataTypes(JNIEnv* env,
    348                                                      jobject obj) {
    349   jlong model_type_selection = 0;
    350   syncer::ModelTypeSet types = sync_service_->GetActiveDataTypes();
    351   types.PutAll(syncer::ControlTypes());
    352   if (types.Has(syncer::BOOKMARKS)) {
    353     model_type_selection |= BOOKMARK;
    354   }
    355   if (types.Has(syncer::AUTOFILL)) {
    356     model_type_selection |= AUTOFILL;
    357   }
    358   if (types.Has(syncer::AUTOFILL_PROFILE)) {
    359     model_type_selection |= AUTOFILL_PROFILE;
    360   }
    361   if (types.Has(syncer::PASSWORDS)) {
    362     model_type_selection |= PASSWORD;
    363   }
    364   if (types.Has(syncer::TYPED_URLS)) {
    365     model_type_selection |= TYPED_URL;
    366   }
    367   if (types.Has(syncer::SESSIONS)) {
    368     model_type_selection |= SESSION;
    369   }
    370   if (types.Has(syncer::HISTORY_DELETE_DIRECTIVES)) {
    371     model_type_selection |= HISTORY_DELETE_DIRECTIVE;
    372   }
    373   if (types.Has(syncer::PROXY_TABS)) {
    374     model_type_selection |= PROXY_TABS;
    375   }
    376   if (types.Has(syncer::FAVICON_IMAGES)) {
    377     model_type_selection |= FAVICON_IMAGE;
    378   }
    379   if (types.Has(syncer::FAVICON_TRACKING)) {
    380     model_type_selection |= FAVICON_TRACKING;
    381   }
    382   if (types.Has(syncer::DEVICE_INFO)) {
    383     model_type_selection |= DEVICE_INFO;
    384   }
    385   if (types.Has(syncer::NIGORI)) {
    386     model_type_selection |= NIGORI;
    387   }
    388   if (types.Has(syncer::EXPERIMENTS)) {
    389     model_type_selection |= EXPERIMENTS;
    390   }
    391   return model_type_selection;
    392 }
    393 
    394 void ProfileSyncServiceAndroid::SetPreferredDataTypes(
    395     JNIEnv* env, jobject obj,
    396     jboolean sync_everything,
    397     jlong model_type_selection) {
    398   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    399   syncer::ModelTypeSet types;
    400   // Note: only user selectable types should be included here.
    401   if (model_type_selection & AUTOFILL)
    402     types.Put(syncer::AUTOFILL);
    403   if (model_type_selection & BOOKMARK)
    404     types.Put(syncer::BOOKMARKS);
    405   if (model_type_selection & PASSWORD)
    406     types.Put(syncer::PASSWORDS);
    407   if (model_type_selection & PROXY_TABS)
    408     types.Put(syncer::PROXY_TABS);
    409   if (model_type_selection & TYPED_URL)
    410     types.Put(syncer::TYPED_URLS);
    411   DCHECK(syncer::UserSelectableTypes().HasAll(types));
    412   sync_service_->OnUserChoseDatatypes(sync_everything, types);
    413 }
    414 
    415 void ProfileSyncServiceAndroid::SetSetupInProgress(
    416     JNIEnv* env, jobject obj, jboolean in_progress) {
    417   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    418   sync_service_->SetSetupInProgress(in_progress);
    419 }
    420 
    421 void ProfileSyncServiceAndroid::SetSyncSetupCompleted(
    422     JNIEnv* env, jobject obj) {
    423   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    424   sync_service_->SetSyncSetupCompleted();
    425 }
    426 
    427 jboolean ProfileSyncServiceAndroid::HasSyncSetupCompleted(
    428     JNIEnv* env, jobject obj) {
    429   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    430   return sync_service_->HasSyncSetupCompleted();
    431 }
    432 
    433 jboolean ProfileSyncServiceAndroid::IsStartSuppressed(
    434     JNIEnv* env, jobject obj) {
    435   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    436   return sync_prefs_->IsStartSuppressed();
    437 }
    438 
    439 void ProfileSyncServiceAndroid::EnableEncryptEverything(
    440     JNIEnv* env, jobject obj) {
    441   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    442   sync_service_->EnableEncryptEverything();
    443 }
    444 
    445 jboolean ProfileSyncServiceAndroid::HasKeepEverythingSynced(
    446     JNIEnv* env, jobject) {
    447   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    448   return sync_prefs_->HasKeepEverythingSynced();
    449 }
    450 
    451 jboolean ProfileSyncServiceAndroid::HasUnrecoverableError(
    452     JNIEnv* env, jobject) {
    453   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    454   return sync_service_->HasUnrecoverableError();
    455 }
    456 
    457 ScopedJavaLocalRef<jstring> ProfileSyncServiceAndroid::GetAboutInfoForTest(
    458     JNIEnv* env, jobject) {
    459   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    460 
    461   scoped_ptr<base::DictionaryValue> about_info =
    462       sync_ui_util::ConstructAboutInformation(sync_service_);
    463   std::string about_info_json;
    464   base::JSONWriter::Write(about_info.get(), &about_info_json);
    465 
    466   return ConvertUTF8ToJavaString(env, about_info_json);
    467 }
    468 
    469 jlong ProfileSyncServiceAndroid::GetLastSyncedTimeForTest(
    470     JNIEnv* env, jobject obj) {
    471   // Use profile preferences here instead of SyncPrefs to avoid an extra
    472   // conversion, since SyncPrefs::GetLastSyncedTime() converts the stored value
    473   // to to base::Time.
    474   return static_cast<jlong>(
    475       profile_->GetPrefs()->GetInt64(sync_driver::prefs::kSyncLastSyncedTime));
    476 }
    477 
    478 void ProfileSyncServiceAndroid::NudgeSyncer(JNIEnv* env,
    479                                             jobject obj,
    480                                             jint objectSource,
    481                                             jstring objectId,
    482                                             jlong version,
    483                                             jstring state) {
    484   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    485   SendNudgeNotification(objectSource, ConvertJavaStringToUTF8(env, objectId),
    486                         version, ConvertJavaStringToUTF8(env, state));
    487 }
    488 
    489 void ProfileSyncServiceAndroid::NudgeSyncerForAllTypes(JNIEnv* env,
    490                                                        jobject obj) {
    491   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
    492   syncer::ObjectIdInvalidationMap object_ids_with_states;
    493   content::NotificationService::current()->Notify(
    494         chrome::NOTIFICATION_SYNC_REFRESH_REMOTE,
    495         content::Source<Profile>(profile_),
    496         content::Details<const syncer::ObjectIdInvalidationMap>(
    497             &object_ids_with_states));
    498 }
    499 
    500 // static
    501 ProfileSyncServiceAndroid*
    502     ProfileSyncServiceAndroid::GetProfileSyncServiceAndroid() {
    503   return reinterpret_cast<ProfileSyncServiceAndroid*>(
    504           Java_ProfileSyncService_getProfileSyncServiceAndroid(
    505       AttachCurrentThread(), base::android::GetApplicationContext()));
    506 }
    507 
    508 static jlong Init(JNIEnv* env, jobject obj) {
    509   ProfileSyncServiceAndroid* profile_sync_service_android =
    510       new ProfileSyncServiceAndroid(env, obj);
    511   profile_sync_service_android->Init();
    512   return reinterpret_cast<intptr_t>(profile_sync_service_android);
    513 }
    514 
    515 // static
    516 bool ProfileSyncServiceAndroid::Register(JNIEnv* env) {
    517   return RegisterNativesImpl(env);
    518 }
    519