[Signin] Dice Mutlilogin + Tests.

Change-Id: I1b9fee123149e2f1371f8a568acaf8ceb59e9f07
Reviewed-on: https://chromium-review.googlesource.com/c/1251581
Commit-Queue: Valeriya Sinevich <valeriyas@google.com>
Reviewed-by: David Roger <droger@chromium.org>
Cr-Commit-Position: refs/heads/master@{#599620}

components/signin/core/browser/account_reconcilor.cc

@@ -110,6 +110,45 @@ bool RevokeAllSecondaryTokens(
   return token_revoked;
 }
 
+// Returns true if current array of existing accounts in cookie is different
+// from the desired one.
+bool AccountsNeedUpdate(
+    const signin::MultiloginParameters& parameters,
+    const std::vector<gaia::ListedAccount>& existing_accounts) {
+  if (parameters.mode ==
+      signin::MultiloginMode::MULTILOGIN_UPDATE_COOKIE_ACCOUNTS_ORDER) {
+    // In UPDATE mode accounts_to_send are guaranteed to be not empty.
+    DCHECK(!parameters.accounts_to_send.empty());
+    if (existing_accounts.empty())
+      return true;
+    // In UPDATE mode update is needed id syncing account is not first.
+    if (existing_accounts[0].id != parameters.accounts_to_send[0])
+      return true;
+  }
+  // Maybe some accounts in cookies are not valid and need refreshing.
+  std::set<std::string> accounts_to_send_set(
+      parameters.accounts_to_send.begin(), parameters.accounts_to_send.end());
+  std::set<std::string> existing_accounts_set;
+  for (const gaia::ListedAccount& account : existing_accounts) {
+    if (account.valid)
+      existing_accounts_set.insert(account.id);
+  }
+  return (existing_accounts_set != accounts_to_send_set);
+}
+
+// Pick the account will become first after this reconcile is finished.
+std::string PickFirstGaiaAccount(
+    const signin::MultiloginParameters& parameters,
+    const std::vector<gaia::ListedAccount>& gaia_accounts) {
+  if (parameters.mode ==
+          signin::MultiloginMode::MULTILOGIN_PRESERVE_COOKIE_ACCOUNTS_ORDER &&
+      !gaia_accounts.empty()) {
+    return gaia_accounts[0].id;
+  }
+  return parameters.accounts_to_send.empty() ? ""
+                                             : parameters.accounts_to_send[0];
+}
+
 }  // namespace
 
 AccountReconcilor::Lock::Lock(AccountReconcilor* reconcilor)
