Add service flags to the 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"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/profiler/scoped_tracker.h"
+#include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "components/signin/core/browser/refresh_token_annotation_request.h"
 #include "components/signin/core/browser/signin_client.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "components/signin/core/common/signin_pref_names.h"
 #include "components/signin/core/common/signin_switches.h"
+#include "google_apis/gaia/gaia_auth_consumer.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 "net/url_request/url_request_context_getter.h"
 
 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 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";
 
 class AccountInfoFetcher : public OAuth2TokenService::Consumer,
-                           public gaia::GaiaOAuthClient::Delegate {
+                           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;
 
   const std::string& account_id() { return account_id_; }
 
   void Start();
+  void SendSuccessIfDoneFetching();
 
   // OAuth2TokenService::Consumer implementation.
   void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
                          const std::string& access_token,
                          const base::Time& expiration_time) override;
   void OnGetTokenFailure(const OAuth2TokenService::Request* request,
                          const GoogleServiceAuthError& error) override;
 
   // gaia::GaiaOAuthClient::Delegate implementation.
   void OnGetUserInfoResponse(
       scoped_ptr<base::DictionaryValue> user_info) override;
   void OnOAuthError() override;
   void OnNetworkError(int response_code) override;
 
+  // Overridden from GaiaAuthConsumer:
+  void OnClientLoginSuccess(const ClientLoginResult& result) override;
+  void OnClientLoginFailure(const GoogleServiceAuthError& error) override;
+  void OnGetUserInfoSuccess(const UserInfoMap& data) override;
+  void OnGetUserInfoFailure(const GoogleServiceAuthError& error) override;
+
  private:
   OAuth2TokenService* token_service_;
   net::URLRequestContextGetter* request_context_getter_;
   AccountTrackerService* service_;
   const std::string account_id_;
 
   scoped_ptr<OAuth2TokenService::Request> login_token_request_;
   scoped_ptr<gaia::GaiaOAuthClient> gaia_oauth_client_;
+  scoped_ptr<GaiaAuthFetcher> gaia_auth_fetcher_;
+
+  scoped_ptr<base::DictionaryValue> fetched_user_info_;
+  scoped_ptr<std::vector<std::string> > fetched_service_flags_;
 };
 
 AccountInfoFetcher::AccountInfoFetcher(
     OAuth2TokenService* token_service,
     net::URLRequestContextGetter* request_context_getter,
     AccountTrackerService* service,
     const std::string& account_id)
     : OAuth2TokenService::Consumer("gaia_account_tracker"),
       token_service_(token_service),
       request_context_getter_(request_context_getter),
       service_(service),
       account_id_(account_id) {
   TRACE_EVENT_ASYNC_BEGIN1(
       "AccountTrackerService", "AccountIdFetcher", this,
       "account_id", account_id);
 }
 
 AccountInfoFetcher::~AccountInfoFetcher() {
   TRACE_EVENT_ASYNC_END0("AccountTrackerService", "AccountIdFetcher", this);
 }
 
 void AccountInfoFetcher::Start() {
   OAuth2TokenService::ScopeSet scopes;
   scopes.insert(GaiaConstants::kGoogleUserInfoEmail);
   scopes.insert(GaiaConstants::kGoogleUserInfoProfile);
+  scopes.insert(GaiaConstants::kOAuth1LoginScope);
   login_token_request_ = token_service_->StartRequest(
       account_id_, scopes, this);
 }
 
+void AccountInfoFetcher::SendSuccessIfDoneFetching() {
+  if (fetched_user_info_ && fetched_service_flags_) {
+    service_->OnUserInfoFetchSuccess(
+        this, fetched_user_info_.get(), fetched_service_flags_.get());
+  }
+}
+
 void AccountInfoFetcher::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
   TRACE_EVENT_ASYNC_STEP_PAST0(
       "AccountTrackerService", "AccountIdFetcher", this, "OnGetTokenSuccess");
   DCHECK_EQ(request, login_token_request_.get());
 
   gaia_oauth_client_.reset(new gaia::GaiaOAuthClient(request_context_getter_));
-
   const int kMaxRetries = 3;
   gaia_oauth_client_->GetUserInfo(access_token, kMaxRetries, this);
