Handle ListAccount fetches from within the GaiaCookieManagerService.

components/signin/core/browser/account_reconcilor.cc

 // Copyright 2014 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 "components/signin/core/browser/account_reconcilor.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_client.h"
 #include "components/signin/core/browser/signin_metrics.h"
 #include "components/signin/core/common/profile_management_switches.h"
-#include "google_apis/gaia/gaia_auth_fetcher.h"
 #include "google_apis/gaia/gaia_auth_util.h"
-#include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_oauth_client.h"
 #include "google_apis/gaia/gaia_urls.h"
-#include "net/cookies/canonical_cookie.h"
 
 
 namespace {
 
 class EmailEqualToFunc : public std::equal_to<std::pair<std::string, bool> > {
  public:
   bool operator()(const std::pair<std::string, bool>& p1,
                   const std::pair<std::string, bool>& p2) const;
 };
 
@@ skipping 25 matching lines @@
     GaiaCookieManagerService* cookie_manager_service)
     : token_service_(token_service),
       signin_manager_(signin_manager),
       client_(client),
       cookie_manager_service_(cookie_manager_service),
       registered_with_token_service_(false),
       registered_with_cookie_manager_service_(false),
       registered_with_content_settings_(false),
       is_reconcile_started_(false),
       first_execution_(true),
-      are_gaia_accounts_set_(false),
       chrome_accounts_changed_(false) {
   VLOG(1) << "AccountReconcilor::AccountReconcilor";
 }
 
 AccountReconcilor::~AccountReconcilor() {
   VLOG(1) << "AccountReconcilor::~AccountReconcilor";
   // Make sure shutdown was called first.
   DCHECK(!registered_with_token_service_);
   DCHECK(!registered_with_cookie_manager_service_);
 }
 
 void AccountReconcilor::Initialize(bool start_reconcile_if_tokens_available) {
   VLOG(1) << "AccountReconcilor::Initialize";
   RegisterWithSigninManager();
 
   // If this user is not signed in, the reconcilor should do nothing but
   // wait for signin.
   if (IsProfileConnected()) {
     RegisterWithCookieManagerService();
-    RegisterForCookieChanges();
     RegisterWithContentSettings();
     RegisterWithTokenService();
 
     // Start a reconcile if the tokens are already loaded.
     if (start_reconcile_if_tokens_available &&
         token_service_->GetAccounts().size() > 0) {
       StartReconcile();
     }
   }
 }
 
 void AccountReconcilor::Shutdown() {
   VLOG(1) << "AccountReconcilor::Shutdown";
-  gaia_fetcher_.reset();
-  get_gaia_accounts_callbacks_.clear();
   UnregisterWithCookieManagerService();
   UnregisterWithSigninManager();
   UnregisterWithTokenService();
-  UnregisterForCookieChanges();
   UnregisterWithContentSettings();
 }
 
-void AccountReconcilor::RegisterForCookieChanges() {
-  // First clear any existing registration to avoid DCHECKs that can otherwise
-  // go off in some embedders on reauth (e.g., ChromeSigninClient).
-  UnregisterForCookieChanges();
-  cookie_changed_subscription_ = client_->AddCookieChangedCallback(
-      GaiaUrls::GetInstance()->gaia_url(),
-      "LSID",
-      base::Bind(&AccountReconcilor::OnCookieChanged, base::Unretained(this)));
-}
-
-void AccountReconcilor::UnregisterForCookieChanges() {
-  cookie_changed_subscription_.reset();
-}
-
 void AccountReconcilor::RegisterWithSigninManager() {
   signin_manager_->AddObserver(this);
 }
 
 void AccountReconcilor::UnregisterWithSigninManager() {
   signin_manager_->RemoveObserver(this);
 }
 
 void AccountReconcilor::RegisterWithContentSettings() {
   VLOG(1) << "AccountReconcilor::RegisterWithContentSettings";
@@ skipping 54 matching lines @@
     return;
 
   cookie_manager_service_->RemoveObserver(this);
   registered_with_cookie_manager_service_ = false;
 }
 
 bool AccountReconcilor::IsProfileConnected() {
   return signin_manager_->IsAuthenticated();
 }
 
