Correctly deal with tokens for supervised users in ProfileOAuth2TokenService.

chrome/browser/sync/profile_sync_service.cc

 // Copyright (c) 2012 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/sync/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 60 matching lines @@
 #include "sync/internal_api/public/sync_encryption_handler.h"
 #include "sync/internal_api/public/util/experiments.h"
 #include "sync/internal_api/public/util/sync_string_conversions.h"
 #include "sync/js/js_arg_list.h"
 #include "sync/js/js_event_details.h"
 #include "sync/util/cryptographer.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/time_format.h"
 
 #if defined(ENABLE_MANAGED_USERS)
-#include "chrome/browser/managed_mode/managed_user_service.h"
+#include "chrome/browser/managed_mode/managed_user_constants.h"
 #endif
 
 #if defined(OS_ANDROID)
 #include "sync/internal_api/public/read_transaction.h"
 #endif
 
 using browser_sync::ChangeProcessor;
 using browser_sync::DataTypeController;
 using browser_sync::DataTypeManager;
 using browser_sync::FailedDataTypesHandler;
@@ skipping 110 matching lines @@
   if (IsManaged() || sync_prefs_.IsStartSuppressed())
     return false;
 
   // Sync is logged in if there is a non-empty effective username.
   return !GetEffectiveUsername().empty();
 }
 
 bool ProfileSyncService::IsOAuthRefreshTokenAvailable() {
   if (!oauth2_token_service_)
     return false;
-  return oauth2_token_service_->RefreshTokenIsAvailable(
-      oauth2_token_service_->GetPrimaryAccountId());
+
+  return oauth2_token_service_->RefreshTokenIsAvailable(GetAccountIdToUse());
 }
 
 void ProfileSyncService::Initialize() {
   if (profile_)
     SigninGlobalError::GetForProfile(profile_)->AddProvider(this);
 
   InitSettings();
 
   // We clear this here (vs Shutdown) because we want to remember that an error
   // happened on shutdown so we can display details (message, location) about it
@@ skipping 467 matching lines @@
     }
     default: {
       // Show error to user.
       UpdateAuthErrorState(error);
     }
   }
 }
 
 void ProfileSyncService::OnRefreshTokenAvailable(
     const std::string& account_id) {
-  if (oauth2_token_service_->GetPrimaryAccountId() == account_id)
+  if (account_id == GetAccountIdToUse())
     OnRefreshTokensLoaded();
 }
 
 void ProfileSyncService::OnRefreshTokenRevoked(
     const std::string& account_id) {
   if (!IsOAuthRefreshTokenAvailable()) {
     access_token_.clear();
     // The additional check around IsOAuthRefreshTokenAvailable() above
     // prevents us sounding the alarm if we actually have a valid token but
     // a refresh attempt by TokenService failed for any variety of reasons
@@ skipping 1168 matching lines @@
   request_access_token_retry_timer_.Stop();
   OAuth2TokenService::ScopeSet oauth2_scopes;
   if (profile_->IsManaged()) {
     oauth2_scopes.insert(GaiaConstants::kChromeSyncManagedOAuth2Scope);
   } else {
     oauth2_scopes.insert(GaiaConstants::kChromeSyncOAuth2Scope);
   }
 
   // Invalidate previous token, otherwise token service will return the same
   // token again.
-  const std::string& account_id = oauth2_token_service_->GetPrimaryAccountId();
+  const std::string& account_id = GetAccountIdToUse();
   if (!access_token_.empty()) {
     oauth2_token_service_->InvalidateToken(
         account_id, oauth2_scopes, access_token_);
   }
 
   access_token_.clear();
   access_token_request_ =
       oauth2_token_service_->StartRequest(account_id, oauth2_scopes, this);
 }
 
@@ skipping 221 matching lines @@
     UnrecoverableErrorReason reason) {
   DCHECK(!HasUnrecoverableError());
   unrecoverable_error_reason_ = reason;
   OnUnrecoverableErrorImpl(from_here, message, delete_sync_database);
 }
 
 std::string ProfileSyncService::GetEffectiveUsername() {
   if (profile_->IsManaged()) {
 #if defined(ENABLE_MANAGED_USERS)
     DCHECK_EQ(std::string(), signin_->GetAuthenticatedUsername());
-    return ManagedUserService::GetManagedUserPseudoEmail();
+    return managed_users::kManagedUserPseudoEmail;
 #else
     NOTREACHED();
 #endif
   }
 
   return signin_->GetAuthenticatedUsername();
 }
 
+std::string ProfileSyncService::GetAccountIdToUse() {
+  if (profile_->IsManaged()) {
+#if defined(ENABLE_MANAGED_USERS)
+    return managed_users::kManagedUserPseudoEmail;
+#else
+    NOTREACHED();
+#endif
+  }
+
+  // TODO(fgorski): Use GetPrimaryAccountId() when it's available.
+  return signin_->GetAuthenticatedUsername();
+}
+
 WeakHandle<syncer::JsEventHandler> ProfileSyncService::GetJsEventHandler() {
   return MakeWeakHandle(sync_js_controller_.AsWeakPtr());
 }