import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
/**
 * Called when the child account status has been determined or updated.
 * Can be overridden by subclasses to avoid native calls and calls into dependencies in testing.
 *
 * @param oldValue The old child account status. This is null when the child account status
 *         has been determined for the first time after the browser has started.
 */
protected void onChildAccountStatusUpdated(Boolean oldValue) {
    Log.v(TAG, "hasChildAccount: " + mHasChildAccount + " oldHasChildAccount: " + oldValue);
    if (mHasChildAccount) {
        if (oldValue == null) {
            // This is the first time we have determined the child account status, which means
            // the browser is starting up. If we are not signed in yet, the startup code will
            // sign in and call us back in onChildAccountSigninComplete().
            if (ChromeSigninController.get(mContext).getSignedInUser() == null) return;
        } else if (!oldValue.booleanValue()) {
            // We have switched from no child account to child account while the browser
            // is running. Sign in (which will call us back in onChildAccountSigninComplete()).
            SigninManager signinManager = SigninManager.get(mContext);
            Account account = AccountManagerHelper.get(mContext).getSingleGoogleAccount();
            signinManager.signInToSelectedAccount(null, account,
                    SigninManager.SIGNIN_TYPE_FORCED_CHILD_ACCOUNT,
                    SigninManager.SIGNIN_SYNC_IMMEDIATELY, false, null);
            return;
        }
    }
    // Fallthrough for all other cases: Propagate child account status to native code.
    // This is a no-op if the child account status does not change.
    nativeSetIsChildAccount(mHasChildAccount);
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
@Override
public void deliverMessage(final String to, final Bundle data) {
    @Nullable
    Account account = ChromeSigninController.get(this).getSignedInUser();
    if (account == null) {
        // This should never happen, because this code should only be run if a user is
        // signed-in.
        Log.w(TAG, "No signed-in user; cannot send message to data center");
        return;
    }

    // Attempt to retrieve a token for the user.
    OAuth2TokenService.getOAuth2AccessToken(this, null, account,
            SyncConstants.CHROME_SYNC_OAUTH2_SCOPE,
            new AccountManagerHelper.GetAuthTokenCallback() {
                @Override
                public void tokenAvailable(String token) {
                    sendUpstreamMessage(to, data, token);
                }
            });
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
@Override
public void onAccountSelectionConfirmed(String accountName) {
    final Account account =
            AccountManagerHelper.get(getContext()).getAccountFromName(accountName);
    SignInFlowObserver signInCallback = new SignInFlowObserver() {
        @Override
        public void onSigninComplete() {
            mAccountFirstRunView.switchToSignedMode();
            SigninManager.get(getOwnerActivity()).logInSignedInUser();
            SigninPromoUma.recordAction(SigninPromoUma.SIGNIN_PROMO_ACCEPTED);
        }

        @Override
        public void onSigninCancelled() {
            SigninPromoUma.recordAction(SigninPromoUma.SIGNIN_PROMO_DECLINED);
            dismiss();
        }
    };
    SigninManager.get(getOwnerActivity().getApplicationContext()).signInToSelectedAccount(
            getOwnerActivity(), account, SigninManager.SIGNIN_TYPE_INTERACTIVE,
            SigninManager.SIGNIN_SYNC_IMMEDIATELY, false, signInCallback);
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
/**
 * Called by native to retrieve OAuth2 tokens.
 *
 * @param username The native username (full address).
 * @param scope The scope to get an auth token for (without Android-style 'oauth2:' prefix).
 * @param nativeCallback The pointer to the native callback that should be run upon completion.
 */
@CalledByNative
public static void getOAuth2AuthToken(
        Context context, String username, String scope, final long nativeCallback) {
    Account account = getAccountOrNullFromUsername(context, username);
    if (account == null) {
        ThreadUtils.postOnUiThread(new Runnable() {
            @Override
            public void run() {
                nativeOAuth2TokenFetched(null, nativeCallback);
            }
        });
        return;
    }
    String oauth2Scope = OAUTH2_SCOPE_PREFIX + scope;

    AccountManagerHelper accountManagerHelper = AccountManagerHelper.get(context);
    accountManagerHelper.getAuthTokenFromForeground(
            null, account, oauth2Scope, new AccountManagerHelper.GetAuthTokenCallback() {
                @Override
                public void tokenAvailable(String token) {
                    nativeOAuth2TokenFetched(token, nativeCallback);
                }
            });
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
private void performResignin(String newName,
                             final boolean isSyncWanted,
                             final Set<Integer> dataTypes) {
    // This is the correct account now.
    final Account account = AccountManagerHelper.createAccountFromName(newName);

    mSigninManager.startSignIn(null, account, true, new SignInFlowObserver() {
        @Override
        public void onSigninComplete() {
            mProfileSyncService.setSetupInProgress(false);

            if (isSyncWanted) {
                mSyncController.start();
            } else {
                mSyncController.stop();
            }

            validateAccountSettings(true);
        }

        @Override
        public void onSigninCancelled() {
        }
    });
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
/**
 * Trigger Chromium sign in of the given account.
 *
 * This also ensure that sync setup is not in progress anymore, so sync will start after
 * sync initialization has happened.
 *
 * @param activity the current activity.
 * @param accountName the full account name.
 */
@VisibleForTesting
public void signIn(Activity activity, String accountName) {
    final Account account = AccountManagerHelper.createAccountFromName(accountName);

    // The SigninManager handles most of the sign-in flow, and doFinishSignIn handles the
    // ChromeShell specific details.
    SigninManager signinManager = SigninManager.get(mContext);
    signinManager.onFirstRunCheckDone();
    final boolean passive = false;
    signinManager.startSignIn(activity, account, passive, new SignInFlowObserver() {
        @Override
        public void onSigninComplete() {
            SigninManager.get(mContext).logInSignedInUser();
            mProfileSyncService.setSetupInProgress(false);
            start();
        }

        @Override
        public void onSigninCancelled() {
            stop();
        }
    });
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
/**
 * Trigger Chromium sign in of the given account.
 *
 * This also ensure that sync setup is not in progress anymore, so sync will start after
 * sync initialization has happened.
 *
 * @param activity the current activity.
 * @param accountName the full account name.
 */
public void signIn(Activity activity, String accountName) {
    final Account account = AccountManagerHelper.createAccountFromName(accountName);

    // The SigninManager handles most of the sign-in flow, and doFinishSignIn handles the
    // Chromium testshell specific details.
    SigninManager signinManager = SigninManager.get(mContext);
    signinManager.onFirstRunCheckDone();
    final boolean passive = false;
    signinManager.startSignIn(activity, account, passive, new SigninManager.Observer() {
        @Override
        public void onSigninComplete() {
            SigninManager.get(mContext).logInSignedInUser();
            mProfileSyncService.setSetupInProgress(false);
            mProfileSyncService.syncSignIn();
            start();
        }

        @Override
        public void onSigninCancelled() {
            stop();
        }
    });
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
/**
 * Called by native to retrieve OAuth2 tokens.
 *
 * @param username The native username (full address).
 * @param scope The scope to get an auth token for (without Android-style 'oauth2:' prefix).
 * @param nativeCallback The pointer to the native callback that should be run upon completion.
 */
@CalledByNative
public static void getOAuth2AuthToken(
        Context context, String username, String scope, final int nativeCallback) {
    Account account = getAccountOrNullFromUsername(context, username);
    if (account == null) {
        nativeOAuth2TokenFetched(null, false, nativeCallback);
        return;
    }
    String oauth2Scope = OAUTH2_SCOPE_PREFIX + scope;

    AccountManagerHelper accountManagerHelper = AccountManagerHelper.get(context);
    accountManagerHelper.getAuthTokenFromForeground(
        null, account, oauth2Scope, new AccountManagerHelper.GetAuthTokenCallback() {
            @Override
            public void tokenAvailable(String token) {
                nativeOAuth2TokenFetched(
                    token, token != null, nativeCallback);
            }
        });
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
/**
 * Register with Android Sync Manager. This is what causes the "Chrome" option to appear in
 * Settings -> Accounts / Sync .
 *
 * @param account the account to enable Chrome sync on
 */
private void makeSyncable(Account account) {
    synchronized (mCachedSettings) {
        mCachedSettings.setIsSyncable(account);
    }

    StrictMode.ThreadPolicy oldPolicy = temporarilyAllowDiskWritesAndDiskReads();
    // Disable the syncability of Chrome for all other accounts. Don't use
    // our cache as we're touching many accounts that aren't signed in, so this saves
    // extra calls to Android sync configuration.
    Account[] googleAccounts = AccountManagerHelper.get(mApplicationContext).
            getGoogleAccounts();
    for (Account accountToSetNotSyncable : googleAccounts) {
        if (!accountToSetNotSyncable.equals(account) &&
                mSyncContentResolverWrapper.getIsSyncable(
                        accountToSetNotSyncable, mContractAuthority) > 0) {
            mSyncContentResolverWrapper.setIsSyncable(accountToSetNotSyncable,
                    mContractAuthority, 0);
        }
    }
    StrictMode.setThreadPolicy(oldPolicy);
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
@Override
public void requestAuthToken(final PendingIntent pendingIntent,
        @Nullable String invalidAuthToken) {
    @Nullable Account account = ChromeSigninController.get(this).getSignedInUser();
    if (account == null) {
        // This should never happen, because this code should only be run if a user is
        // signed-in.
        Log.w(TAG, "No signed-in user; cannot send message to data center");
        return;
    }

    // Attempt to retrieve a token for the user. This method will also invalidate
    // invalidAuthToken if it is non-null.
    AccountManagerHelper.get(this).getNewAuthTokenFromForeground(
            account, invalidAuthToken, getOAuth2ScopeWithType(),
            new AccountManagerHelper.GetAuthTokenCallback() {
                @Override
                public void tokenAvailable(String token) {
                    if (token != null) {
                        setAuthToken(InvalidationService.this.getApplicationContext(),
                                pendingIntent, token, getOAuth2ScopeWithType());
                    }
                }
            });
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
/**
 * @return The child account status if it can be determined immediately, or null otherwise.
 */
@Nullable
private Boolean getPredeterminedChildStatus() {
    if (!nativeIsChildAccountDetectionEnabled()) {
        Log.v(TAG, "Child account detection disabled");
        return false;
    }
    AccountManagerHelper accountManagerHelper = AccountManagerHelper.get(mContext);
    // This isn't strictly necessary, as getGoogleAccounts() will return an empty list if the
    // GET_ACCOUNTS permission is not granted, but it makes the behavior explicit.
    if (!accountManagerHelper.hasGetAccountsPermission()) {
        Log.v(TAG, "GET_ACCOUNTS permission not granted");
        return false;
    }
    Account[] googleAccounts = accountManagerHelper.getGoogleAccounts();
    if (googleAccounts.length != 1) {
        if (CommandLine.getInstance().hasSwitch(ChromeSwitches.CHILD_ACCOUNT)) {
            Log.w(TAG, "Ignoring --" + ChromeSwitches.CHILD_ACCOUNT + " command line flag "
                    + "because there are " + googleAccounts.length + " Google accounts on the "
                    + "device");
        } else {
            Log.v(TAG, googleAccounts.length + " Google accounts on the device");
        }
        return false;
    }
    String childAccountName =
            CommandLine.getInstance().getSwitchValue(ChromeSwitches.CHILD_ACCOUNT);
    String accountName = googleAccounts[0].name;
    if (childAccountName != null && accountName.equals(childAccountName)) {
        Log.v(TAG, "Child account forced via command line for " + childAccountName);
        return true;
    }
    return null;
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
/**
 * This is called once per ChromeApplication instance, which get created per process
 * (browser OR renderer).  Don't stick anything in here that shouldn't be called multiple times
 * during Chrome's lifetime.
 */
@Override
public void onCreate() {
    UmaUtils.recordMainEntryPointTime();
    super.onCreate();
    UiUtils.setKeyboardShowingDelegate(new UiUtils.KeyboardShowingDelegate() {
        @Override
        public boolean disableKeyboardCheck(Context context, View view) {
            Activity activity = null;
            if (context instanceof Activity) {
                activity = (Activity) context;
            } else if (view != null && view.getContext() instanceof Activity) {
                activity = (Activity) view.getContext();
            }

            // For multiwindow mode we do not track keyboard visibility.
            return activity != null && MultiWindowUtils.getInstance().isMultiWindow(activity);
        }
    });

    // Initialize the AccountManagerHelper with the correct AccountManagerDelegate. Must be done
    // only once and before AccountMangerHelper.get(...) is called to avoid using the
    // default AccountManagerDelegate.
    AccountManagerHelper.initializeAccountManagerHelper(this, createAccountManagerDelegate());

    // Set the unique identification generator for invalidations.  The
    // invalidations system can start and attempt to fetch the client ID
    // very early.  We need this generator to be ready before that happens.
    UniqueIdInvalidationClientNameGenerator.doInitializeAndInstallGenerator(this);

    // Set minimum Tango log level. This sets an in-memory static field, and needs to be
    // set in the ApplicationContext instead of an activity, since Tango can be woken up
    // by the system directly though messages from GCM.
    AndroidLogger.setMinimumAndroidLogLevel(Log.WARN);

    // Set up the identification generator for sync. The ID is actually generated
    // in the SyncController constructor.
    UniqueIdentificationGeneratorFactory.registerGenerator(SyncController.GENERATOR_ID,
            new UuidBasedUniqueIdentificationGenerator(this, SESSIONS_UUID_PREF_KEY), false);
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
private static Account getAccountOrNullFromUsername(Context context, String username) {
    if (username == null) {
        Log.e(TAG, "Username is null");
        return null;
    }

    AccountManagerHelper accountManagerHelper = AccountManagerHelper.get(context);
    Account account = accountManagerHelper.getAccountFromName(username);
    if (account == null) {
        Log.e(TAG, "Account not found for provided username.");
        return null;
    }
    return account;
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
/**
 * Called by native to list the activite accounts in the OS.
 */
@VisibleForTesting
@CalledByNative
public static String[] getSystemAccounts(Context context) {
    AccountManagerHelper accountManagerHelper = AccountManagerHelper.get(context);
    java.util.List<String> accountNames = accountManagerHelper.getGoogleAccountNames();
    return accountNames.toArray(new String[accountNames.size()]);
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
/**
* Called by native to invalidate an OAuth2 token.
*/
@CalledByNative
public static void invalidateOAuth2AuthToken(Context context, String accessToken) {
    if (accessToken != null) {
        AccountManagerHelper.get(context).invalidateAuthToken(accessToken);
    }
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
/**
 * Initiate fetching the user accounts data (images and the full name).
 * Fetched data will be sent to observers of ProfileDownloader.
 * @param profile Profile to use.
 */
private static void startFetchingAccountsInformation(Context context, Profile profile) {
    Account[] accounts = AccountManagerHelper.get(context).getGoogleAccounts();
    for (int i = 0; i < accounts.length; i++) {
        startFetchingAccountInformation(context, profile, accounts[i].name);
    }
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
private boolean accountExists(Account account) {
    Account[] accounts = AccountManagerHelper.get(mContext).getGoogleAccounts();
    for (Account a : accounts) {
        if (a.equals(account)) {
            return true;
        }
    }
    return false;
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
/**
 * Displays the account picker or the add account dialog and signs the user in.
 *
 * @return The fragment that was shown.
 */
@VisibleForTesting
public DialogFragment displayAccountPicker() {
    Context context = getActivity();
    if (context == null) return null;

    if (!SigninManager.get(context).isSignInAllowed()) {
        if (SigninManager.get(context).isSigninDisabledByPolicy()) {
            ManagedPreferencesUtils.showManagedByAdministratorToast(context);
        }
        return null;
    }

    if (AccountManagerHelper.get(context).hasGoogleAccounts()) {
        if (getFragmentManager().findFragmentByTag(ACCOUNT_PICKER_DIALOG_TAG) != null) {
            return null;
        }
        ChooseAccountFragment chooserFragment = new ChooseAccountFragment();
        chooserFragment.show(getFragmentManager(), ACCOUNT_PICKER_DIALOG_TAG);
        return chooserFragment;
    } else {
        AddGoogleAccountDialogFragment dialog = new AddGoogleAccountDialogFragment();
        dialog.setListener(new AddGoogleAccountListener() {
            @Override
            public void onAddAccountClicked() {
                AccountAdder.getInstance().addAccount(MainPreferences.this,
                        AccountAdder.ADD_ACCOUNT_RESULT);
            }
        });
        dialog.show(getFragmentManager(), null);
        return dialog;
    }
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
@VisibleForTesting
static boolean hasGoogleAccountAuthenticator(Context context) {
    if (sHasGoogleAccountAuthenticator == null) {
        AccountManagerHelper accountHelper = AccountManagerHelper.get(context);
        sHasGoogleAccountAuthenticator = accountHelper.hasGoogleAccountAuthenticator();
    }
    return sHasGoogleAccountAuthenticator;
}
 

import org.chromium.sync.signin.AccountManagerHelper; //导入依赖的package包/类
private static void signIn(Activity activity, String accountName) {
    if (activity == null) return;
    Account account = AccountManagerHelper.get(activity).getAccountFromName(accountName);
    if (account == null) return;
    SigninManager.get(activity).signInToSelectedAccount(activity, account,
            SigninManager.SIGNIN_TYPE_INTERACTIVE, SigninManager.SIGNIN_SYNC_IMMEDIATELY,
            false, null);
}