Create signin component and componentize TokenWebData.

chrome/browser/signin/mutable_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/mutable_profile_oauth2_token_service.h"
 
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/webdata/token_web_data.h"
+#include "chrome/browser/webdata/web_data_service_factory.h"
+#include "components/signin/core/webdata/token_web_data.h"
 #include "components/webdata/common/web_data_service_base.h"
 #include "google_apis/gaia/gaia_auth_fetcher.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "net/url_request/url_request_context_getter.h"
 
 #if defined(ENABLE_MANAGED_USERS)
 #include "chrome/browser/managed_mode/managed_user_constants.h"
 #endif
 
@@ skipping 56 matching lines @@
 MutableProfileOAuth2TokenService::MutableProfileOAuth2TokenService()
     : web_data_service_request_(0)  {
 }
 
 MutableProfileOAuth2TokenService::~MutableProfileOAuth2TokenService() {
 }
 
 void MutableProfileOAuth2TokenService::Shutdown() {
   if (web_data_service_request_ != 0) {
     scoped_refptr<TokenWebData> token_web_data =
-        TokenWebData::FromBrowserContext(profile());
+        WebDataServiceFactory::GetTokenWebDataForProfile(
+            profile(), Profile::EXPLICIT_ACCESS);
     DCHECK(token_web_data.get());
     token_web_data->CancelRequest(web_data_service_request_);
     web_data_service_request_  = 0;
   }
   ProfileOAuth2TokenService::Shutdown();
 }
 
 net::URLRequestContextGetter*
 MutableProfileOAuth2TokenService::GetRequestContext() {
   return profile()->GetRequestContext();
 }
 
 void MutableProfileOAuth2TokenService::LoadCredentials() {
   DCHECK_EQ(0, web_data_service_request_);
 
   CancelAllRequests();
   refresh_tokens().clear();
   scoped_refptr<TokenWebData> token_web_data =
-      TokenWebData::FromBrowserContext(profile());
+      WebDataServiceFactory::GetTokenWebDataForProfile(
+          profile(), Profile::EXPLICIT_ACCESS);
   if (token_web_data.get())
     web_data_service_request_ = token_web_data->GetAllTokens(this);
 }
 
 void MutableProfileOAuth2TokenService::OnWebDataServiceRequestDone(
     WebDataServiceBase::Handle handle,
     const WDTypedResult* result) {
   DCHECK_EQ(web_data_service_request_, handle);
   web_data_service_request_ = 0;
 
@@ skipping 34 matching lines @@
        iter != db_tokens.end();
        ++iter) {
     std::string prefixed_account_id = iter->first;
     std::string refresh_token = iter->second;
 
     if (IsLegacyRefreshTokenId(prefixed_account_id) && !refresh_token.empty())
       old_login_token = refresh_token;
 
     if (IsLegacyServiceId(prefixed_account_id)) {
       scoped_refptr<TokenWebData> token_web_data =
-          TokenWebData::FromBrowserContext(profile());
+          WebDataServiceFactory::GetTokenWebDataForProfile(
+              profile(), Profile::EXPLICIT_ACCESS);
       if (token_web_data.get())
         token_web_data->RemoveTokenForService(prefixed_account_id);
     } else {
       DCHECK(!refresh_token.empty());
       std::string account_id = RemoveAccountIdPrefix(prefixed_account_id);
       refresh_tokens()[account_id].reset(
           new AccountInfo(this, account_id, refresh_token));
       FireRefreshTokenAvailable(account_id);
       // TODO(fgorski): Notify diagnostic observers.
     }
   }
 
   if (!old_login_token.empty()) {
     std::string account_id = GetAccountIdForMigratingRefreshToken();
 
     if (refresh_tokens().count(account_id) == 0)
       UpdateCredentials(account_id, old_login_token);
   }
 
   FireRefreshTokensLoaded();
 }
 
 void MutableProfileOAuth2TokenService::PersistCredentials(
     const std::string& account_id,
     const std::string& refresh_token) {
   scoped_refptr<TokenWebData> token_web_data =
-      TokenWebData::FromBrowserContext(profile());
+      WebDataServiceFactory::GetTokenWebDataForProfile(
+          profile(), Profile::EXPLICIT_ACCESS);
   if (token_web_data.get()) {
     token_web_data->SetTokenForService(ApplyAccountIdPrefix(account_id),
                                        refresh_token);
   }
 }
 
 void MutableProfileOAuth2TokenService::ClearPersistedCredentials(
     const std::string& account_id) {
   scoped_refptr<TokenWebData> token_web_data =
-      TokenWebData::FromBrowserContext(profile());
+      WebDataServiceFactory::GetTokenWebDataForProfile(
+          profile(), Profile::EXPLICIT_ACCESS);
   if (token_web_data.get())
     token_web_data->RemoveTokenForService(ApplyAccountIdPrefix(account_id));
 }
 
 std::string
 MutableProfileOAuth2TokenService::GetAccountIdForMigratingRefreshToken() {
 #if defined(ENABLE_MANAGED_USERS)
   // TODO(bauerb): Make sure that only services that can deal with supervised
   // users see the supervised user token.
   if (profile()->IsManaged())
     return managed_users::kManagedUserPseudoEmail;
 #endif
 
   return GetPrimaryAccountId();
 }
 
 void MutableProfileOAuth2TokenService::RevokeCredentialsOnServer(
     const std::string& refresh_token) {
   // RevokeServerRefreshToken deletes itself when done.
   new RevokeServerRefreshToken(refresh_token, GetRequestContext());
 }