Rename "managed (mode|user)" to "supervised user" (part 2)

chrome/browser/supervised_user/supervised_user_refresh_token_fetcher.cc

 // Copyright 2013 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/managed_mode/managed_user_refresh_token_fetcher.h"
+#include "chrome/browser/supervised_user/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 "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"
@@ skipping 22 matching lines @@
     "&scope=%s"
     "&response_type=code"
     "&profile_id=%s"
     "&device_name=%s";
 
 static const char kAuthorizationHeaderFormat[] =
     "Authorization: Bearer %s";
 
 static const char kCodeKey[] = "code";
 
-class ManagedUserRefreshTokenFetcherImpl
-    : public ManagedUserRefreshTokenFetcher,
+class SupervisedUserRefreshTokenFetcherImpl
+    : public SupervisedUserRefreshTokenFetcher,
       public OAuth2TokenService::Consumer,
       public URLFetcherDelegate,
       public GaiaOAuthClient::Delegate {
  public:
-  ManagedUserRefreshTokenFetcherImpl(OAuth2TokenService* oauth2_token_service,
-                                     const std::string& account_id,
-                                     URLRequestContextGetter* context);
-  virtual ~ManagedUserRefreshTokenFetcherImpl();
+  SupervisedUserRefreshTokenFetcherImpl(
+      OAuth2TokenService* oauth2_token_service,
+      const std::string& account_id,
+      URLRequestContextGetter* context);
+  virtual ~SupervisedUserRefreshTokenFetcherImpl();
 
-  // ManagedUserRefreshTokenFetcher implementation:
-  virtual void Start(const std::string& managed_user_id,
+  // SupervisedUserRefreshTokenFetcher implementation:
+  virtual void Start(const std::string& supervised_user_id,
                      const std::string& device_name,
                      const TokenCallback& callback) OVERRIDE;
 
  protected:
   // OAuth2TokenService::Consumer implementation:
   virtual void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
                                  const std::string& access_token,
                                  const Time& expiration_time) OVERRIDE;
   virtual void OnGetTokenFailure(const OAuth2TokenService::Request* request,
                                  const GoogleServiceAuthError& error) OVERRIDE;
@@ skipping 16 matching lines @@
   void StartFetching();
 
   void DispatchNetworkError(int error_code);
   void DispatchGoogleServiceAuthError(const GoogleServiceAuthError& error,
                                       const std::string& token);
   OAuth2TokenService* oauth2_token_service_;
   std::string account_id_;
   URLRequestContextGetter* context_;
 
   std::string device_name_;
-  std::string managed_user_id_;
+  std::string 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_;
 };
 