+
+  gaia_auth_fetcher_.reset(
+      new GaiaAuthFetcher(
+          this, GaiaConstants::kChromeSource, request_context_getter_));
+  gaia_auth_fetcher_->StartOAuthLogin(
+      access_token, GaiaConstants::kGaiaService);
 }
 
 void AccountInfoFetcher::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   TRACE_EVENT_ASYNC_STEP_PAST1("AccountTrackerService",
                                "AccountIdFetcher",
                                this,
                                "OnGetTokenFailure",
                                "google_service_auth_error",
                                error.ToString());
   LOG(ERROR) << "OnGetTokenFailure: " << error.ToString();
   DCHECK_EQ(request, login_token_request_.get());
   service_->OnUserInfoFetchFailure(this);
 }
 
 void AccountInfoFetcher::OnGetUserInfoResponse(
     scoped_ptr<base::DictionaryValue> user_info) {
   TRACE_EVENT_ASYNC_STEP_PAST1("AccountTrackerService",
                                "AccountIdFetcher",
                                this,
                                "OnGetUserInfoResponse",
                                "account_id",
                                account_id_);
-  service_->OnUserInfoFetchSuccess(this, user_info.get());
+  fetched_user_info_ = user_info.Pass();
+  SendSuccessIfDoneFetching();
+}
+
+void AccountInfoFetcher::OnClientLoginSuccess(
+    const ClientLoginResult& result) {
+  gaia_auth_fetcher_->StartGetUserInfo(result.lsid);
+}
+
+void AccountInfoFetcher::OnClientLoginFailure(
+    const GoogleServiceAuthError& error) {
+  service_->OnUserInfoFetchFailure(this);
+}
+
+void AccountInfoFetcher::OnGetUserInfoSuccess(const UserInfoMap& data) {
+  fetched_service_flags_.reset(new std::vector<std::string>);
+  UserInfoMap::const_iterator services_iter = data.find("allServices");
+  if (services_iter != data.end()) {
+    base::SplitString(services_iter->second, ',', fetched_service_flags_.get());
+    SendSuccessIfDoneFetching();
+  } else {
+    DLOG(WARNING) << "AccountInfoFetcher::OnGetUserInfoSuccess: "
+                  << "GetUserInfo response didn't include allServices field.";
+    service_->OnUserInfoFetchFailure(this);
+  }
+}
+
+void AccountInfoFetcher::OnGetUserInfoFailure(
+    const GoogleServiceAuthError& error) {
+  service_->OnUserInfoFetchFailure(this);
 }
 
 void AccountInfoFetcher::OnOAuthError() {
   TRACE_EVENT_ASYNC_STEP_PAST0(
       "AccountTrackerService", "AccountIdFetcher", this, "OnOAuthError");
   LOG(ERROR) << "OnOAuthError";
   service_->OnUserInfoFetchFailure(this);
 }
 
 void AccountInfoFetcher::OnNetworkError(int response_code) {
@@ skipping 271 matching lines @@
                                signin_client_->GetURLRequestContext(),
                                this,
                                account_id);
     user_info_requests_[account_id] = fetcher;
     fetcher->Start();
   }
 }
 
 void AccountTrackerService::SetAccountStateFromUserInfo(
     const std::string& account_id,
-    const base::DictionaryValue* user_info) {
+    const base::DictionaryValue* user_info,
+    const std::vector<std::string>* service_flags) {
   AccountState& state = accounts_[account_id];
 
   std::string gaia_id;
   std::string email;
   if (user_info->GetString("id", &gaia_id) &&
       user_info->GetString("email", &email)) {
     state.info.gaia = gaia_id;
     state.info.email = email;
 
     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);
 
+    state.info.service_flags = *service_flags;
+
     NotifyAccountUpdated(state);
     SaveToPrefs(state);
   }
 }
 
 void AccountTrackerService::OnUserInfoFetchSuccess(
     AccountInfoFetcher* fetcher,
-    const base::DictionaryValue* user_info) {
+    const base::DictionaryValue* user_info,
+    const std::vector<std::string>* service_flags) {
   const std::string& account_id = fetcher->account_id();
   DCHECK(ContainsKey(accounts_, account_id));
 
-  SetAccountStateFromUserInfo(account_id, user_info);
+  SetAccountStateFromUserInfo(account_id, user_info, service_flags);
   DeleteFetcher(fetcher);
 }
 
 void AccountTrackerService::OnUserInfoFetchFailure(
     AccountInfoFetcher* fetcher) {
   LOG(WARNING) << "Failed to get UserInfo for " << fetcher->account_id();
   NotifyAccountUpdateFailed(fetcher->account_id());
   DeleteFetcher(fetcher);
 }
 
@@ skipping 23 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);
+
+        const base::ListValue* service_flags_list;
+        if (dict->GetList(kAccountServiceFlagsPath, &service_flags_list)) {
+          std::string flag;
+          size_t index = 0;
+          while (service_flags_list->GetString(index++, &flag)) {

[Roger Tawa OOO till Jul 10th, 2015/05/11 20:03:50]

Would be better to use for (...) loop over the service_flags_list.  Should use
pre-increment.

[anthonyvd, 2015/05/14 17:45:03]

Done.

+            state.info.service_flags.push_back(flag);
+          }
+        }
+
         if (state.info.IsValid())
           NotifyAccountUpdated(state);
       }
     }
   }
   last_updated_ = base::Time::FromInternalValue(
       signin_client_->GetPrefs()->GetInt64(kAccountTrackerServiceLastUpdate));
 }
 
 void AccountTrackerService::SaveToPrefs(const AccountState& state) {
@@ skipping 16 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);
+
+  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())
     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 107 matching lines @@
   state.info.email = email;
   SaveToPrefs(state);
 
   DVLOG(1) << "AccountTrackerService::SeedAccountInfo"
            << " account_id=" << account_id
            << " gaia_id=" << gaia
            << " email=" << email;
 
   return account_id;
 }