Home | History | Annotate | Download | only in browser 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "components/signin/core/browser/account_tracker_service.h"
      6 
      7 #include "base/debug/trace_event.h"
      8 #include "base/prefs/pref_service.h"
      9 #include "base/prefs/scoped_user_pref_update.h"
     10 #include "base/strings/utf_string_conversions.h"
     11 #include "components/signin/core/browser/signin_manager.h"
     12 #include "components/signin/core/common/signin_pref_names.h"
     13 #include "google_apis/gaia/gaia_auth_util.h"
     14 #include "google_apis/gaia/gaia_constants.h"
     15 #include "google_apis/gaia/gaia_oauth_client.h"
     16 #include "google_apis/gaia/oauth2_token_service.h"
     17 #include "net/url_request/url_request_context_getter.h"
     18 
     19 namespace {
     20 
     21 const char kAccountKeyPath[] = "account_id";
     22 const char kAccountEmailPath[] = "email";
     23 const char kAccountGaiaPath[] = "gaia";
     24 
     25 }
     26 
     27 class AccountInfoFetcher : public OAuth2TokenService::Consumer,
     28                            public gaia::GaiaOAuthClient::Delegate {
     29  public:
     30   AccountInfoFetcher(OAuth2TokenService* token_service,
     31                      net::URLRequestContextGetter* request_context_getter,
     32                      AccountTrackerService* service,
     33                      const std::string& account_id);
     34   virtual ~AccountInfoFetcher();
     35 
     36   const std::string& account_id() { return account_id_; }
     37 
     38   void Start();
     39 
     40   // OAuth2TokenService::Consumer implementation.
     41   virtual void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
     42                                  const std::string& access_token,
     43                                  const base::Time& expiration_time) OVERRIDE;
     44   virtual void OnGetTokenFailure(const OAuth2TokenService::Request* request,
     45                                  const GoogleServiceAuthError& error) OVERRIDE;
     46 
     47   // gaia::GaiaOAuthClient::Delegate implementation.
     48   virtual void OnGetUserInfoResponse(
     49       scoped_ptr<base::DictionaryValue> user_info) OVERRIDE;
     50   virtual void OnOAuthError() OVERRIDE;
     51   virtual void OnNetworkError(int response_code) OVERRIDE;
     52 
     53  private:
     54   OAuth2TokenService* token_service_;
     55   net::URLRequestContextGetter* request_context_getter_;
     56   AccountTrackerService* service_;
     57   const std::string account_id_;
     58 
     59   scoped_ptr<OAuth2TokenService::Request> login_token_request_;
     60   scoped_ptr<gaia::GaiaOAuthClient> gaia_oauth_client_;
     61 };
     62 
     63 AccountInfoFetcher::AccountInfoFetcher(
     64     OAuth2TokenService* token_service,
     65     net::URLRequestContextGetter* request_context_getter,
     66     AccountTrackerService* service,
     67     const std::string& account_id)
     68     : OAuth2TokenService::Consumer("gaia_account_tracker"),
     69       token_service_(token_service),
     70       request_context_getter_(request_context_getter),
     71       service_(service),
     72       account_id_(account_id) {
     73   TRACE_EVENT_ASYNC_BEGIN1(
     74       "AccountTrackerService", "AccountIdFetcher", this,
     75       "account_id", account_id);
     76 }
     77 
     78 AccountInfoFetcher::~AccountInfoFetcher() {
     79   TRACE_EVENT_ASYNC_END0("AccountTrackerService", "AccountIdFetcher", this);
     80 }
     81 
     82 void AccountInfoFetcher::Start() {
     83   OAuth2TokenService::ScopeSet scopes;
     84   scopes.insert(GaiaConstants::kGoogleUserInfoEmail);
     85   scopes.insert(GaiaConstants::kGoogleUserInfoProfile);
     86   login_token_request_ = token_service_->StartRequest(
     87       account_id_, scopes, this);
     88 }
     89 
     90 void AccountInfoFetcher::OnGetTokenSuccess(
     91     const OAuth2TokenService::Request* request,
     92     const std::string& access_token,
     93     const base::Time& expiration_time) {
     94   TRACE_EVENT_ASYNC_STEP_PAST0(
     95       "AccountTrackerService", "AccountIdFetcher", this, "OnGetTokenSuccess");
     96   DCHECK_EQ(request, login_token_request_.get());
     97 
     98   gaia_oauth_client_.reset(new gaia::GaiaOAuthClient(request_context_getter_));
     99 
    100   const int kMaxRetries = 3;
    101   gaia_oauth_client_->GetUserInfo(access_token, kMaxRetries, this);
    102 }
    103 
    104 void AccountInfoFetcher::OnGetTokenFailure(
    105     const OAuth2TokenService::Request* request,
    106     const GoogleServiceAuthError& error) {
    107   TRACE_EVENT_ASYNC_STEP_PAST1("AccountTrackerService",
    108                                "AccountIdFetcher",
    109                                this,
    110                                "OnGetTokenFailure",
    111                                "google_service_auth_error",
    112                                error.ToString());
    113   LOG(ERROR) << "OnGetTokenFailure: " << error.ToString();
    114   DCHECK_EQ(request, login_token_request_.get());
    115   service_->OnUserInfoFetchFailure(this);
    116 }
    117 
    118 void AccountInfoFetcher::OnGetUserInfoResponse(
    119     scoped_ptr<base::DictionaryValue> user_info) {
    120   TRACE_EVENT_ASYNC_STEP_PAST1("AccountTrackerService",
    121                                "AccountIdFetcher",
    122                                this,
    123                                "OnGetUserInfoResponse",
    124                                "account_id",
    125                                account_id_);
    126   service_->OnUserInfoFetchSuccess(this, user_info.get());
    127 }
    128 
    129 void AccountInfoFetcher::OnOAuthError() {
    130   TRACE_EVENT_ASYNC_STEP_PAST0(
    131       "AccountTrackerService", "AccountIdFetcher", this, "OnOAuthError");
    132   LOG(ERROR) << "OnOAuthError";
    133   service_->OnUserInfoFetchFailure(this);
    134 }
    135 
    136 void AccountInfoFetcher::OnNetworkError(int response_code) {
    137   TRACE_EVENT_ASYNC_STEP_PAST1("AccountTrackerService",
    138                                "AccountIdFetcher",
    139                                this,
    140                                "OnNetworkError",
    141                                "response_code",
    142                                response_code);
    143   LOG(ERROR) << "OnNetworkError " << response_code;
    144   service_->OnUserInfoFetchFailure(this);
    145 }
    146 
    147 
    148 const char AccountTrackerService::kAccountInfoPref[] = "account_info";
    149 
    150 AccountTrackerService::AccountTrackerService()
    151     : token_service_(NULL),
    152       pref_service_(NULL),
    153       shutdown_called_(false) {
    154 }
    155 
    156 AccountTrackerService::~AccountTrackerService() {
    157   DCHECK(shutdown_called_);
    158 }
    159 
    160 void AccountTrackerService::Initialize(
    161     OAuth2TokenService* token_service,
    162     PrefService* pref_service,
    163     net::URLRequestContextGetter* request_context_getter) {
    164   DCHECK(token_service);
    165   DCHECK(!token_service_);
    166   DCHECK(pref_service);
    167   DCHECK(!pref_service_);
    168   token_service_ = token_service;
    169   pref_service_ = pref_service;
    170   request_context_getter_ = request_context_getter;
    171   token_service_->AddObserver(this);
    172   LoadFromPrefs();
    173   LoadFromTokenService();
    174 }
    175 
    176 void AccountTrackerService::Shutdown() {
    177   shutdown_called_ = true;
    178   STLDeleteValues(&user_info_requests_);
    179   token_service_->RemoveObserver(this);
    180 }
    181 
    182 void AccountTrackerService::AddObserver(Observer* observer) {
    183   observer_list_.AddObserver(observer);
    184 }
    185 
    186 void AccountTrackerService::RemoveObserver(Observer* observer) {
    187   observer_list_.RemoveObserver(observer);
    188 }
    189 
    190 bool AccountTrackerService::IsAllUserInfoFetched() const {
    191   return user_info_requests_.empty();
    192 }
    193 
    194 std::vector<AccountTrackerService::AccountInfo>
    195 AccountTrackerService::GetAccounts() const {
    196   std::vector<AccountInfo> accounts;
    197 
    198   for (std::map<std::string, AccountState>::const_iterator it =
    199            accounts_.begin();
    200        it != accounts_.end();
    201        ++it) {
    202     const AccountState& state = it->second;
    203     accounts.push_back(state.info);
    204   }
    205   return accounts;
    206 }
    207 
    208 AccountTrackerService::AccountInfo AccountTrackerService::GetAccountInfo(
    209     const std::string& account_id) {
    210   if (ContainsKey(accounts_, account_id))
    211     return accounts_[account_id].info;
    212 
    213   return AccountInfo();
    214 }
    215 
    216 AccountTrackerService::AccountInfo
    217 AccountTrackerService::FindAccountInfoByGaiaId(
    218     const std::string& gaia_id) {
    219   for (std::map<std::string, AccountState>::const_iterator it =
    220            accounts_.begin();
    221        it != accounts_.end();
    222        ++it) {
    223     const AccountState& state = it->second;
    224     if (state.info.gaia == gaia_id)
    225       return state.info;
    226   }
    227 
    228   return AccountInfo();
    229 }
    230 
    231 AccountTrackerService::AccountInfo
    232 AccountTrackerService::FindAccountInfoByEmail(
    233     const std::string& email) {
    234   for (std::map<std::string, AccountState>::const_iterator it =
    235            accounts_.begin();
    236        it != accounts_.end();
    237        ++it) {
    238     const AccountState& state = it->second;
    239     if (gaia::AreEmailsSame(state.info.email, email))
    240       return state.info;
    241   }
    242 
    243   return AccountInfo();
    244 }
    245 
    246 AccountTrackerService::AccountIdMigrationState
    247 AccountTrackerService::GetMigrationState() {
    248   return GetMigrationState(pref_service_);
    249 }
    250 
    251 // static
    252 AccountTrackerService::AccountIdMigrationState
    253 AccountTrackerService::GetMigrationState(PrefService* pref_service) {
    254   return static_cast<AccountTrackerService::AccountIdMigrationState>(
    255       pref_service->GetInteger(prefs::kAccountIdMigrationState));
    256 }
    257 
    258 void AccountTrackerService::OnRefreshTokenAvailable(
    259     const std::string& account_id) {
    260   TRACE_EVENT1("AccountTrackerService",
    261                "AccountTracker::OnRefreshTokenAvailable",
    262                "account_id",
    263                account_id);
    264   DVLOG(1) << "AVAILABLE " << account_id;
    265 
    266   StartTrackingAccount(account_id);
    267   AccountState& state = accounts_[account_id];
    268 
    269   if (state.info.gaia.empty())
    270     StartFetchingUserInfo(account_id);
    271 }
    272 
    273 void AccountTrackerService::OnRefreshTokenRevoked(
    274     const std::string& account_id) {
    275   TRACE_EVENT1("AccountTrackerService",
    276                "AccountTracker::OnRefreshTokenRevoked",
    277                "account_id",
    278                account_id);
    279 
    280   DVLOG(1) << "REVOKED " << account_id;
    281   StopTrackingAccount(account_id);
    282 }
    283 
    284 void AccountTrackerService::NotifyAccountUpdated(const AccountState& state) {
    285   DCHECK(!state.info.gaia.empty());
    286   FOR_EACH_OBSERVER(
    287       Observer, observer_list_, OnAccountUpdated(state.info));
    288 }
    289 
    290 void AccountTrackerService::NotifyAccountRemoved(const AccountState& state) {
    291   DCHECK(!state.info.gaia.empty());
    292   FOR_EACH_OBSERVER(
    293       Observer, observer_list_, OnAccountRemoved(state.info));
    294 }
    295 
    296 void AccountTrackerService::StartTrackingAccount(
    297     const std::string& account_id) {
    298   if (!ContainsKey(accounts_, account_id)) {
    299     DVLOG(1) << "StartTracking " << account_id;
    300     AccountState state;
    301     state.info.account_id = account_id;
    302     accounts_.insert(make_pair(account_id, state));
    303   }
    304 }
    305 
    306 void AccountTrackerService::StopTrackingAccount(const std::string& account_id) {
    307   DVLOG(1) << "StopTracking " << account_id;
    308   if (ContainsKey(accounts_, account_id)) {
    309     AccountState& state = accounts_[account_id];
    310     RemoveFromPrefs(state);
    311     if (!state.info.gaia.empty())
    312       NotifyAccountRemoved(state);
    313 
    314     accounts_.erase(account_id);
    315   }
    316 
    317   if (ContainsKey(user_info_requests_, account_id))
    318     DeleteFetcher(user_info_requests_[account_id]);
    319 }
    320 
    321 void AccountTrackerService::StartFetchingUserInfo(
    322     const std::string& account_id) {
    323   if (ContainsKey(user_info_requests_, account_id))
    324     DeleteFetcher(user_info_requests_[account_id]);
    325 
    326   DVLOG(1) << "StartFetching " << account_id;
    327   AccountInfoFetcher* fetcher =
    328       new AccountInfoFetcher(token_service_,
    329                              request_context_getter_.get(),
    330                              this,
    331                              account_id);
    332   user_info_requests_[account_id] = fetcher;
    333   fetcher->Start();
    334 }
    335 
    336 void AccountTrackerService::OnUserInfoFetchSuccess(
    337     AccountInfoFetcher* fetcher,
    338     const base::DictionaryValue* user_info) {
    339   const std::string& account_id = fetcher->account_id();
    340   DCHECK(ContainsKey(accounts_, account_id));
    341   AccountState& state = accounts_[account_id];
    342 
    343   std::string gaia_id;
    344   std::string email;
    345   if (user_info->GetString("id", &gaia_id) &&
    346       user_info->GetString("email", &email)) {
    347     state.info.gaia = gaia_id;
    348     state.info.email = email;
    349 
    350     NotifyAccountUpdated(state);
    351     SaveToPrefs(state);
    352   }
    353   DeleteFetcher(fetcher);
    354 }
    355 
    356 void AccountTrackerService::OnUserInfoFetchFailure(
    357     AccountInfoFetcher* fetcher) {
    358   LOG(WARNING) << "Failed to get UserInfo for " << fetcher->account_id();
    359   DeleteFetcher(fetcher);
    360   // TODO(rogerta): figure out when to retry.
    361 }
    362 
    363 void AccountTrackerService::DeleteFetcher(AccountInfoFetcher* fetcher) {
    364   DVLOG(1) << "DeleteFetcher " << fetcher->account_id();
    365   const std::string& account_id = fetcher->account_id();
    366   DCHECK(ContainsKey(user_info_requests_, account_id));
    367   DCHECK_EQ(fetcher, user_info_requests_[account_id]);
    368   user_info_requests_.erase(account_id);
    369   delete fetcher;
    370 }
    371 
    372 void AccountTrackerService::LoadFromPrefs() {
    373   const base::ListValue* list = pref_service_->GetList(kAccountInfoPref);
    374   for (size_t i = 0; i < list->GetSize(); ++i) {
    375     const base::DictionaryValue* dict;
    376     if (list->GetDictionary(i, &dict)) {
    377       base::string16 value;
    378       if (dict->GetString(kAccountKeyPath, &value)) {
    379         std::string account_id = base::UTF16ToUTF8(value);
    380         StartTrackingAccount(account_id);
    381         AccountState& state = accounts_[account_id];
    382 
    383         if (dict->GetString(kAccountGaiaPath, &value))
    384           state.info.gaia = base::UTF16ToUTF8(value);
    385         if (dict->GetString(kAccountEmailPath, &value))
    386           state.info.email = base::UTF16ToUTF8(value);
    387 
    388         if (!state.info.gaia.empty())
    389           NotifyAccountUpdated(state);
    390       }
    391     }
    392   }
    393 }
    394 
    395 void AccountTrackerService::SaveToPrefs(const AccountState& state) {
    396   if (!pref_service_)
    397     return;
    398 
    399   base::DictionaryValue* dict = NULL;
    400   base::string16 account_id_16 = base::UTF8ToUTF16(state.info.account_id);
    401   ListPrefUpdate update(pref_service_, kAccountInfoPref);
    402   for(size_t i = 0; i < update->GetSize(); ++i, dict = NULL) {
    403     if (update->GetDictionary(i, &dict)) {
    404       base::string16 value;
    405       if (dict->GetString(kAccountKeyPath, &value) && value == account_id_16)
    406         break;
    407     }
    408   }
    409 
    410   if (!dict) {
    411     dict = new base::DictionaryValue();
    412     update->Append(dict);  // |update| takes ownership.
    413     dict->SetString(kAccountKeyPath, account_id_16);
    414   }
    415 
    416   dict->SetString(kAccountEmailPath, state.info.email);
    417   dict->SetString(kAccountGaiaPath, state.info.gaia);
    418 }
    419 
    420 void AccountTrackerService::RemoveFromPrefs(const AccountState& state) {
    421   if (!pref_service_)
    422     return;
    423 
    424   base::string16 account_id_16 = base::UTF8ToUTF16(state.info.account_id);
    425   ListPrefUpdate update(pref_service_, kAccountInfoPref);
    426   for(size_t i = 0; i < update->GetSize(); ++i) {
    427     base::DictionaryValue* dict = NULL;
    428     if (update->GetDictionary(i, &dict)) {
    429       base::string16 value;
    430       if (dict->GetString(kAccountKeyPath, &value) && value == account_id_16) {
    431         update->Remove(i, NULL);
    432         break;
    433       }
    434     }
    435   }
    436 }
    437 
    438 void AccountTrackerService::LoadFromTokenService() {
    439   std::vector<std::string> accounts = token_service_->GetAccounts();
    440   for (std::vector<std::string>::const_iterator it = accounts.begin();
    441        it != accounts.end(); ++it) {
    442     OnRefreshTokenAvailable(*it);
    443   }
    444 }
    445