Remove signin and persist from gaia_authenticator.

chrome/browser/sync/engine/auth_watcher.cc

 // Copyright (c) 2006-2009 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/engine/auth_watcher.h"
 
 #include "base/file_util.h"
 #include "base/string_util.h"
 #include "chrome/browser/sync/engine/all_status.h"
 #include "chrome/browser/sync/engine/authenticator.h"
@@ skipping 60 matching lines @@
 
 void AuthWatcher::PersistCredentials() {
   DCHECK_EQ(MessageLoop::current(), message_loop());
   gaia::GaiaAuthenticator::AuthResults results = gaia_->results();
 
   // We just successfully signed in again, let's clear out any residual cached
   // login data from earlier sessions.
   ClearAuthenticationData();
 
   user_settings_->StoreEmailForSignin(results.email, results.primary_email);
-  user_settings_->RememberSigninType(results.email, results.signin);
-  user_settings_->RememberSigninType(results.primary_email, results.signin);
   results.email = results.primary_email;
   gaia_->SetUsernamePassword(results.primary_email, results.password);
   if (!user_settings_->VerifyAgainstStoredHash(results.email, results.password))
     user_settings_->StoreHashedPassword(results.email, results.password);
 
-  if (gaia::PERSIST_TO_DISK == results.credentials_saved) {
-    user_settings_->SetAuthTokenForService(results.email,
-                                           SYNC_SERVICE_NAME,
-                                           gaia_->auth_token());
-  }
+  user_settings_->SetAuthTokenForService(results.email,
+                                         SYNC_SERVICE_NAME,
+                                         gaia_->auth_token());
 }
 
 // TODO(chron): Full integration test suite needed. http://crbug.com/35429
 void AuthWatcher::RenewAuthToken(const std::string& updated_token) {
   message_loop()->PostTask(FROM_HERE, NewRunnableMethod(this,
       &AuthWatcher::DoRenewAuthToken, updated_token));
 }
 
 void AuthWatcher::DoRenewAuthToken(const std::string& updated_token) {
   DCHECK_EQ(MessageLoop::current(), message_loop());
@@ skipping 20 matching lines @@
   message_loop()->PostTask(FROM_HERE, NewRunnableMethod(this,
       &AuthWatcher::DoAuthenticateWithLsid, lsid));
 }
 
 void AuthWatcher::DoAuthenticateWithLsid(const std::string& lsid) {
   DCHECK_EQ(MessageLoop::current(), message_loop());
 
   AuthWatcherEvent event = { AuthWatcherEvent::AUTHENTICATION_ATTEMPT_START };
   NotifyListeners(&event);
 
-  if (gaia_->AuthenticateWithLsid(lsid, true)) {
+  if (gaia_->AuthenticateWithLsid(lsid)) {
     PersistCredentials();
     DoAuthenticateWithToken(gaia_->email(), gaia_->auth_token());
   } else {
     ProcessGaiaAuthFailure();
   }
 }
 
 const char kAuthWatcher[] = "AuthWatcher";
 
 void AuthWatcher::AuthenticateWithToken(const std::string& gaia_email,
                                         const std::string& auth_token) {
   message_loop()->PostTask(FROM_HERE, NewRunnableMethod(this,
       &AuthWatcher::DoAuthenticateWithToken, gaia_email, auth_token));
 }
 
 void AuthWatcher::DoAuthenticateWithToken(const std::string& gaia_email,
                                           const std::string& auth_token) {
   DCHECK_EQ(MessageLoop::current(), message_loop());
 
   Authenticator auth(scm_, user_settings_);
   Authenticator::AuthenticationResult result =
       auth.AuthenticateToken(auth_token);
   string email = gaia_email;
   if (auth.display_email() && *auth.display_email()) {
     email = auth.display_email();
     LOG(INFO) << "Auth returned email " << email << " for gaia email " <<
         gaia_email;
   }
+
   AuthWatcherEvent event = {AuthWatcherEvent::ILLEGAL_VALUE , 0};
   gaia_->SetUsername(email);
-  gaia_->SetAuthToken(auth_token, gaia::SAVE_IN_MEMORY_ONLY);
+  gaia_->SetAuthToken(auth_token);
   const bool was_authenticated = NOT_AUTHENTICATED != status_;
   switch (result) {
     case Authenticator::SUCCESS:
       {
         status_ = GAIA_AUTHENTICATED;
         const std::string& share_name = email;
         user_settings_->SwitchUser(email);
 
         // Set the authentication token for notifications
         talk_mediator_->SetAuthToken(email, auth_token, SYNC_SERVICE_NAME);
@@ skipping 53 matching lines @@
   return user_settings_->VerifyAgainstStoredHash(email, password)
     && AuthenticateLocally(email);
 }
 
 void AuthWatcher::ProcessGaiaAuthFailure() {
   DCHECK_EQ(MessageLoop::current(), message_loop());
   gaia::GaiaAuthenticator::AuthResults results = gaia_->results();
   if (LOCALLY_AUTHENTICATED == status_) {
     return;  // nothing todo
   } else if (AuthenticateLocally(results.email, results.password)) {
-    // We save the "Remember me" checkbox by putting a non-null auth
-    // token into the last_user table.  So if we're offline and the
-    // user checks the box, insert a bogus auth token.
-    if (gaia::PERSIST_TO_DISK == results.credentials_saved) {
-      const string auth_token("bogus");
-      user_settings_->SetAuthTokenForService(results.email,
-                                             SYNC_SERVICE_NAME,
-                                             auth_token);
-    }
+    // TODO(chron): Do we really want a bogus token?
+    const string auth_token("bogus");
+    user_settings_->SetAuthTokenForService(results.email,
+                                           SYNC_SERVICE_NAME,
+                                           auth_token);
     const bool unavailable =
         gaia::ConnectionUnavailable == results.auth_error ||
         gaia::Unknown == results.auth_error ||
         gaia::ServiceUnavailable == results.auth_error;
     if (unavailable)
       return;
   }
   AuthWatcherEvent myevent = { AuthWatcherEvent::GAIA_AUTH_FAILED, &results };
   NotifyListeners(&myevent);
 }
 
 void AuthWatcher::DoAuthenticate(const AuthRequest& request) {
   DCHECK_EQ(MessageLoop::current(), message_loop());
 
   AuthWatcherEvent event = { AuthWatcherEvent::AUTHENTICATION_ATTEMPT_START };
   NotifyListeners(&event);
 
   current_attempt_trigger_ = request.trigger;
 
-  gaia::SaveCredentials save = request.persist_creds_to_disk ?
-      gaia::PERSIST_TO_DISK : gaia::SAVE_IN_MEMORY_ONLY;
-  gaia::SignIn const signin = user_settings_->
-      RecallSigninType(request.email, gaia::GMAIL_SIGNIN);
-
   // We let the caller be lazy and try using the last captcha token seen by
   // the gaia authenticator if they haven't provided a token but have sent
   // a challenge response. Of course, if the captcha token is specified,
   // we use that one instead.
   std::string captcha_token(request.captcha_token);
   if (!request.captcha_value.empty() && captcha_token.empty())
     captcha_token = gaia_->captcha_token();
 
   if (!request.password.empty()) {
     bool authenticated = false;
     if (!captcha_token.empty()) {
       authenticated = gaia_->Authenticate(request.email, request.password,
-                                          save, captcha_token,
-                                          request.captcha_value, signin);
+                                          captcha_token,
+                                          request.captcha_value);
     } else {
-      authenticated = gaia_->Authenticate(request.email, request.password,
-                                          save, signin);
+      authenticated = gaia_->Authenticate(request.email, request.password);
     }
     if (authenticated) {
       PersistCredentials();
       DoAuthenticateWithToken(gaia_->email(), gaia_->auth_token());
     } else {
       ProcessGaiaAuthFailure();
     }
   } else if (!request.auth_token.empty()) {
     DoAuthenticateWithToken(request.email, request.auth_token);
   } else {
@@ skipping 29 matching lines @@
        status_ == LOCALLY_AUTHENTICATED)) {
     // We're either online or just got reconnected and want to try to
     // authenticate. If we've got a saved token this should just work. If not
     // the auth failure should trigger UI indications that we're not logged in.
 
     // METRIC: If we get a SYNC_AUTH_ERROR, our token expired.
     gaia::GaiaAuthenticator::AuthResults authresults = gaia_->results();
     AuthRequest request = { authresults.email, authresults.password,
                             authresults.auth_token, std::string(),
                             std::string(),
-                            gaia::PERSIST_TO_DISK ==
-                                authresults.credentials_saved,
                             AuthWatcherEvent::EXPIRED_CREDENTIALS };
     DoAuthenticate(request);
   }
 }
 
 AuthWatcher::~AuthWatcher() {
   auth_backend_thread_.Stop();
   // The gaia authenticator takes a const MessageLoop* because it only uses it
   // to ensure all methods are invoked on the given loop.  Once our thread has
   // stopped, the current message loop will be NULL, and no methods should be
   // invoked on |gaia_| after this point.  We could set it to NULL, but
   // abstaining allows for even more sanity checking that nothing is invoked on
   // it from now on.
 }
 
 void AuthWatcher::Authenticate(const string& email, const string& password,
-    const string& captcha_token, const string& captcha_value,
-    bool persist_creds_to_disk) {
+    const string& captcha_token, const string& captcha_value) {
   LOG(INFO) << "AuthWatcher::Authenticate called";
 
   string empty;
   AuthRequest request = { FormatAsEmailAddress(email), password, empty,
-                          captcha_token, captcha_value, persist_creds_to_disk,
+                          captcha_token, captcha_value,
                           AuthWatcherEvent::USER_INITIATED };
   message_loop()->PostTask(FROM_HERE, NewRunnableMethod(this,
       &AuthWatcher::DoAuthenticate, request));
 }
 
 void AuthWatcher::ClearAuthenticationData() {
   scm_->set_auth_token(std::string());
   user_settings_->ClearAllServiceTokens();
 }
 
 string AuthWatcher::email() const {
   return gaia_->email();
 }
 
 void AuthWatcher::NotifyListeners(AuthWatcherEvent* event) {
   event->trigger = current_attempt_trigger_;
   channel_->NotifyListeners(*event);
 }
 
 }  // namespace browser_sync