@@ -354,11 +393,13 @@ void AccountReconcilor::PerformMergeAction(const std::string& account_id) {
 }
 
 void AccountReconcilor::PerformSetCookiesAction(
-    const std::vector<std::string>& account_ids) {
+    const signin::MultiloginParameters& parameters) {
   reconcile_is_noop_ = false;
+  is_reconcile_started_ = true;
   VLOG(1) << "AccountReconcilor::PerformSetCookiesAction: "
-          << base::JoinString(account_ids, " ");
-  cookie_manager_service_->SetAccountsInCookie(account_ids,
+          << base::JoinString(parameters.accounts_to_send, " ");
+  // TODO (https://crbug.com/890321): pass mode to GaiaCookieManagerService.
+  cookie_manager_service_->SetAccountsInCookie(parameters.accounts_to_send,
                                                delegate_->GetGaiaApiSource());
 }
 
@@ -436,27 +477,41 @@ void AccountReconcilor::FinishReconcileWithMultiloginEndpoint(
     std::vector<gaia::ListedAccount>&& gaia_accounts) {
   DCHECK(base::FeatureList::IsEnabled(kUseMultiloginEndpoint));
 
-  signin::MultiloginMode mode;
-  if (delegate_->ShouldUpdateAccountsOrderInCookies()) {
-    // UPDATE mode can happen only if sync is enabled.
-    DCHECK(!primary_account.empty());
-    mode = signin::MultiloginMode::MULTILOGIN_UPDATE_COOKIE_ACCOUNTS_ORDER;
-  } else {
-    mode = signin::MultiloginMode::MULTILOGIN_PRESERVE_COOKIE_ACCOUNTS_ORDER;
-  }
-
-  std::vector<std::string> accounts_to_send;
-  if (delegate_->ReorderChromeAccountsForReconcileIfNeeded(
-          chrome_accounts, primary_account, gaia_accounts, &accounts_to_send)) {
-    PerformSetCookiesAction(accounts_to_send);
+  bool primary_has_error =
+      token_service_->RefreshTokenHasError(primary_account);
+
+  const signin::MultiloginParameters parameters_for_multilogin =
+      delegate_->CalculateParametersForMultilogin(
+          chrome_accounts, primary_account, gaia_accounts, first_execution_,
+          primary_has_error);
+
+  DCHECK(is_reconcile_started_);
+  if (AccountsNeedUpdate(parameters_for_multilogin, gaia_accounts)) {
+    // Reconcilor has to do some calls to gaia. is_reconcile_started_ is true
+    // and any StartReconcile() calls that are made in the meantime will be
+    // aborted until OnSetAccountsInCookieCompleted is called and
+    // is_reconcile_started_ is set to false.
+    PerformSetCookiesAction(parameters_for_multilogin);
   } else {
     OnSetAccountsInCookieCompleted(GoogleServiceAuthError::AuthErrorNone());
+    DCHECK(!is_reconcile_started_);
   }
 
   signin_metrics::RecordAccountsPerProfile(chrome_accounts.size());
-  // TODO (valeriyas): Write correct first gaia account to cache for desktop.
-  if (!is_reconcile_started_)
-    delegate_->OnReconcileFinished(primary_account, reconcile_is_noop_);
+  if (!is_reconcile_started_) {
+    // TODO(droger): investigate if |is_reconcile_started_| is still needed for
+    // multilogin.
+
+    // This happens only when reconcile doesn't make any changes (i.e. the state
+    // is consistent). If it is not the case, second reconcile is expected to be
+    // triggered after changes are made. For that one the state is supposed to
+    // be already consistent.
+    DCHECK(!AccountsNeedUpdate(parameters_for_multilogin, gaia_accounts));
+    std::string first_gaia_account_after_reconcile =
+        PickFirstGaiaAccount(parameters_for_multilogin, gaia_accounts);
+    delegate_->OnReconcileFinished(first_gaia_account_after_reconcile,
+                                   reconcile_is_noop_);
+  }
   first_execution_ = false;
   ScheduleStartReconcileIfChromeAccountsChanged();
 }

components/signin/core/browser/account_reconcilor.h

@@ -140,25 +140,36 @@ class AccountReconcilor : public KeyedService,
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorMirrorEndpointParamTest,
                            ProfileAlreadyConnected);
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTestTable, TableRowTest);
+  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTestDiceMultilogin, TableRowTest);
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTestMirrorMultilogin, TableRowTest);
-  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, DiceTokenServiceRegistration);
-  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, DiceReconcileWhithoutSignin);
-  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, DiceReconcileNoop);
-  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, DiceLastKnownFirstAccount);
-  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, UnverifiedAccountNoop);
-  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, UnverifiedAccountMerge);
-  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, HandleSigninDuringReconcile);
-  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, DiceMigrationAfterNoop);
-  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest,
+  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorDiceEndpointParamTest,
+                           DiceTokenServiceRegistration);
+  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorDiceEndpointParamTest,
+                           DiceReconcileWithoutSignin);
+  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorDiceEndpointParamTest,
+                           DiceReconcileNoop);
+  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorDiceEndpointParamTest,
+                           DiceLastKnownFirstAccount);
+  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorDiceEndpointParamTest,
+                           UnverifiedAccountNoop);
+  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorDiceEndpointParamTest,
+                           UnverifiedAccountMerge);
+  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorDiceEndpointParamTest,
+                           HandleSigninDuringReconcile);
+  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorDiceEndpointParamTest,
+                           DiceMigrationAfterNoop);
+  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorDiceEndpointParamTest,
                            DiceNoMigrationWhenTokensNotReady);
-  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest,
+  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorDiceEndpointParamTest,
                            DiceNoMigrationAfterReconcile);
