Convert UserPolicySigninService to use OAuth2TokenService

chrome/browser/signin/profile_oauth2_token_service.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/signin/profile_oauth2_token_service.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/time/time.h"
@@ skipping 50 matching lines @@
       last_auth_error_(GoogleServiceAuthError::NONE) {
 }
 
 ProfileOAuth2TokenService::~ProfileOAuth2TokenService() {
   DCHECK(!signin_global_error_.get()) <<
       "ProfileOAuth2TokenService::Initialize called but not "
       "ProfileOAuth2TokenService::Shutdown";
 }
 
 void ProfileOAuth2TokenService::Initialize(Profile* profile) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-
   DCHECK(profile);
   DCHECK(!profile_);
   profile_ = profile;
 
   signin_global_error_.reset(new SigninGlobalError(profile));
   GlobalErrorServiceFactory::GetForProfile(profile_)->AddGlobalError(
       signin_global_error_.get());
   signin_global_error_->AddProvider(this);
 
   content::Source<TokenService> token_service_source(
       TokenServiceFactory::GetForProfile(profile));
   registrar_.Add(this,
                  chrome::NOTIFICATION_TOKENS_CLEARED,
                  token_service_source);
   registrar_.Add(this,
                  chrome::NOTIFICATION_TOKEN_AVAILABLE,
                  token_service_source);
   registrar_.Add(this,
                  chrome::NOTIFICATION_TOKEN_LOADING_FINISHED,
                  token_service_source);
 }
 
 void ProfileOAuth2TokenService::Shutdown() {
+  DCHECK(profile_) << "Shutdown() called without matching call to Initialize()";
   CancelAllRequests();
   signin_global_error_->RemoveProvider(this);
   GlobalErrorServiceFactory::GetForProfile(profile_)->RemoveGlobalError(
       signin_global_error_.get());
   signin_global_error_.reset();
 }
 
 std::string ProfileOAuth2TokenService::GetRefreshToken() {
   TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
   if (!token_service || !token_service->HasOAuthLoginToken()) {
     return std::string();
   }
   return token_service->GetOAuth2LoginRefreshToken();
 }
 
+net::URLRequestContextGetter* ProfileOAuth2TokenService::GetRequestContext() {
+  return profile_->GetRequestContext();
+}
+
 void ProfileOAuth2TokenService::UpdateAuthError(
     const GoogleServiceAuthError& error) {
   // Do not report connection errors as these are not actually auth errors.
   // We also want to avoid masking a "real" auth error just because we
   // subsequently get a transient network error.
   if (error.state() == GoogleServiceAuthError::CONNECTION_FAILED)
     return;
 
   if (error.state() != last_auth_error_.state()) {
     last_auth_error_ = error;
@@ skipping 36 matching lines @@
     default:
       NOTREACHED() << "Invalid notification type=" << type;
       break;
   }
 }
 
 GoogleServiceAuthError ProfileOAuth2TokenService::GetAuthStatus() const {
   return last_auth_error_;
 }
 
-net::URLRequestContextGetter* ProfileOAuth2TokenService::GetRequestContext() {
-  return profile_->GetRequestContext();
-}
-
 void ProfileOAuth2TokenService::RegisterCacheEntry(
     const std::string& refresh_token,
     const ScopeSet& scopes,
     const std::string& access_token,
     const base::Time& expiration_date) {
   if (ShouldCacheForRefreshToken(TokenServiceFactory::GetForProfile(profile_),
                                  refresh_token)) {
     OAuth2TokenService::RegisterCacheEntry(refresh_token,
                                            scopes,
                                            access_token,
@@ skipping 134 matching lines @@
     }
   }
 
   if (!old_login_token.empty() &&
       refresh_tokens_.count(GetAccountId(profile_)) == 0) {
     UpdateCredentials(GetAccountId(profile_), old_login_token);
   }
 
   FireRefreshTokensLoaded();
 }