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 13 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";
 
 #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
@@ skipping 118 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";
 
 AccountTrackerService::AccountTrackerService()
     : token_service_(NULL),
       signin_client_(NULL),
       shutdown_called_(false),
       network_fetches_enabled_(false) {
@@ skipping 234 matching lines @@
     std::string hosted_domain;
     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);
+    user_info->GetString("picture", &state.info.picture_url);
 
     NotifyAccountUpdated(state);
     SaveToPrefs(state);
   }
 }
 
 void AccountTrackerService::OnUserInfoFetchSuccess(
     AccountInfoFetcher* fetcher,
     const base::DictionaryValue* user_info) {
   const std::string& account_id = fetcher->account_id();
@@ skipping 37 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))

[Mike Lerman, 2015/04/20 13:25:23]

Roger: Does every account HAVE a picture? What if the user never set one and
still uses the default blue head?

[Roger Tawa OOO till Jul 10th, 2015/04/21 14:00:34]

That's a good question, don't have the answer.  If an account without a user
defined picture returns nothing for this path, then we need to have a special
string like "NO_PICTURE" or something.  Similar to what we do with hosted
domain.

[anthonyvd, 2015/04/29 15:15:08]

Done.

+          state.info.picture_url = base::UTF16ToUTF8(value);
         if (state.info.IsValid())
           NotifyAccountUpdated(state);
       }
     }
   }
 }
 
 void AccountTrackerService::SaveToPrefs(const AccountState& state) {
   if (!signin_client_->GetPrefs())
     return;
@@ skipping 14 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);
 }
 
 void AccountTrackerService::RemoveFromPrefs(const AccountState& state) {
   if (!signin_client_->GetPrefs())
     return;
 
   base::string16 account_id_16 = base::UTF8ToUTF16(state.info.account_id);
   ListPrefUpdate update(signin_client_->GetPrefs(), kAccountInfoPref);
   for(size_t i = 0; i < update->GetSize(); ++i) {
     base::DictionaryValue* dict = NULL;
@@ skipping 80 matching lines @@
   DCHECK(!email.empty());
   const std::string account_id = PickAccountIdForAccount(gaia, email);
   const bool already_exists = ContainsKey(accounts_, account_id);
   StartTrackingAccount(account_id);
   AccountState& state = accounts_[account_id];
   DCHECK(!already_exists || state.info.gaia == gaia);
   state.info.gaia = gaia;
   state.info.email = email;
   SaveToPrefs(state);
 }