backoff milliseconds from now.
+ *
+ * Don't call this unless you are inside `run`.
+ *
+ * @param backoff time to wait in milliseconds.
+ */
+ @Override
+ public void requestBackoff(final long backoff) {
+ if (this.backoffHandler == null) {
+ throw new IllegalStateException("No backoff handler: requesting backoff outside run()?");
+ }
+ if (backoff > 0) {
+ // Fuzz the backoff time (up to 25% more) to prevent client lock-stepping; agrees with desktop.
+ final long fuzzedBackoff = backoff + Math.round((double) backoff * 0.25d * Math.random());
+ this.backoffHandler.extendEarliestNextRequest(System.currentTimeMillis() + fuzzedBackoff);
+ }
+ }
+
+ @Override
+ public boolean shouldBackOffStorage() {
+ if (thisSyncIsForced) {
+ /*
+ * If the user asks us to sync, we should sync regardless. This path is
+ * hit if the user force syncs and we restart a session after a
+ * freshStart.
+ */
+ return false;
+ }
+
+ if (nodeAssignmentDelegate.wantNodeAssignment()) {
+ /*
+ * We recently had a 401 and we aborted the last sync. We should kick off
+ * another sync to fetch a new node/weave cluster URL, since ours is
+ * stale. If we have a user authentication error, the next sync will
+ * determine that and will stop requesting node assignment, so this will
+ * only force one abnormally scheduled sync.
+ */
+ return false;
+ }
+
+ if (this.backoffHandler == null) {
+ throw new IllegalStateException("No backoff handler: checking backoff outside run()?");
+ }
+ return this.backoffHandler.delayMilliseconds() > 0;
+ }
+
+ /**
+ * Asynchronously request an immediate sync, optionally syncing only the given
+ * named stages.
+ *
+ * Returns immediately.
+ *
+ * @param account
+ * the Android Account instance to sync.
+ * @param stageNames
+ * stage names to sync, or null to sync all known stages.
+ */
+ public static void requestImmediateSync(final Account account, final String[] stageNames) {
+ requestImmediateSync(account, stageNames, null);
+ }
+
+ /**
+ * Asynchronously request an immediate sync, optionally syncing only the given
+ * named stages.
+ *
+ * Returns immediately.
+ *
+ * @param account
+ * the Android Account instance to sync.
+ * @param stageNames
+ * stage names to sync, or null to sync all known stages.
+ * @param moreExtras
+ * bundle of extras to give to the sync, or null
+ */
+ public static void requestImmediateSync(final Account account, final String[] stageNames, Bundle moreExtras) {
+ if (account == null) {
+ Logger.warn(LOG_TAG, "Not requesting immediate sync because Android Account is null.");
+ return;
+ }
+
+ final Bundle extras = new Bundle();
+ Utils.putStageNamesToSync(extras, stageNames, null);
+ extras.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true);
+
+ if (moreExtras != null) {
+ extras.putAll(moreExtras);
+ }
+
+ ContentResolver.requestSync(account, BrowserContract.AUTHORITY, extras);
+ }
+
+ @Override
+ public void onPerformSync(final Account account,
+ final Bundle extras,
+ final String authority,
+ final ContentProviderClient provider,
+ final SyncResult syncResult) {
+ syncStartTimestamp = System.currentTimeMillis();
+
+ Logger.setThreadLogTag(SyncConstants.GLOBAL_LOG_TAG);
+ Logger.resetLogging();
+ Utils.reseedSharedRandom(); // Make sure we don't work with the same random seed for too long.
+
+ // Set these so that we don't need to thread them through assorted calls and callbacks.
+ this.syncResult = syncResult;
+ this.localAccount = account;
+
+ SyncAccountParameters params;
+ try {
+ params = SyncAccounts.blockingFromAndroidAccountV0(mContext, AccountManager.get(mContext), this.localAccount);
+ } catch (Exception e) {
+ // Updates syncResult and (harmlessly) calls notifyMonitor().
+ processException(null, e);
+ return;
+ }
+
+ // params and the following fields are non-null at this point.
+ final String username = params.username; // Encoded with Utils.usernameFromAccount.
+ final String password = params.password;
+ final String serverURL = params.serverURL;
+ final String syncKey = params.syncKey;
+
+ final AtomicBoolean setNextSync = new AtomicBoolean(true);
+ final SyncAdapter self = this;
+ final Runnable runnable = new Runnable() {
+ @Override
+ public void run() {
+ Logger.trace(LOG_TAG, "AccountManagerCallback invoked.");
+ // TODO: N.B.: Future must not be used on the main thread.
+ try {
+ if (Logger.LOG_PERSONAL_INFORMATION) {
+ Logger.pii(LOG_TAG, "Syncing account named " + account.name +
+ " for authority " + authority + ".");
+ } else {
+ // Replace "foo@bar.com" with "XXX@XXX.XXX".
+ Logger.info(LOG_TAG, "Syncing account named like " + Utils.obfuscateEmail(account.name) +
+ " for authority " + authority + ".");
+ }
+
+ // We dump this information right away to help with debugging.
+ Logger.debug(LOG_TAG, "Username: " + username);
+ Logger.debug(LOG_TAG, "Server: " + serverURL);
+ if (Logger.LOG_PERSONAL_INFORMATION) {
+ Logger.debug(LOG_TAG, "Password: " + password);
+ Logger.debug(LOG_TAG, "Sync key: " + syncKey);
+ } else {
+ Logger.debug(LOG_TAG, "Password? " + (password != null));
+ Logger.debug(LOG_TAG, "Sync key? " + (syncKey != null));
+ }
+
+ // Support multiple accounts by mapping each server/account pair to a branch of the
+ // shared preferences space.
+ final String product = GlobalConstants.BROWSER_INTENT_PACKAGE;
+ final String profile = Constants.DEFAULT_PROFILE;
+ final long version = SyncConfiguration.CURRENT_PREFS_VERSION;
+ self.accountSharedPreferences = Utils.getSharedPreferences(mContext, product, username, serverURL, profile, version);
+ self.clientsDataDelegate = new SharedPreferencesClientsDataDelegate(accountSharedPreferences);
+ self.backoffHandler = new PrefsBackoffHandler(accountSharedPreferences, SyncConstants.BACKOFF_PREF_SUFFIX_11);
+ final String nodeWeaveURL = Utils.nodeWeaveURL(serverURL, username);
+ self.nodeAssignmentDelegate = new SharedPreferencesNodeAssignmentCallback(accountSharedPreferences, nodeWeaveURL);
+
+ Logger.info(LOG_TAG,
+ "Client is named '" + clientsDataDelegate.getClientName() + "'" +
+ ", has client guid " + clientsDataDelegate.getAccountGUID() +
+ ", and has " + clientsDataDelegate.getClientsCount() + " clients.");
+
+ final boolean thisSyncIsForced = (extras != null) && (extras.getBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, false));
+ final long delayMillis = backoffHandler.delayMilliseconds();
+ boolean shouldSync = thisSyncIsForced || (delayMillis <= 0L);
+ if (!shouldSync) {
+ long remainingSeconds = delayMillis / 1000;
+ syncResult.delayUntil = remainingSeconds + BACKOFF_PAD_SECONDS;
+ setNextSync.set(false);
+ self.notifyMonitor();
+ return;
+ }
+
+ final String prefsPath = Utils.getPrefsPath(product, username, serverURL, profile, version);
+ self.performSync(account, extras, authority, provider, syncResult,
+ username, password, prefsPath, serverURL, syncKey);
+ } catch (Exception e) {
+ self.processException(null, e);
+ return;
+ }
+ }
+ };
+
+ synchronized (syncMonitor) {
+ // Perform the work in a new thread from within this synchronized block,
+ // which allows us to be waiting on the monitor before the callback can
+ // notify us in a failure case. Oh, concurrent programming.
+ new Thread(runnable).start();
+
+ // Start our stale connection monitor thread.
+ ConnectionMonitorThread stale = new ConnectionMonitorThread();
+ stale.start();
+
+ Logger.trace(LOG_TAG, "Waiting on sync monitor.");
+ try {
+ syncMonitor.wait();
+
+ if (setNextSync.get()) {
+ long interval = getSyncInterval(clientsDataDelegate);
+ long next = System.currentTimeMillis() + interval;
+
+ if (thisSyncIsForced) {
+ Logger.info(LOG_TAG, "Setting minimum next sync time to " + next + " (" + interval + "ms from now).");
+ self.backoffHandler.setEarliestNextRequest(next);
+ } else {
+ Logger.info(LOG_TAG, "Extending minimum next sync time to " + next + " (" + interval + "ms from now).");
+ self.backoffHandler.extendEarliestNextRequest(next);
+ }
+ }
+ Logger.info(LOG_TAG, "Sync took " + Utils.formatDuration(syncStartTimestamp, System.currentTimeMillis()) + ".");
+ } catch (InterruptedException e) {
+ Logger.warn(LOG_TAG, "Waiting on sync monitor interrupted.", e);
+ } finally {
+ // And we're done with HTTP stuff.
+ stale.shutdown();
+ }
+ }
+ }
+
+ public int getSyncInterval(ClientsDataDelegate clientsDataDelegate) {
+ // Must have been a problem that means we can't access the Account.
+ if (this.localAccount == null) {
+ return SINGLE_DEVICE_INTERVAL_MILLISECONDS;
+ }
+
+ int clientsCount = clientsDataDelegate.getClientsCount();
+ if (clientsCount <= 1) {
+ return SINGLE_DEVICE_INTERVAL_MILLISECONDS;
+ }
+
+ return MULTI_DEVICE_INTERVAL_MILLISECONDS;
+ }
+
+ /**
+ * Now that we have a sync key and password, go ahead and do the work.
+ * @throws NoSuchAlgorithmException
+ * @throws IllegalArgumentException
+ * @throws SyncConfigurationException
+ * @throws AlreadySyncingException
+ * @throws NonObjectJSONException
+ * @throws ParseException
+ * @throws IOException
+ * @throws CryptoException
+ */
+ protected void performSync(final Account account,
+ final Bundle extras,
+ final String authority,
+ final ContentProviderClient provider,
+ final SyncResult syncResult,
+ final String username,
+ final String password,
+ final String prefsPath,
+ final String serverURL,
+ final String syncKey)
+ throws NoSuchAlgorithmException,
+ SyncConfigurationException,
+ IllegalArgumentException,
+ AlreadySyncingException,
+ IOException, ParseException,
+ NonObjectJSONException, CryptoException {
+ Logger.trace(LOG_TAG, "Performing sync.");
+
+ /**
+ * Bug 769745: pickle Sync account parameters to JSON file. Un-pickle in
+ * SyncAccounts.syncAccountsExist.
+ */
+ try {
+ // Constructor can throw on nulls, which should not happen -- but let's be safe.
+ final SyncAccountParameters params = new SyncAccountParameters(mContext, null,
+ account.name, // Un-encoded, like "test@mozilla.com".
+ syncKey,
+ password,
+ serverURL,
+ null, // We'll re-fetch cluster URL; not great, but not harmful.
+ clientsDataDelegate.getClientName(),
+ clientsDataDelegate.getAccountGUID());
+
+ // Bug 772971: pickle Sync account parameters on background thread to
+ // avoid strict mode warnings.
+ ThreadPool.run(new Runnable() {
+ @Override
+ public void run() {
+ final boolean syncAutomatically = ContentResolver.getSyncAutomatically(account, authority);
+ try {
+ AccountPickler.pickle(mContext, Constants.ACCOUNT_PICKLE_FILENAME, params, syncAutomatically);
+ } catch (Exception e) {
+ // Should never happen, but we really don't want to die in a background thread.
+ Logger.warn(LOG_TAG, "Got exception pickling current account details; ignoring.", e);
+ }
+ }
+ });
+ } catch (IllegalArgumentException e) {
+ // Do nothing.
+ }
+
+ if (username == null) {
+ throw new IllegalArgumentException("username must not be null.");
+ }
+
+ if (syncKey == null) {
+ throw new SyncConfigurationException();
+ }
+
+ final KeyBundle keyBundle = new KeyBundle(username, syncKey);
+
+ if (keyBundle == null ||
+ keyBundle.getEncryptionKey() == null ||
+ keyBundle.getHMACKey() == null) {
+ throw new SyncConfigurationException();
+ }
+
+ final AuthHeaderProvider authHeaderProvider = new BasicAuthHeaderProvider(username, password);
+ final SharedPreferences prefs = getContext().getSharedPreferences(prefsPath, Utils.SHARED_PREFERENCES_MODE);
+ final SyncConfiguration config = new Sync11Configuration(username, authHeaderProvider, prefs, keyBundle);
+
+ Collection