Change ProfileDownloader to use AccountTrackerService.

components/signin/core/browser/account_tracker_service.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_tracker_service.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
@@ skipping 16 matching lines @@
 
 namespace {
 
 const char kAccountKeyPath[] = "account_id";
 const char kAccountEmailPath[] = "email";
 const char kAccountGaiaPath[] = "gaia";
 const char kAccountHostedDomainPath[] = "hd";
 const char kAccountFullNamePath[] = "full_name";
 const char kAccountGivenNamePath[] = "given_name";
 const char kAccountLocalePath[] = "locale";
+const char kAccountPictureURLPath[] = "picture_url";
 const char kAccountServiceFlagsPath[] = "service_flags";
 
 const base::TimeDelta kRefreshFromTokenServiceDelay =
     base::TimeDelta::FromHours(24);
 
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
 // IsRefreshTokenDeviceIdExperimentEnabled is called from
 // SendRefreshTokenAnnotationRequest only on desktop platforms.
 bool IsRefreshTokenDeviceIdExperimentEnabled() {
   const std::string group_name =
       base::FieldTrialList::FindFullName("RefreshTokenDeviceId");
   return group_name == "Enabled";
 }
 #endif
 }
 
 // This must be a string which can never be a valid domain.
 const char AccountTrackerService::kNoHostedDomainFound[] = "NO_HOSTED_DOMAIN";
 
+// This must be a string which can never be a valid picture URL.
+const char AccountTrackerService::kNoPictureURLFound[] = "NO_PICTURE_URL";
+
 class AccountInfoFetcher : public OAuth2TokenService::Consumer,
                            public gaia::GaiaOAuthClient::Delegate,
                            public GaiaAuthConsumer {
  public:
   AccountInfoFetcher(OAuth2TokenService* token_service,
                      net::URLRequestContextGetter* request_context_getter,
                      AccountTrackerService* service,
                      const std::string& account_id);
   ~AccountInfoFetcher() override;
 
@@ skipping 157 matching lines @@
                                "OnNetworkError",
                                "response_code",
                                response_code);
   LOG(ERROR) << "OnNetworkError " << response_code;
   service_->OnUserInfoFetchFailure(this);
 }
 
 AccountTrackerService::AccountInfo::AccountInfo() {}
 AccountTrackerService::AccountInfo::~AccountInfo() {}
 
-bool AccountTrackerService::AccountInfo::IsValid() {
+bool AccountTrackerService::AccountInfo::IsValid() const {
   return !account_id.empty() && !email.empty() && !gaia.empty() &&
          !hosted_domain.empty() && !full_name.empty() && !given_name.empty() &&
-         !locale.empty();
+         !locale.empty() && !picture_url.empty();
 }
 
 
 const char AccountTrackerService::kAccountInfoPref[] = "account_info";
 const char AccountTrackerService::kAccountTrackerServiceLastUpdate[] =
     "account_tracker_service_last_update";
 
 AccountTrackerService::AccountTrackerService()
     : token_service_(NULL),
       signin_client_(NULL),
@@ skipping 266 matching lines @@
     if (user_info->GetString("hd", &hosted_domain) && !hosted_domain.empty()) {
       state.info.hosted_domain = hosted_domain;
     } else {
       state.info.hosted_domain = kNoHostedDomainFound;
     }
 
     user_info->GetString("name", &state.info.full_name);
     user_info->GetString("given_name", &state.info.given_name);
     user_info->GetString("locale", &state.info.locale);
 
+    std::string picture_url;
+    if(user_info->GetString("picture", &picture_url)) {
+      state.info.picture_url = picture_url;
+    } else {
+      state.info.picture_url = kNoPictureURLFound;
+    }
+
     state.info.service_flags = *service_flags;
 
     NotifyAccountUpdated(state);
     SaveToPrefs(state);
   }
 }
 
 void AccountTrackerService::OnUserInfoFetchSuccess(
     AccountInfoFetcher* fetcher,
     const base::DictionaryValue* user_info,
@@ skipping 38 matching lines @@
         if (dict->GetString(kAccountEmailPath, &value))
           state.info.email = base::UTF16ToUTF8(value);
         if (dict->GetString(kAccountHostedDomainPath, &value))
           state.info.hosted_domain = base::UTF16ToUTF8(value);
         if (dict->GetString(kAccountFullNamePath, &value))
           state.info.full_name = base::UTF16ToUTF8(value);
         if (dict->GetString(kAccountGivenNamePath, &value))
           state.info.given_name = base::UTF16ToUTF8(value);
         if (dict->GetString(kAccountLocalePath, &value))
           state.info.locale = base::UTF16ToUTF8(value);
+        if (dict->GetString(kAccountPictureURLPath, &value))
+          state.info.picture_url = base::UTF16ToUTF8(value);
 
         const base::ListValue* service_flags_list;
         if (dict->GetList(kAccountServiceFlagsPath, &service_flags_list)) {
           std::string flag;
           for(base::Value* flag: *service_flags_list) {
             std::string flag_string;
             if(flag->GetAsString(&flag_string)) {
               state.info.service_flags.push_back(flag_string);
             }
           }
@@ skipping 28 matching lines @@
     update->Append(dict);  // |update| takes ownership.
     dict->SetString(kAccountKeyPath, account_id_16);
   }
 
   dict->SetString(kAccountEmailPath, state.info.email);
   dict->SetString(kAccountGaiaPath, state.info.gaia);
   dict->SetString(kAccountHostedDomainPath, state.info.hosted_domain);
   dict->SetString(kAccountFullNamePath, state.info.full_name);
   dict->SetString(kAccountGivenNamePath, state.info.given_name);
   dict->SetString(kAccountLocalePath, state.info.locale);
+  dict->SetString(kAccountPictureURLPath, state.info.picture_url);
 
   scoped_ptr<base::ListValue> service_flags_list;
   service_flags_list.reset(new base::ListValue);
   service_flags_list->AppendStrings(state.info.service_flags);
 
   dict->Set(kAccountServiceFlagsPath, service_flags_list.Pass());
 }
 
 void AccountTrackerService::RemoveFromPrefs(const AccountState& state) {
   if (!signin_client_->GetPrefs())
@@ skipping 113 matching lines @@
   state.info.email = email;
   SaveToPrefs(state);
 
   DVLOG(1) << "AccountTrackerService::SeedAccountInfo"
            << " account_id=" << account_id
            << " gaia_id=" << gaia
            << " email=" << email;
 
   return account_id;
 }
+
+void AccountTrackerService::SeedAccountInfo(
+    AccountTrackerService::AccountInfo info) {
+  info.account_id = PickAccountIdForAccount(info.gaia, info.email);
+  if (info.hosted_domain.empty()) {
+    info.hosted_domain = kNoHostedDomainFound;
+  }
+
+  if(info.IsValid()) {
+    if(!ContainsKey(accounts_, info.account_id)) {
+      SeedAccountInfo(info.gaia, info.email);
+    }
+
+    AccountState& state = accounts_[info.account_id];
+    state.info = info;
+    NotifyAccountUpdated(state);
+    SaveToPrefs(state);
+  }
+}