Split token-related methods from WebDataService

chrome/browser/signin/token_service.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// 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/token_service.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/string_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/signin_manager.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
-#include "chrome/browser/webdata/web_data_service.h"
+#include "chrome/browser/webdata/token_web_data.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "google_apis/gaia/gaia_auth_fetcher.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "net/url_request/url_request_context_getter.h"
 
@@ skipping 34 matching lines @@
 }
 
 TokenService::~TokenService() {
 }
 
 void TokenService::Shutdown() {
   if (!source_.empty()) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     ResetCredentialsInMemory();
   }
-  web_data_service_ = NULL;
+  token_web_data_ = NULL;
 }
 
 void TokenService::Initialize(const char* const source,
                               Profile* profile) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!source_.empty()) {
     // Already initialized.
     return;
   }
   DCHECK(!profile_);
   profile_ = profile;
   getter_ = profile->GetRequestContext();
   // Since the user can create a bookmark in incognito, sync may be running.
   // Thus we have to go for explicit access.
-  web_data_service_ = WebDataService::FromBrowserContext(profile);
+  token_web_data_ = TokenWebData::FromBrowserContext(profile);
   source_ = std::string(source);
 
   CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   // Allow the token service to be cleared from the command line. We rely on
   // SigninManager::Initialize() being called to clear out the
   // kGoogleServicesUsername pref before we call EraseTokensFromDB() as
   // otherwise the system would be in an invalid state.
   if (cmd_line->HasSwitch(switches::kClearTokenService))
     EraseTokensFromDB();
 
@@ skipping 38 matching lines @@
 void TokenService::ResetCredentialsInMemory() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Terminate any running fetchers. Callbacks will not return.
   for (size_t i = 0; i < arraysize(kServices); ++i) {
     fetchers_[i].reset();
   }
 
   // Cancel pending loads. Callbacks will not return.
   if (token_loading_query_) {
-    web_data_service_->CancelRequest(token_loading_query_);
+    token_web_data_->CancelRequest(token_loading_query_);
     token_loading_query_ = 0;
   }
 
   tokens_loaded_ = false;
   token_map_.clear();
   credentials_ = GaiaAuthConsumer::ClientLoginResult();
 }
 
 void TokenService::UpdateCredentials(
     const GaiaAuthConsumer::ClientLoginResult& credentials) {
@@ skipping 14 matching lines @@
   FOR_DIAGNOSTICS_OBSERVERS(NotifySigninValueChanged(LSID, credentials.lsid));
 }
 
 void TokenService::UpdateCredentialsWithOAuth2(
     const GaiaAuthConsumer::ClientOAuthResult& oauth2_tokens) {
   SaveOAuth2Credentials(oauth2_tokens);
 }
 
 void TokenService::LoadTokensFromDB() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (web_data_service_.get())
-    token_loading_query_ = web_data_service_->GetAllTokens(this);
+  if (token_web_data_.get())
+    token_loading_query_ = token_web_data_->GetAllTokens(this);
 }
 
 void TokenService::SaveAuthTokenToDB(const std::string& service,
                                      const std::string& auth_token) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (web_data_service_.get())
-    web_data_service_->SetTokenForService(service, auth_token);
+  if (token_web_data_.get())
+    token_web_data_->SetTokenForService(service, auth_token);
 }
 
 void TokenService::EraseTokensFromDB() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (web_data_service_.get())
-    web_data_service_->RemoveAllTokens();
+  if (token_web_data_.get())
+    token_web_data_->RemoveAllTokens();
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_TOKENS_CLEARED,
       content::Source<TokenService>(this),
       content::NotificationService::NoDetails());
 
   // Clear in-memory token values stored by AboutSigninInternals
   // Note that although this is clearing in-memory values, it belongs here and
   // not in ResetCredentialsInMemory() (which is invoked both on sign out and
   // shutdown).
@@ skipping 153 matching lines @@
 }
 
 void TokenService::OnClientOAuthFailure(
    const GoogleServiceAuthError& error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   LOG(WARNING) << "OAuth2 login token pair fetch failed: " << error.ToString();
   FireTokenRequestFailedNotification(
       GaiaConstants::kGaiaOAuth2LoginRefreshToken, error);
 }
 
-void TokenService::OnWebDataServiceRequestDone(WebDataService::Handle h,
+void TokenService::OnWebDataServiceRequestDone(WebDataServiceBase::Handle h,
                                                const WDTypedResult* result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(token_loading_query_);
   token_loading_query_ = 0;
 
   // If the fetch failed, there will be no result. In that case, we just don't
   // load any tokens at all from the DB.
   if (result) {
     DCHECK(result->GetType() == TOKEN_RESULT);
     const WDResult<std::map<std::string, std::string> > * token_result =
@@ skipping 80 matching lines @@
 
 void TokenService::AddSigninDiagnosticsObserver(
     SigninDiagnosticsObserver* observer) {
   signin_diagnostics_observers_.AddObserver(observer);
 }
 
 void TokenService::RemoveSigninDiagnosticsObserver(
     SigninDiagnosticsObserver* observer) {
   signin_diagnostics_observers_.RemoveObserver(observer);
 }