Add URL parameter so that /ListAccounts returns valid json.

chrome/browser/signin/account_reconcilor.cc

 // 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.
 
 #include "chrome/browser/signin/account_reconcilor.h"
 
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 344 matching lines @@
   VLOG(1) << "AccountReconcilor::StartRemoveAction: " << account_id;
   GetAccountsFromCookie(
       base::Bind(&AccountReconcilor::FinishRemoveAction,
                  base::Unretained(this),
                  account_id));
 }
 
 void AccountReconcilor::FinishRemoveAction(
     const std::string& account_id,
     const GoogleServiceAuthError& error,
-    const std::vector<std::string>& accounts) {
+    const std::vector<std::pair<std::string, bool> >& accounts) {
   VLOG(1) << "AccountReconcilor::FinishRemoveAction:"
           << " account=" << account_id
           << " error=" << error.ToString();
   if (error.state() == GoogleServiceAuthError::NONE) {
     AbortReconcile();
-    merge_session_helper_.LogOut(account_id, accounts);
+    std::vector<std::string> accounts_only;
+    for (std::vector<std::pair<std::string, bool> >::const_iterator i =
+             accounts.begin(); i != accounts.end(); ++i) {
+      accounts_only.push_back(i->first);
+    }
+    merge_session_helper_.LogOut(account_id, accounts_only);
   }
   // Wait for the next ReconcileAction if there is an error.
 }
 
 void AccountReconcilor::PerformAddToChromeAction(
     const std::string& account_id,
     int session_index) {
   VLOG(1) << "AccountReconcilor::PerformAddToChromeAction:"
           << " account=" << account_id
           << " session_index=" << session_index;
@@ skipping 41 matching lines @@
     gaia_fetcher_.reset(new GaiaAuthFetcher(this, GaiaConstants::kChromeSource,
                                             profile_->GetRequestContext()));
     gaia_fetcher_->StartListAccounts();
   }
 }
 
 void AccountReconcilor::OnListAccountsSuccess(const std::string& data) {
   gaia_fetcher_.reset();
 
   // Get account information from response data.
-  std::vector<std::string> gaia_accounts;
+  std::vector<std::pair<std::string, bool> > gaia_accounts;
   bool valid_json = gaia::ParseListAccountsData(data, &gaia_accounts);
   if (!valid_json) {
     VLOG(1) << "AccountReconcilor::OnListAccountsSuccess: parsing error";
   } else if (gaia_accounts.size() > 0) {
     VLOG(1) << "AccountReconcilor::OnListAccountsSuccess: "
             << "Gaia " << gaia_accounts.size() << " accounts, "
-            << "Primary is '" << gaia_accounts[0] << "'";
+            << "Primary is '" << gaia_accounts[0].first << "'";
   } else {
     VLOG(1) << "AccountReconcilor::OnListAccountsSuccess: No accounts";
   }
 
   // There must be at least one callback waiting for result.
   DCHECK(!get_gaia_accounts_callbacks_.empty());
 
   GoogleServiceAuthError error = !valid_json
       ? GoogleServiceAuthError(
             GoogleServiceAuthError::UNEXPECTED_SERVICE_RESPONSE)
       : GoogleServiceAuthError::AuthErrorNone();
   get_gaia_accounts_callbacks_.front().Run(error, gaia_accounts);
   get_gaia_accounts_callbacks_.pop_front();
 
   MayBeDoNextListAccounts();
 }
 
 void AccountReconcilor::OnListAccountsFailure(
     const GoogleServiceAuthError& error) {
   gaia_fetcher_.reset();
   VLOG(1) << "AccountReconcilor::OnListAccountsFailure: " << error.ToString();
-  std::vector<std::string> empty_accounts;
+  std::vector<std::pair<std::string, bool> > empty_accounts;
 
   // There must be at least one callback waiting for result.
   DCHECK(!get_gaia_accounts_callbacks_.empty());
 
   get_gaia_accounts_callbacks_.front().Run(error, empty_accounts);
   get_gaia_accounts_callbacks_.pop_front();
 
   MayBeDoNextListAccounts();
 }
 
 void AccountReconcilor::MayBeDoNextListAccounts() {
   if (!get_gaia_accounts_callbacks_.empty()) {
     gaia_fetcher_.reset(new GaiaAuthFetcher(this, GaiaConstants::kChromeSource,
                                             profile_->GetRequestContext()));
     gaia_fetcher_->StartListAccounts();
   }
 }
 
 void AccountReconcilor::ContinueReconcileActionAfterGetGaiaAccounts(
     const GoogleServiceAuthError& error,
-    const std::vector<std::string>& accounts) {
+    const std::vector<std::pair<std::string, bool> >& accounts) {
   if (error.state() == GoogleServiceAuthError::NONE) {
     gaia_accounts_ = accounts;
     are_gaia_accounts_set_ = true;
     FinishReconcile();
   } else {
     AbortReconcile();
   }
 }
 
 void AccountReconcilor::ValidateAccountsFromTokenService() {
@@ skipping 68 matching lines @@
   if (!are_gaia_accounts_set_ || !AreAllRefreshTokensChecked())
     return;
 
   VLOG(1) << "AccountReconcilor::FinishReconcile";
 
   DeleteFetchers();
 
   DCHECK(add_to_cookie_.empty());
   DCHECK(add_to_chrome_.empty());
   bool are_primaries_equal =
-      gaia_accounts_.size() > 0 && primary_account_ == gaia_accounts_[0];
+      gaia_accounts_.size() > 0 && primary_account_ == gaia_accounts_[0].first;
 
   if (are_primaries_equal) {
     // Determine if we need to merge accounts from gaia cookie to chrome.
     for (size_t i = 0; i < gaia_accounts_.size(); ++i) {
-      const std::string& gaia_account = gaia_accounts_[i];
-      if (valid_chrome_accounts_.find(gaia_account) ==
+      const std::string& gaia_account = gaia_accounts_[i].first;
+      if (gaia_accounts_[i].second &&
+              valid_chrome_accounts_.find(gaia_account) ==
           valid_chrome_accounts_.end()) {
         add_to_chrome_.push_back(std::make_pair(gaia_account, i));
       }
     }
 
     // Determine if we need to merge accounts from chrome into gaia cookie.
     for (std::set<std::string>::const_iterator i =
              valid_chrome_accounts_.begin();
          i != valid_chrome_accounts_.end(); ++i) {
-      if (std::find(gaia_accounts_.begin(), gaia_accounts_.end(), *i) ==
-          gaia_accounts_.end()) {
+      bool add_to_cookie = true;
+      for (size_t j = 0; j < gaia_accounts_.size(); ++j) {
+        if (gaia_accounts_[j].first == *i) {
+          add_to_cookie = !gaia_accounts_[j].second;
+          break;
+        }
+      }
+      if (add_to_cookie)
         add_to_cookie_.push_back(*i);
-      }
     }
   } else {
     VLOG(1) << "AccountReconcilor::FinishReconcile: rebuild cookie";
     // Really messed up state.  Blow away the gaia cookie completely and
     // rebuild it, making sure the primary account as specified by the
     // SigninManager is the first session in the gaia cookie.
     PerformLogoutAllAccountsAction();
     add_to_cookie_.push_back(primary_account_);
     for (std::set<std::string>::const_iterator i =
              valid_chrome_accounts_.begin();
@@ skipping 77 matching lines @@
            add_to_chrome_.begin();
        i != add_to_chrome_.end(); ++i) {
     if (account_id == i->first) {
       add_to_chrome_.erase(i);
       break;
     }
   }
 
   CalculateIfReconcileIsDone();
 }