OAuth2 sign-in flow for ChromeOS

chrome/browser/signin/token_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/signin/token_service.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "chrome/browser/prefs/pref_service.h"
@@ skipping 95 matching lines @@
 // store tokens and fetch them.  Move the key-value storage out of
 // token_service, and leave the token fetching in token_service.
 
 void TokenService::AddAuthTokenManually(const std::string& service,
                                         const std::string& auth_token) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(1) << "Got an authorization token for " << service;
   token_map_[service] = auth_token;
   FireTokenAvailableNotification(service, auth_token);
   SaveAuthTokenToDB(service, auth_token);
+
+#if defined(OS_CHROMEOS)
+  // We don't want to fetch OAuth2 tokens from LSO service token in case when
+  // ChromeOS is in exclusive OAuth2 useage mode. OAuth2 token should only
+  // arrive into token service through UpdateCredentialsWithOAuth2().
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kForceOAuth2))
+    return;
+#endif
+
   // If we got ClientLogin token for "lso" service, and we don't already have
   // OAuth2 tokens, start fetching OAuth2 login scoped token pair.
   if (service == GaiaConstants::kLSOService && !HasOAuthLoginToken()) {
     int index = GetServiceIndex(service);
     CHECK_GE(index, 0);
     fetchers_[index]->StartLsoForOAuthLoginTokenExchange(auth_token);
   }
 }
 
 
@@ skipping 12 matching lines @@
   }
 
   tokens_loaded_ = false;
   token_map_.clear();
   credentials_ = GaiaAuthConsumer::ClientLoginResult();
 }
 
 void TokenService::UpdateCredentials(
     const GaiaAuthConsumer::ClientLoginResult& credentials) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+#if defined(OS_CHROMEOS)
+  // Prevent this method from ever bing used on ChromeOS if we use OAuth2.
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kForceOAuth2)) {
+    NOTREACHED();
+    return;
+  }
+#endif
   credentials_ = credentials;
 
   SaveAuthTokenToDB(GaiaConstants::kGaiaLsid, credentials.lsid);
   SaveAuthTokenToDB(GaiaConstants::kGaiaSid, credentials.sid);
 
   // Cancel any currently running requests.
   for (size_t i = 0; i < arraysize(kServices); i++) {
     fetchers_[i].reset();
   }
 
   // Notify AboutSigninInternals that a new lsid and sid are available.
   FOR_DIAGNOSTICS_OBSERVERS(NotifySigninValueChanged(
       signin_internals_util::SID, credentials.sid));
   FOR_DIAGNOSTICS_OBSERVERS(NotifySigninValueChanged(LSID, credentials.lsid));
 }
 
 void TokenService::UpdateCredentialsWithOAuth2(
-    const GaiaAuthConsumer::ClientOAuthResult& credentials) {
-  // Will be implemented once the ClientOAuth signin is complete.  Not called
-  // yet by any code.
-  NOTREACHED();
+    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);
 }
 
 void TokenService::SaveAuthTokenToDB(const std::string& service,
                                      const std::string& auth_token) {
@@ skipping 36 matching lines @@
 // static
 int TokenService::GetServiceIndex(const std::string& service) {
   for (size_t i = 0; i < arraysize(kServices); ++i) {
     if (kServices[i] == service)
       return i;
   }
   return -1;
 }
 
 bool TokenService::AreCredentialsValid() const {
-  return !credentials_.lsid.empty() && !credentials_.sid.empty();
+#if defined(OS_CHROMEOS)
+  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kForceOAuth2))
+    return HasOAuthLoginAccessToken() && HasOAuthLoginToken();
+#endif
+
+  return credentials_.lsid.empty() && !credentials_.sid.empty();
 }
 
 void TokenService::StartFetchingTokens() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(AreCredentialsValid());
