We should use UserID object to identify users instead of username.

chrome/browser/supervised_user/legacy/supervised_user_refresh_token_fetcher.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 "chrome/browser/supervised_user/legacy/supervised_user_refresh_token_fetcher.h"
 
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
+#include "components/user_manager/user_id.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/gaia_oauth_client.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "google_apis/gaia/oauth2_api_call_flow.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_status_code.h"
@@ skipping 34 matching lines @@
       public GaiaOAuthClient::Delegate {
  public:
   SupervisedUserRefreshTokenFetcherImpl(
       OAuth2TokenService* oauth2_token_service,
       const std::string& account_id,
       const std::string& device_id,
       URLRequestContextGetter* context);
   ~SupervisedUserRefreshTokenFetcherImpl() override;
 
   // SupervisedUserRefreshTokenFetcher implementation:
-  void Start(const std::string& supervised_user_id,
+  void Start(const user_manager::UserID& supervised_user_id,
              const std::string& device_name,
              const TokenCallback& callback) override;
 
  protected:
   // OAuth2TokenService::Consumer implementation:
   void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
                          const std::string& access_token,
                          const Time& expiration_time) override;
   void OnGetTokenFailure(const OAuth2TokenService::Request* request,
                          const GoogleServiceAuthError& error) override;
@@ skipping 17 matching lines @@
 
   void DispatchNetworkError(int error_code);
   void DispatchGoogleServiceAuthError(const GoogleServiceAuthError& error,
                                       const std::string& token);
   OAuth2TokenService* oauth2_token_service_;
   std::string account_id_;
   std::string device_id_;
   URLRequestContextGetter* context_;
 
   std::string device_name_;
-  std::string supervised_user_id_;
+  user_manager::UserID supervised_user_id_;
   TokenCallback callback_;
 
   scoped_ptr<OAuth2TokenService::Request> access_token_request_;
   std::string access_token_;
   bool access_token_expired_;
   scoped_ptr<URLFetcher> url_fetcher_;
   scoped_ptr<GaiaOAuthClient> gaia_oauth_client_;
 };
 
 SupervisedUserRefreshTokenFetcherImpl::SupervisedUserRefreshTokenFetcherImpl(
     OAuth2TokenService* oauth2_token_service,
     const std::string& account_id,
     const std::string& device_id,
     URLRequestContextGetter* context)
     : OAuth2TokenService::Consumer("supervised_user"),
       oauth2_token_service_(oauth2_token_service),
       account_id_(account_id),
       device_id_(device_id),
       context_(context),
+      supervised_user_id_(std::string(), std::string()),
       access_token_expired_(false) {}
 
 SupervisedUserRefreshTokenFetcherImpl::
 ~SupervisedUserRefreshTokenFetcherImpl() {}
 
 void SupervisedUserRefreshTokenFetcherImpl::Start(
-    const std::string& supervised_user_id,
+    const user_manager::UserID& supervised_user_id,
     const std::string& device_name,
     const TokenCallback& callback) {
   DCHECK(callback_.is_null());
   supervised_user_id_ = supervised_user_id;
   device_name_ = device_name;
   callback_ = callback;
   StartFetching();
 }
 
 void SupervisedUserRefreshTokenFetcherImpl::StartFetching() {
@@ skipping 22 matching lines @@
                              net::LOAD_DO_NOT_SAVE_COOKIES);
   url_fetcher_->SetAutomaticallyRetryOnNetworkChanges(kNumRetries);
   url_fetcher_->AddExtraRequestHeader(
       base::StringPrintf(kAuthorizationHeaderFormat, access_token.c_str()));
 
   std::string body = base::StringPrintf(
       kIssueTokenBodyFormat,
       net::EscapeUrlEncodedData(
           GaiaUrls::GetInstance()->oauth2_chrome_client_id(), true).c_str(),
       net::EscapeUrlEncodedData(kChromeSyncSupervisedOAuth2Scope, true).c_str(),
-      net::EscapeUrlEncodedData(supervised_user_id_, true).c_str(),
+      net::EscapeUrlEncodedData(supervised_user_id_.GetUserEmail(), true).c_str(),
       net::EscapeUrlEncodedData(device_name_, true).c_str());
   if (!device_id_.empty()) {
     body.append(base::StringPrintf(
         kIssueTokenBodyFormatDeviceIdAddendum,
         net::EscapeUrlEncodedData(device_id_, true).c_str()));
   }
   url_fetcher_->SetUploadData("application/x-www-form-urlencoded", body);
 
   url_fetcher_->Start();
 }
@@ skipping 110 matching lines @@
     URLRequestContextGetter* context) {
   scoped_ptr<SupervisedUserRefreshTokenFetcher> fetcher(
       new SupervisedUserRefreshTokenFetcherImpl(oauth2_token_service,
                                                 account_id,
                                                 device_id,
                                                 context));
   return fetcher.Pass();
 }
 
 SupervisedUserRefreshTokenFetcher::~SupervisedUserRefreshTokenFetcher() {}