Add URL parameter so that /ListAccounts returns valid json.

chrome/browser/signin/account_reconcilor.h

 // 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.
 #ifndef CHROME_BROWSER_SIGNIN_ACCOUNT_RECONCILOR_H_
 #define CHROME_BROWSER_SIGNIN_ACCOUNT_RECONCILOR_H_
 
 #include <deque>
 
 #include "base/basictypes.h"
 #include "base/callback_forward.h"
@@ skipping 38 matching lines @@
   }
 
   bool IsRegisteredWithTokenService() const {
     return registered_with_token_service_;
   }
 
   bool AreGaiaAccountsSet() const { return are_gaia_accounts_set_; }
 
   bool AreAllRefreshTokensChecked() const;
 
-  const std::vector<std::string>& GetGaiaAccountsForTesting() const {
+  const std::vector<std::pair<std::string, bool> >&

[bartfab (slow), 2014/02/17 15:22:04]

Nit 1: #include <string>
Nit 2: #include <utility>
Nit 3: #include <vector>

[Roger Tawa OOO till Jul 10th, 2014/02/18 19:37:54]

Done.

+      GetGaiaAccountsForTesting() const {
     return gaia_accounts_;
   }
 
+ private:
   const std::set<std::string>& GetValidChromeAccountsForTesting() const {
     return valid_chrome_accounts_;
   }
 
   const std::set<std::string>& GetInvalidChromeAccountsForTesting() const {
     return invalid_chrome_accounts_;
   }
 
- private:
   // Used during GetAccountsFromCookie.
   // Stores a callback for the next action to perform.
   typedef base::Callback<void(
       const GoogleServiceAuthError& error,
-      const std::vector<std::string>&)> GetAccountsFromCookieCallback;
+      const std::vector<std::pair<std::string, bool> >&)>
+          GetAccountsFromCookieCallback;
 
   friend class AccountReconcilorTest;
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, GetAccountsFromCookieSuccess);
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, GetAccountsFromCookieFailure);
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, ValidateAccountsFromTokens);
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest,
                            ValidateAccountsFromTokensFailedUserInfo);
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest,
                            ValidateAccountsFromTokensFailedTokenRequest);
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, StartReconcileNoop);
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, StartReconcileNoopMultiple);
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, StartReconcileAddToCookie);
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, StartReconcileAddToChrome);
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, StartReconcileBadPrimary);
   FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest, StartReconcileOnlyOnce);
+  FRIEND_TEST_ALL_PREFIXES(AccountReconcilorTest,
+                           StartReconcileWithSessionInfoExpiredDefault);
 
   class RefreshTokenFetcher;
   class UserIdFetcher;
 
   // Register and unregister with dependent services.
   void RegisterWithCookieMonster();
   void UnregisterWithCookieMonster();
   void RegisterWithSigninManager();
   void UnregisterWithSigninManager();
   void RegisterWithTokenService();
@@ skipping 13 matching lines @@
   virtual void PerformMergeAction(const std::string& account_id);
   virtual void PerformAddToChromeAction(const std::string& account_id,
                                         int session_index);
   virtual void PerformLogoutAllAccountsAction();
 
   // Used to remove an account from chrome and the cookie jar.
   virtual void StartRemoveAction(const std::string& account_id);
   virtual void FinishRemoveAction(
       const std::string& account_id,
       const GoogleServiceAuthError& error,
-      const std::vector<std::string>& accounts);
+      const std::vector<std::pair<std::string, bool> >& accounts);
 
   // Used during periodic reconciliation.
   void StartReconcile();
   void FinishReconcile();
   void AbortReconcile();
   void CalculateIfReconcileIsDone();
   void HandleSuccessfulAccountIdCheck(const std::string& account_id);
   void HandleFailedAccountIdCheck(const std::string& account_id);
   void HandleRefreshTokenFetched(const std::string& account_id,
                                  const std::string& refresh_token);
 
   void GetAccountsFromCookie(GetAccountsFromCookieCallback callback);
   void ContinueReconcileActionAfterGetGaiaAccounts(
       const GoogleServiceAuthError& error,
-      const std::vector<std::string>& accounts);
+      const std::vector<std::pair<std::string, bool> >& accounts);
   void ValidateAccountsFromTokenService();
 
   void OnCookieChanged(ChromeCookieDetails* details);
 
   // Overriden from content::NotificationObserver.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // Overriden from GaiaAuthConsumer.
@@ skipping 33 matching lines @@
   scoped_ptr<GaiaAuthFetcher> gaia_fetcher_;
   bool registered_with_token_service_;
 
   // True while the reconcilor is busy checking or managing the accounts in
   // this profile.
   bool is_reconcile_started_;
 
   // Used during reconcile action.
   // These members are used used to validate the gaia cookie.
   bool are_gaia_accounts_set_;
-  std::vector<std::string> gaia_accounts_;
+  std::vector<std::pair<std::string, bool> > gaia_accounts_;
 
   // Used during reconcile action.
   // These members are used to validate the tokens in OAuth2TokenService.
   std::string primary_account_;
   std::vector<std::string> chrome_accounts_;
   scoped_ptr<OAuth2TokenService::Request>* requests_;
   ScopedVector<UserIdFetcher> user_id_fetchers_;
   ScopedVector<RefreshTokenFetcher> refresh_token_fetchers_;
   std::set<std::string> valid_chrome_accounts_;
   std::set<std::string> invalid_chrome_accounts_;
   std::vector<std::string> add_to_cookie_;
   std::vector<std::pair<std::string, int> > add_to_chrome_;
 
   std::deque<GetAccountsFromCookieCallback> get_gaia_accounts_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(AccountReconcilor);
 };
 
 #endif  // CHROME_BROWSER_SIGNIN_ACCOUNT_RECONCILOR_H_