-ManagedUserRefreshTokenFetcherImpl::ManagedUserRefreshTokenFetcherImpl(
+SupervisedUserRefreshTokenFetcherImpl::SupervisedUserRefreshTokenFetcherImpl(
     OAuth2TokenService* oauth2_token_service,
     const std::string& account_id,
     URLRequestContextGetter* context)
-    : OAuth2TokenService::Consumer("managed_user"),
+    : OAuth2TokenService::Consumer("supervised_user"),
       oauth2_token_service_(oauth2_token_service),
       account_id_(account_id),
       context_(context),
       access_token_expired_(false) {}
 
-ManagedUserRefreshTokenFetcherImpl::~ManagedUserRefreshTokenFetcherImpl() {}
+SupervisedUserRefreshTokenFetcherImpl::
+~SupervisedUserRefreshTokenFetcherImpl() {}
 
-void ManagedUserRefreshTokenFetcherImpl::Start(
-    const std::string& managed_user_id,
+void SupervisedUserRefreshTokenFetcherImpl::Start(
+    const std::string& supervised_user_id,
     const std::string& device_name,
     const TokenCallback& callback) {
   DCHECK(callback_.is_null());
-  managed_user_id_ = managed_user_id;
+  supervised_user_id_ = supervised_user_id;
   device_name_ = device_name;
   callback_ = callback;
   StartFetching();
 }
 
-void ManagedUserRefreshTokenFetcherImpl::StartFetching() {
+void SupervisedUserRefreshTokenFetcherImpl::StartFetching() {
   OAuth2TokenService::ScopeSet scopes;
   scopes.insert(GaiaConstants::kOAuth1LoginScope);
   access_token_request_ = oauth2_token_service_->StartRequest(
       account_id_, scopes, this);
 }
 
-void ManagedUserRefreshTokenFetcherImpl::OnGetTokenSuccess(
+void SupervisedUserRefreshTokenFetcherImpl::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const Time& expiration_time) {
   DCHECK_EQ(access_token_request_.get(), request);
   access_token_ = access_token;
 
   GURL url(GaiaUrls::GetInstance()->oauth2_issue_token_url());
   // GaiaOAuthClient uses id 0, so we use 1 to distinguish the requests in
   // unit tests.
   const int id = 1;
 
   url_fetcher_.reset(URLFetcher::Create(id, url, URLFetcher::POST, this));
 
   url_fetcher_->SetRequestContext(context_);
   url_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                              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(managed_user_id_, true).c_str(),
+      net::EscapeUrlEncodedData(supervised_user_id_, true).c_str(),
       net::EscapeUrlEncodedData(device_name_, true).c_str());
   url_fetcher_->SetUploadData("application/x-www-form-urlencoded", body);
 
   url_fetcher_->Start();
 }
 
-void ManagedUserRefreshTokenFetcherImpl::OnGetTokenFailure(
+void SupervisedUserRefreshTokenFetcherImpl::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   DCHECK_EQ(access_token_request_.get(), request);
   callback_.Run(error, std::string());
   callback_.Reset();
 }
 
-void ManagedUserRefreshTokenFetcherImpl::OnURLFetchComplete(
+void SupervisedUserRefreshTokenFetcherImpl::OnURLFetchComplete(
     const URLFetcher* source) {
   const net::URLRequestStatus& status = source->GetStatus();
   if (!status.is_success()) {
     DispatchNetworkError(status.error());
     return;
   }
 
   int response_code = source->GetResponseCode();
   if (response_code == net::HTTP_UNAUTHORIZED && !access_token_expired_) {
     access_token_expired_ = true;
@@ skipping 29 matching lines @@
 
   gaia::OAuthClientInfo client_info;
   GaiaUrls* urls = GaiaUrls::GetInstance();
   client_info.client_id = urls->oauth2_chrome_client_id();
   client_info.client_secret = urls->oauth2_chrome_client_secret();
   gaia_oauth_client_.reset(new gaia::GaiaOAuthClient(context_));
   gaia_oauth_client_->GetTokensFromAuthCode(client_info, auth_code, kNumRetries,
                                             this);
 }
 
-void ManagedUserRefreshTokenFetcherImpl::OnGetTokensResponse(
+void SupervisedUserRefreshTokenFetcherImpl::OnGetTokensResponse(
     const std::string& refresh_token,
     const std::string& access_token,
     int expires_in_seconds) {
   // TODO(bauerb): It would be nice if we could pass the access token as well,
   // so we don't need to fetch another one immediately.
   DispatchGoogleServiceAuthError(GoogleServiceAuthError::AuthErrorNone(),
                                  refresh_token);
 }
 
-void ManagedUserRefreshTokenFetcherImpl::OnRefreshTokenResponse(
+void SupervisedUserRefreshTokenFetcherImpl::OnRefreshTokenResponse(
     const std::string& access_token,
     int expires_in_seconds) {
   NOTREACHED();
 }
 
-void ManagedUserRefreshTokenFetcherImpl::OnOAuthError() {
+void SupervisedUserRefreshTokenFetcherImpl::OnOAuthError() {
   DispatchGoogleServiceAuthError(
       GoogleServiceAuthError(GoogleServiceAuthError::CONNECTION_FAILED),
       std::string());
 }
 
-void ManagedUserRefreshTokenFetcherImpl::OnNetworkError(int response_code) {
+void SupervisedUserRefreshTokenFetcherImpl::OnNetworkError(int response_code) {
   // TODO(bauerb): We should return the HTTP response code somehow.
   DLOG(WARNING) << "HTTP error " << response_code;
   DispatchGoogleServiceAuthError(
       GoogleServiceAuthError(GoogleServiceAuthError::CONNECTION_FAILED),
       std::string());
 }
 
-void ManagedUserRefreshTokenFetcherImpl::DispatchNetworkError(int error_code) {
+void SupervisedUserRefreshTokenFetcherImpl::DispatchNetworkError(
+    int error_code) {
   DispatchGoogleServiceAuthError(
       GoogleServiceAuthError::FromConnectionError(error_code), std::string());
 }
 
-void ManagedUserRefreshTokenFetcherImpl::DispatchGoogleServiceAuthError(
+void SupervisedUserRefreshTokenFetcherImpl::DispatchGoogleServiceAuthError(
     const GoogleServiceAuthError& error,
     const std::string& token) {
   callback_.Run(error, token);
   callback_.Reset();
 }
 
 }  // namespace
 
 // static
-scoped_ptr<ManagedUserRefreshTokenFetcher>
-ManagedUserRefreshTokenFetcher::Create(OAuth2TokenService* oauth2_token_service,
-                                       const std::string& account_id,
-                                       URLRequestContextGetter* context) {
-  scoped_ptr<ManagedUserRefreshTokenFetcher> fetcher(
-      new ManagedUserRefreshTokenFetcherImpl(oauth2_token_service, account_id,
-          context));
+scoped_ptr<SupervisedUserRefreshTokenFetcher>
+SupervisedUserRefreshTokenFetcher::Create(
+    OAuth2TokenService* oauth2_token_service,
+    const std::string& account_id,
+    URLRequestContextGetter* context) {
+  scoped_ptr<SupervisedUserRefreshTokenFetcher> fetcher(
+      new SupervisedUserRefreshTokenFetcherImpl(oauth2_token_service,
+                                                account_id,
+                                                context));
   return fetcher.Pass();
 }
 
-ManagedUserRefreshTokenFetcher::~ManagedUserRefreshTokenFetcher() {}
+SupervisedUserRefreshTokenFetcher::~SupervisedUserRefreshTokenFetcher() {}