+  bool uses_oauth2 = false;
+#if defined(OS_CHROMEOS)
+  uses_oauth2 = CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kForceOAuth2);
+#endif
+
   for (size_t i = 0; i < arraysize(kServices); i++) {
     fetchers_[i].reset(new GaiaAuthFetcher(this, source_, getter_));
-    fetchers_[i]->StartIssueAuthToken(credentials_.sid,
-                                      credentials_.lsid,
-                                      kServices[i]);
+    if (uses_oauth2) {
+      fetchers_[i]->StartIssueAuthTokenForOAuth2(GetOAuth2LoginAccessToken(),
+                                                 kServices[i]);
+    } else {
+      fetchers_[i]->StartIssueAuthToken(credentials_.sid,
+                                        credentials_.lsid,
+                                        kServices[i]);
+    }
   }
 }
 
 // Services dependent on a token will check if a token is available.
 // If it isn't, they'll go to sleep until they get a token event.
 bool TokenService::HasTokenForService(const char* service) const {
   return token_map_.count(service) > 0;
 }
 
 const std::string& TokenService::GetTokenForService(
     const char* const service) const {
 
   if (token_map_.count(service) > 0) {
     // Note map[key] is not const.
     return (*token_map_.find(service)).second;
   }
   return EmptyString();
 }
 
 bool TokenService::HasOAuthLoginToken() const {
   return HasTokenForService(GaiaConstants::kGaiaOAuth2LoginRefreshToken);
 }
 
+bool TokenService::HasOAuthLoginAccessToken() const {
+  return HasTokenForService(GaiaConstants::kGaiaOAuth2LoginAccessToken);
+}
+
 const std::string& TokenService::GetOAuth2LoginRefreshToken() const {
   return GetTokenForService(GaiaConstants::kGaiaOAuth2LoginRefreshToken);
 }
 
 const std::string& TokenService::GetOAuth2LoginAccessToken() const {
   return GetTokenForService(GaiaConstants::kGaiaOAuth2LoginAccessToken);
 }
 
 // static
 void TokenService::GetServiceNamesForTesting(std::vector<std::string>* names) {
@@ skipping 67 matching lines @@
   LOG(WARNING) << "Auth token issuing failed for service:" << service
                << ", error: " << error.ToString();
   FOR_DIAGNOSTICS_OBSERVERS(
       NotifyTokenReceivedFailure(service, error.ToString()));
   FireTokenRequestFailedNotification(service, error);
 }
 
 void TokenService::OnClientOAuthSuccess(const ClientOAuthResult& result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   VLOG(1) << "Got OAuth2 login token pair";
+  SaveOAuth2Credentials(result);
+}
+
+void TokenService::SaveOAuth2Credentials(const ClientOAuthResult& result) {
   token_map_[GaiaConstants::kGaiaOAuth2LoginRefreshToken] =
       result.refresh_token;
   token_map_[GaiaConstants::kGaiaOAuth2LoginAccessToken] = result.access_token;
+  // Save refresh token only since access token is transient anyway.
   SaveAuthTokenToDB(GaiaConstants::kGaiaOAuth2LoginRefreshToken,
       result.refresh_token);
-  SaveAuthTokenToDB(GaiaConstants::kGaiaOAuth2LoginAccessToken,
-      result.access_token);
   // We don't save expiration information for now.
 
   FOR_DIAGNOSTICS_OBSERVERS(
       NotifyTokenReceivedSuccess(GaiaConstants::kGaiaOAuth2LoginAccessToken,
                                  result.access_token, true));
   FOR_DIAGNOSTICS_OBSERVERS(
       NotifyTokenReceivedSuccess(GaiaConstants::kGaiaOAuth2LoginRefreshToken,
                                  result.refresh_token, true));
 
   FireTokenAvailableNotification(GaiaConstants::kGaiaOAuth2LoginRefreshToken,
       result.refresh_token);
+  FireTokenAvailableNotification(GaiaConstants::kGaiaOAuth2LoginAccessToken,
+      result.access_token);
 }
 
 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);
 }
 
@@ skipping 97 matching lines @@
 
 void TokenService::AddSigninDiagnosticsObserver(
     SigninDiagnosticsObserver* observer) {
   signin_diagnostics_observers_.AddObserver(observer);
 }
 
 void TokenService::RemoveSigninDiagnosticsObserver(
     SigninDiagnosticsObserver* observer) {
   signin_diagnostics_observers_.RemoveObserver(observer);
 }