-void AccountReconcilor::OnCookieChanged(const net::CanonicalCookie& cookie,
-                                        bool removed) {
-  DCHECK_EQ("LSID", cookie.Name());
-  DCHECK_EQ(GaiaUrls::GetInstance()->gaia_url().host(), cookie.Domain());
-  if (cookie.IsSecure() && cookie.IsHttpOnly()) {
-    VLOG(1) << "AccountReconcilor::OnCookieChanged: LSID changed";
-
-    // It is possible that O2RT is not available at this moment.
-    if (!token_service_->GetAccounts().size()) {
-      VLOG(1) << "AccountReconcilor::OnCookieChanged: cookie change is ingored"
-                 "because O2RT is not available yet.";
-      return;
-    }
-
-    StartReconcile();
-  }
-}
-
 void AccountReconcilor::OnContentSettingChanged(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     std::string resource_identifier) {
   // If this is not a change to cookie settings, just ignore.
   if (content_type != CONTENT_SETTINGS_TYPE_COOKIES)
     return;
 
   // If this does not affect GAIA, just ignore.  If the primary pattern is
@@ skipping 13 matching lines @@
   // Remember that accounts have changed if a reconcile is already started.
   chrome_accounts_changed_ = is_reconcile_started_;
   StartReconcile();
 }
 
 void AccountReconcilor::GoogleSigninSucceeded(const std::string& account_id,
                                               const std::string& username,
                                               const std::string& password) {
   VLOG(1) << "AccountReconcilor::GoogleSigninSucceeded: signed in";
   RegisterWithCookieManagerService();
-  RegisterForCookieChanges();
   RegisterWithContentSettings();
   RegisterWithTokenService();
 }
 
 void AccountReconcilor::GoogleSignedOut(const std::string& account_id,
                                         const std::string& username) {
   VLOG(1) << "AccountReconcilor::GoogleSignedOut: signed out";
-  gaia_fetcher_.reset();
-  get_gaia_accounts_callbacks_.clear();
   AbortReconcile();
   UnregisterWithCookieManagerService();
   UnregisterWithTokenService();
-  UnregisterForCookieChanges();
   UnregisterWithContentSettings();
   PerformLogoutAllAccountsAction();
 }
 
 void AccountReconcilor::PerformMergeAction(const std::string& account_id) {
   if (!switches::IsEnableAccountConsistency()) {
     MarkAccountAsAddedToCookie(account_id);
     return;
   }
   VLOG(1) << "AccountReconcilor::PerformMergeAction: " << account_id;
   cookie_manager_service_->AddAccountToCookie(account_id);
 }
 
 void AccountReconcilor::PerformLogoutAllAccountsAction() {
   if (!switches::IsEnableAccountConsistency())
     return;
   VLOG(1) << "AccountReconcilor::PerformLogoutAllAccountsAction";
   cookie_manager_service_->LogOutAllAccounts();
 }
 
 void AccountReconcilor::StartReconcile() {
   if (!IsProfileConnected() || !client_->AreSigninCookiesAllowed()) {
     VLOG(1) << "AccountReconcilor::StartReconcile: !connected or no cookies";
     return;
   }
 
-  if (is_reconcile_started_ || get_gaia_accounts_callbacks_.size() > 0)
+  if (is_reconcile_started_)
     return;
 
   is_reconcile_started_ = true;
 
   // Reset state for validating gaia cookie.
-  are_gaia_accounts_set_ = false;
   gaia_accounts_.clear();
 
   // Reset state for validating oauth2 tokens.
   primary_account_.clear();
   chrome_accounts_.clear();
   add_to_cookie_.clear();
   ValidateAccountsFromTokenService();
 
-  GetAccountsFromCookie(base::Bind(
-      &AccountReconcilor::ContinueReconcileActionAfterGetGaiaAccounts,
-      base::Unretained(this)));
-}
-
-void AccountReconcilor::GetAccountsFromCookie(
-    GetAccountsFromCookieCallback callback) {
-  get_gaia_accounts_callbacks_.push_back(callback);
-  if (!gaia_fetcher_)
-    MayBeDoNextListAccounts();
-}
-
-void AccountReconcilor::OnListAccountsSuccess(const std::string& data) {
-  gaia_fetcher_.reset();
-
-  // Get account information from response data.
-  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].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::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::kReconcilorSource,
-        client_->GetURLRequestContext()));
-    gaia_fetcher_->StartListAccounts();
+  // Rely on the GCMS to manage calls to and responses from ListAccounts.
+  if (cookie_manager_service_->ListAccounts(&gaia_accounts_)) {
+    OnGaiaAccountsInCookieUpdated(
+        gaia_accounts_, GoogleServiceAuthError(GoogleServiceAuthError::NONE));
   }
 }
 
-void AccountReconcilor::ContinueReconcileActionAfterGetGaiaAccounts(
-    const GoogleServiceAuthError& error,
-    const std::vector<std::pair<std::string, bool> >& accounts) {
+void AccountReconcilor::OnGaiaAccountsInCookieUpdated(
+        const std::vector<std::pair<std::string, bool> >& accounts,
+        const GoogleServiceAuthError& error) {
   if (error.state() == GoogleServiceAuthError::NONE) {
     gaia_accounts_ = accounts;
-    are_gaia_accounts_set_ = true;
-    FinishReconcile();
+
+    // It is possible that O2RT is not available at this moment.
+    if (token_service_->GetAccounts().empty())
+      return;
+
+    is_reconcile_started_ ? FinishReconcile() : StartReconcile();
   } else {
     AbortReconcile();
   }
 }
 
 void AccountReconcilor::ValidateAccountsFromTokenService() {
   primary_account_ = signin_manager_->GetAuthenticatedAccountId();
   DCHECK(!primary_account_.empty());
 
   chrome_accounts_ = token_service_->GetAccounts();
@@ skipping 11 matching lines @@
     // a restart.
     Shutdown();
     Initialize(true);
   } else {
     Shutdown();
   }
 }
 
 void AccountReconcilor::FinishReconcile() {
   VLOG(1) << "AccountReconcilor::FinishReconcile";
-  DCHECK(are_gaia_accounts_set_);
   DCHECK(add_to_cookie_.empty());
   int number_gaia_accounts = gaia_accounts_.size();
   bool are_primaries_equal = number_gaia_accounts > 0 &&
       gaia::AreEmailsSame(primary_account_, gaia_accounts_[0].first);
 
   // If there are any accounts in the gaia cookie but not in chrome, then
   // those accounts need to be removed from the cookie.  This means we need
   // to blow the cookie away.
   int removed_from_cookie = 0;
   for (size_t i = 0; i < gaia_accounts_.size(); ++i) {
@@ skipping 110 matching lines @@
 
 void AccountReconcilor::OnAddAccountToCookieCompleted(
     const std::string& account_id,
     const GoogleServiceAuthError& error) {
   // Always listens to GaiaCookieManagerService. Only proceed if reconciling.
   if (is_reconcile_started_ && MarkAccountAsAddedToCookie(account_id)) {
     CalculateIfReconcileIsDone();
     ScheduleStartReconcileIfChromeAccountsChanged();
   }
 }