-  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest,
+  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorDiceEndpointParamTest,
                            DiceReconcileReuseGaiaFirstAccount);
-  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest,
+  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorDiceEndpointParamTest,
                            MigrationClearSecondaryTokens);
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, MigrationClearAllTokens);
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, DiceDeleteCookie);
+  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorDiceEndpointParamTest,
+                           MigrationClearAllTokens);
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorMirrorEndpointParamTest,
                            TokensNotLoaded);
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorMirrorEndpointParamTest,
@@ -232,7 +243,7 @@ class AccountReconcilor : public KeyedService,
   virtual void PerformMergeAction(const std::string& account_id);
   virtual void PerformLogoutAllAccountsAction();
   virtual void PerformSetCookiesAction(
-      const std::vector<std::string>& account_ids);
+      const signin::MultiloginParameters& parameters);
 
   // Used during periodic reconciliation.
   void StartReconcile();

components/signin/core/browser/account_reconcilor_delegate.cc

@@ -36,16 +36,36 @@ std::string AccountReconcilorDelegate::GetFirstGaiaAccountForReconcile(
   return std::string();
 }
 
-bool AccountReconcilorDelegate::ReorderChromeAccountsForReconcileIfNeeded(
+MultiloginParameters
+AccountReconcilorDelegate::CalculateParametersForMultilogin(
     const std::vector<std::string>& chrome_accounts,
-    const std::string primary_account,
+    const std::string& primary_account,
     const std::vector<gaia::ListedAccount>& gaia_accounts,
-    std::vector<std::string>* accounts_to_send) const {
-  return false;
+    bool first_execution,
+    bool primary_has_error) const {
+  const MultiloginMode mode = CalculateModeForReconcile(
+      gaia_accounts, primary_account, first_execution, primary_has_error);
+  const std::vector<std::string> accounts_to_send =
+      ReorderChromeAccountsForReconcile(chrome_accounts, primary_account,
+                                        gaia_accounts, mode);
+  return {mode, accounts_to_send};
+}
+
+MultiloginMode AccountReconcilorDelegate::CalculateModeForReconcile(
+    const std::vector<gaia::ListedAccount>& gaia_accounts,
+    const std::string primary_account,
+    bool first_execution,
+    bool primary_has_error) const {
+  return MultiloginMode::MULTILOGIN_UPDATE_COOKIE_ACCOUNTS_ORDER;
 }
 
-bool AccountReconcilorDelegate::ShouldUpdateAccountsOrderInCookies() const {
-  return true;
+std::vector<std::string>
+AccountReconcilorDelegate::ReorderChromeAccountsForReconcile(
+    const std::vector<std::string>& chrome_accounts,
+    const std::string& primary_account,
+    const std::vector<gaia::ListedAccount>& gaia_accounts,
+    const signin::MultiloginMode mode) const {
+  return std::vector<std::string>();
 }
 
 AccountReconcilorDelegate::RevokeTokenOption

components/signin/core/browser/account_reconcilor_delegate.h

@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "base/time/time.h"
+#include "components/signin/core/browser/gaia_cookie_manager_service.h"
 #include "google_apis/gaia/gaia_auth_fetcher.h"
 #include "google_apis/gaia/gaia_auth_util.h"
 #include "google_apis/gaia/google_service_auth_error.h"
@@ -55,6 +56,7 @@ class AccountReconcilorDelegate {
   // |first_execution| is true for the first reconciliation after startup.
   // |will_logout| is true if the reconcilor will perform a logout no matter
   // what is returned by this function.
+  // Only used with MergeSession.
   virtual std::string GetFirstGaiaAccountForReconcile(
       const std::vector<std::string>& chrome_accounts,
       const std::vector<gaia::ListedAccount>& gaia_accounts,
@@ -62,19 +64,13 @@ class AccountReconcilorDelegate {
       bool first_execution,
       bool will_logout) const;
 
-  // Reorders chrome accounts in the order they should appear in cookies with
-  // respect to existing cookies. Returns true if the resulting vector is not
-  // the same as existing vector of gaia accounts (i.e. cookies should be
-  // rebuilt).
-  virtual bool ReorderChromeAccountsForReconcileIfNeeded(
+  // Returns a pair of mode and accounts to send to Mutilogin endpoint.
+  MultiloginParameters CalculateParametersForMultilogin(
       const std::vector<std::string>& chrome_accounts,
-      const std::string primary_account,
+      const std::string& primary_account,
       const std::vector<gaia::ListedAccount>& gaia_accounts,
-      std::vector<std::string>* accounts_to_send) const;
-
-  // Returns true if it is allowed to change the order of the gaia accounts
-  // (e.g. on mobile or on stratup). Default is true.
-  virtual bool ShouldUpdateAccountsOrderInCookies() const;
+      bool first_execution,
+      bool primary_has_error) const;
 
   // Returns whether secondary accounts should be revoked at the beginning of
   // the reconcile.
@@ -113,6 +109,22 @@ class AccountReconcilorDelegate {
   AccountReconcilor* reconcilor() { return reconcilor_; }
 
  private:
+  // Reorders chrome accounts in the order they should appear in cookies with
+  // respect to existing cookies.
+  virtual std::vector<std::string> ReorderChromeAccountsForReconcile(
+      const std::vector<std::string>& chrome_accounts,
+      const std::string& primary_account,
+      const std::vector<gaia::ListedAccount>& gaia_accounts,
+      const signin::MultiloginMode mode) const;
+
+  // Returns Mode which shows if it is allowed to change the order of the gaia
+  // accounts (e.g. on mobile or on stratup). Default is UPDATE.
+  virtual MultiloginMode CalculateModeForReconcile(
+      const std::vector<gaia::ListedAccount>& gaia_accounts,
+      const std::string primary_account,
+      bool first_execution,
+      bool primary_has_error) const;
+
   AccountReconcilor* reconcilor_;
 };
 

components/signin/core/browser/dice_account_reconcilor_delegate.cc

@@ -13,6 +13,42 @@
 #include "components/signin/core/browser/signin_client.h"
 #include "components/signin/core/browser/signin_pref_names.h"
 
+namespace {
+// Outputs accounts in the following order: first account, gaia accounts that
+// are present in chrome_accounts, rest of chrome_accounts.
+std::vector<std::string> ReorderChromeAccountsInternal(
+    const std::vector<std::string>& chrome_accounts,
+    const std::string& first_account,
+    const std::vector<gaia::ListedAccount>& gaia_accounts) {
+  // Reordering should only happen if there is first account with a valid token.
+  DCHECK(!first_account.empty());
+
+  std::set<std::string> chrome_accounts_set(chrome_accounts.begin(),
+                                            chrome_accounts.end());
+  DCHECK(base::ContainsKey(chrome_accounts_set, first_account));
+
+  std::vector<std::string> accounts_to_send;
+  accounts_to_send.reserve(chrome_accounts.size());
+
+  accounts_to_send.push_back(first_account);
+
+  chrome_accounts_set.erase(first_account);
+  for (const gaia::ListedAccount& gaia_account : gaia_accounts) {
+    if (gaia_account.id == first_account ||
+        chrome_accounts_set.find(gaia_account.id) == chrome_accounts_set.end())
+      continue;
+    accounts_to_send.push_back(gaia_account.id);
+    chrome_accounts_set.erase(gaia_account.id);
+  }
+
+  for (const std::string& chrome_account : chrome_accounts_set) {
+    accounts_to_send.push_back(chrome_account);
+  }
+  DCHECK(!accounts_to_send.empty());
+  return accounts_to_send;
+}
+}  // namespace
+
 namespace signin {
 
 DiceAccountReconcilorDelegate::DiceAccountReconcilorDelegate(
@@ -110,6 +146,52 @@ std::string DiceAccountReconcilorDelegate::GetFirstGaiaAccountForReconcile(
   return std::string();
 }
 
+MultiloginMode DiceAccountReconcilorDelegate::CalculateModeForReconcile(
+    const std::vector<gaia::ListedAccount>& gaia_accounts,
+    const std::string primary_account,
+    bool first_execution,
+    bool primary_has_error) const {
+  const bool sync_enabled = !primary_account.empty();
+
+  const bool first_gaia_is_primary =
+      !gaia_accounts.empty() && (gaia_accounts[0].id == primary_account);
+
+  const bool should_update_cookies = sync_enabled && first_execution &&
+                                     !primary_has_error &&
+                                     !first_gaia_is_primary;
+
+  signin::MultiloginMode mode;
+  if (should_update_cookies) {
+    // UPDATE mode can happen only if sync is enabled.
+    DCHECK(!primary_account.empty());
+    mode = signin::MultiloginMode::MULTILOGIN_UPDATE_COOKIE_ACCOUNTS_ORDER;
+  } else {
+    mode = signin::MultiloginMode::MULTILOGIN_PRESERVE_COOKIE_ACCOUNTS_ORDER;
+  }
+  return mode;
+}
+
+std::vector<std::string>
+DiceAccountReconcilorDelegate::ReorderChromeAccountsForReconcile(
+    const std::vector<std::string>& chrome_accounts,
+    const std::string& primary_account,
+    const std::vector<gaia::ListedAccount>& gaia_accounts,
+    const signin::MultiloginMode mode) const {
+  if (mode == signin::MultiloginMode::MULTILOGIN_UPDATE_COOKIE_ACCOUNTS_ORDER) {
+    return ReorderChromeAccountsInternal(chrome_accounts, primary_account,
+                                         gaia_accounts);
+  }
+  if (gaia_accounts.empty() &&
+      base::ContainsValue(chrome_accounts, last_known_first_account_)) {
+    // In PRESERVE mode in case accounts in cookies are accidentally lost we
+    // should put cached first account first since Gaia has no information about
+    // it.
+    return ReorderChromeAccountsInternal(
+        chrome_accounts, last_known_first_account_, gaia_accounts);
+  }
+  return chrome_accounts;
+}
+
 AccountReconcilorDelegate::RevokeTokenOption
 DiceAccountReconcilorDelegate::ShouldRevokeSecondaryTokensBeforeReconcile(
     const std::vector<gaia::ListedAccount>& gaia_accounts) {

components/signin/core/browser/dice_account_reconcilor_delegate.h

@@ -39,6 +39,18 @@ class DiceAccountReconcilorDelegate : public AccountReconcilorDelegate {
   bool ShouldRevokeTokensOnCookieDeleted() override;
 
  private:
+  std::vector<std::string> ReorderChromeAccountsForReconcile(
+      const std::vector<std::string>& chrome_accounts,
+      const std::string& primary_account,
+      const std::vector<gaia::ListedAccount>& gaia_accounts,
+      const signin::MultiloginMode mode) const override;
+
+  MultiloginMode CalculateModeForReconcile(
+      const std::vector<gaia::ListedAccount>& gaia_accounts,
+      const std::string primary_account,
+      bool first_execution,
+      bool primary_has_error) const override;
+
   SigninClient* signin_client_;
   AccountConsistencyMethod account_consistency_;
 

components/signin/core/browser/fake_gaia_cookie_manager_service.cc

@@ -121,4 +121,4 @@ FakeGaiaCookieManagerService::GetURLLoaderFactory() {
   return shared_loader_factory_
              ? shared_loader_factory_
              : GaiaCookieManagerService::GetURLLoaderFactory();
-}
+}
\ No newline at end of file

components/signin/core/browser/gaia_cookie_manager_service.cc

@@ -32,6 +32,27 @@
 #include "services/network/public/cpp/shared_url_loader_factory.h"
 #include "services/network/public/cpp/simple_url_loader.h"
 
+namespace signin {
+MultiloginParameters::MultiloginParameters(
+    const MultiloginMode mode,
+    const std::vector<std::string>& accounts_to_send)
+    : mode(mode), accounts_to_send(accounts_to_send) {}
+
+MultiloginParameters::~MultiloginParameters() {}
+
+MultiloginParameters::MultiloginParameters(const MultiloginParameters& other) {
+  mode = other.mode;
+  accounts_to_send = other.accounts_to_send;
+}
+
+MultiloginParameters& MultiloginParameters::operator=(
+    const MultiloginParameters& other) {
+  mode = other.mode;
+  accounts_to_send = other.accounts_to_send;
+  return *this;
+}
+}  // namespace signin
+
 namespace {
 
 // In case of an error while fetching using the GaiaAuthFetcher or

components/signin/core/browser/gaia_cookie_manager_service.h

@@ -39,6 +39,22 @@ class SimpleURLLoader;
 namespace signin {
 // The maximum number of retries for a fetcher used in this class.
 constexpr int kMaxFetcherRetries = 8;
+
+struct MultiloginParameters {
+  MultiloginParameters(const MultiloginMode mode,
+                       const std::vector<std::string>& accounts_to_send);
+  MultiloginParameters(const MultiloginParameters& other);
+  MultiloginParameters& operator=(const MultiloginParameters& other);
+  ~MultiloginParameters();
+
+  // Needed for testing.
+  bool operator==(const MultiloginParameters& other) const {
+    return mode == other.mode && accounts_to_send == other.accounts_to_send;
+  }
+
+  MultiloginMode mode;
+  std::vector<std::string> accounts_to_send;
+};
 }  // namespace signin
 
 // Merges a Google account known to Chrome into the cookie jar.  When merging

components/signin/core/browser/mirror_account_reconcilor_delegate.cc

@@ -49,37 +49,27 @@ std::string MirrorAccountReconcilorDelegate::GetFirstGaiaAccountForReconcile(
   return primary_account;
 }
 
-bool MirrorAccountReconcilorDelegate::ReorderChromeAccountsForReconcileIfNeeded(
+std::vector<std::string>
+MirrorAccountReconcilorDelegate::ReorderChromeAccountsForReconcile(
     const std::vector<std::string>& chrome_accounts,
-    const std::string primary_account,
+    const std::string& primary_account,
     const std::vector<gaia::ListedAccount>& gaia_accounts,
-    std::vector<std::string>* accounts_to_send) const {
-  DCHECK(accounts_to_send);
-  accounts_to_send->clear();
-  accounts_to_send->reserve(chrome_accounts.size());
-  bool needs_reordering = false;
+    const signin::MultiloginMode mode) const {
+  DCHECK(mode ==
+         signin::MultiloginMode::MULTILOGIN_UPDATE_COOKIE_ACCOUNTS_ORDER);
+  std::vector<std::string> accounts_to_send;
+  accounts_to_send.reserve(chrome_accounts.size());
 
   DCHECK(!primary_account.empty());
-  accounts_to_send->push_back(primary_account);
+  accounts_to_send.push_back(primary_account);
 
   for (const std::string& chrome_account : chrome_accounts) {
     if (chrome_account == primary_account)
       continue;
-    accounts_to_send->push_back(chrome_account);
-  }
-
-  if (gaia_accounts.size() != accounts_to_send->size()) {
-    needs_reordering = true;
-  } else {
-    for (size_t i = 0; i < accounts_to_send->size(); ++i) {
-      const gaia::ListedAccount& gaia_account = gaia_accounts[i];
-      if (gaia_account.id != accounts_to_send->at(i) || !gaia_account.valid) {
-        needs_reordering = true;
-        break;
-      }
-    }
+    accounts_to_send.push_back(chrome_account);
   }
-  return needs_reordering;
+  DCHECK(!accounts_to_send.empty());
+  return accounts_to_send;
 }
 
 void MirrorAccountReconcilorDelegate::GoogleSigninSucceeded(

components/signin/core/browser/mirror_account_reconcilor_delegate.h

@@ -31,11 +31,11 @@ class MirrorAccountReconcilorDelegate : public AccountReconcilorDelegate,
       bool first_execution,
       bool will_logout) const override;
 
-  bool ReorderChromeAccountsForReconcileIfNeeded(
+  std::vector<std::string> ReorderChromeAccountsForReconcile(
       const std::vector<std::string>& chrome_accounts,
-      const std::string primary_account,
+      const std::string& primary_account,
       const std::vector<gaia::ListedAccount>& gaia_accounts,
-      std::vector<std::string>* accounts_to_send) const override;
+      const signin::MultiloginMode mode) const override;
 
   // SigninManagerBase::Observer:
   void GoogleSigninSucceeded(const std::string& account_id,