Remove signin and persist from gaia_authenticator.

chrome/common/net/gaia/gaia_authenticator.cc

 // Copyright (c) 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/common/net/gaia/gaia_authenticator.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 33 matching lines @@
 }
 
 GaiaAuthenticator::~GaiaAuthenticator() {
   delete channel_;
 }
 
 // mutex_ must be entered before calling this function.
 GaiaAuthenticator::AuthParams GaiaAuthenticator::MakeParams(
     const string& user_name,
     const string& password,
-    SaveCredentials should_save_credentials,
     const string& captcha_token,
-    const string& captcha_value,
-    SignIn try_first) {
+    const string& captcha_value) {
   AuthParams params;
   params.request_id = ++request_count_;
   params.email = user_name;
   params.password = password;
-  params.should_save_credentials = should_save_credentials;
   params.captcha_token = captcha_token;
   params.captcha_value = captcha_value;
   params.authenticator = this;
-  params.try_first = try_first;
   return params;
 }
 
 bool GaiaAuthenticator::Authenticate(const string& user_name,
                                      const string& password,
-                                     SaveCredentials should_save_credentials,
                                      const string& captcha_token,
-                                     const string& captcha_value,
-                                     SignIn try_first) {
+                                     const string& captcha_value) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
 
   AuthParams const params =
-    MakeParams(user_name, password, should_save_credentials, captcha_token,
-               captcha_value, try_first);
+      MakeParams(user_name, password, captcha_token, captcha_value);
   return AuthenticateImpl(params);
 }
 
-bool GaiaAuthenticator::AuthenticateWithLsid(const string& lsid,
-                                             bool long_lived) {
+bool GaiaAuthenticator::AuthenticateWithLsid(const string& lsid) {
   auth_results_.lsid = lsid;
   // We need to lookup the email associated with this LSID cookie in order to
   // update |auth_results_| with the correct values.
   if (LookupEmail(&auth_results_)) {
     auth_results_.email = auth_results_.primary_email;
-    return IssueAuthToken(&auth_results_, service_id_, long_lived);
+    return IssueAuthToken(&auth_results_, service_id_);
   }
   return false;
 }
 
-
 bool GaiaAuthenticator::AuthenticateImpl(const AuthParams& params) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   AuthResults results;
   const bool succeeded = AuthenticateImpl(params, &results);
   if (params.request_id == request_count_) {
     auth_results_ = results;
     GaiaAuthEvent event = { succeeded ? GaiaAuthEvent::GAIA_AUTH_SUCCEEDED
                                       : GaiaAuthEvent::GAIA_AUTH_FAILED,
                                       results.auth_error, this };
     channel_->NotifyListeners(event);
   }
   return succeeded;
 }
 
 // This method makes an HTTP request to the Gaia server, and calls other
 // methods to help parse the response. If authentication succeeded, then
 // Gaia-issued cookies are available in the respective variables; if
 // authentication failed, then the exact error is available as an enum. If the
 // client wishes to save the credentials, the last parameter must be true.
 // If a subsequent request is made with fresh credentials, the saved credentials
 // are wiped out; any subsequent request to the zero-parameter overload of this
 // method preserves the saved credentials.
 bool GaiaAuthenticator::AuthenticateImpl(const AuthParams& params,
                                          AuthResults* results) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
-  results->credentials_saved = params.should_save_credentials;
   results->auth_error = ConnectionUnavailable;
-  // Save credentials if so requested.
-  if (params.should_save_credentials != DONT_SAVE_CREDENTIALS) {
-    results->email = params.email.data();
-    results->password = params.password;
-  } else {  // Explicitly clear previously-saved credentials.
-    results->email = "";
-    results->password = "";
-  }
+  results->email = params.email.data();
+  results->password = params.password;
 
   // The aim of this code is to start failing requests if due to a logic error
   // in the program we're hammering GAIA.
 #if defined(OS_WIN)
   __time32_t now = _time32(0);
 #else  // defined(OS_WIN)
   time_t now = time(0);
 #endif  // defined(OS_WIN)
 
   if (now > next_allowed_auth_attempt_time_) {
@@ skipping 43 matching lines @@
     return false;
   }
 
   // Parse reply in two different ways, depending on if request failed or
   // succeeded.
   if (RC_FORBIDDEN == server_response_code) {
     ExtractAuthErrorFrom(message_text, results);
     return false;
   } else if (RC_REQUEST_OK == server_response_code) {
     ExtractTokensFrom(message_text, results);
-    const bool old_gaia =
-      results->auth_token.empty() && !results->lsid.empty();
-    const bool long_lived_token =
-      params.should_save_credentials == PERSIST_TO_DISK;
-    if ((old_gaia || long_lived_token) &&
-        !IssueAuthToken(results, service_id_, long_lived_token))
+    if (!IssueAuthToken(results, service_id_)) {
       return false;
+    }
 
     return LookupEmail(results);
   } else {
     results->auth_error = Unknown;
     return false;
   }
 }
 
 bool GaiaAuthenticator::LookupEmail(AuthResults* results) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
@@ skipping 21 matching lines @@
     ExtractAuthErrorFrom(message_text, results);
     return false;
   } else if (RC_REQUEST_OK == server_response_code) {
     typedef vector<pair<string, string> > Tokens;
     Tokens tokens;
     base::SplitStringIntoKeyValuePairs(message_text, '=', '\n', &tokens);
     for (Tokens::iterator i = tokens.begin(); i != tokens.end(); ++i) {
       if ("accountType" == i->first) {
         // We never authenticate an email as a hosted account.
         DCHECK_EQ("GOOGLE", i->second);
-        results->signin = GMAIL_SIGNIN;
       } else if ("email" == i->first) {
         results->primary_email = i->second;
       }
     }
     return true;
   }
   return false;
 }
 
 // We need to call this explicitly when we need to obtain a long-lived session
 // token.
 bool GaiaAuthenticator::IssueAuthToken(AuthResults* results,
-                                       const string& service_id,
-                                       bool long_lived) {
+                                       const string& service_id) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   // Use the provided Gaia server, but change the path to what V1 expects.
   GURL url(gaia_url_);  // Gaia server.
   GURL::Replacements repl;
   // Needs to stay in scope till GURL is out of scope.
   string path(kGaiaV1IssueAuthTokenPath);
   repl.SetPathStr(path);
   url = url.ReplaceComponents(repl);
 
   string post_body;
   post_body += "LSID=";
   post_body += EscapeUrlEncodedData(results->lsid);
   post_body += "&service=" + service_id;
-  if (long_lived) {
-    post_body += "&Session=true";
-  }
+  post_body += "&Session=true";
 
   unsigned long server_response_code;
   string message_text;
   if (!Post(url, post_body, &server_response_code, &message_text)) {
     return false;
   }
 
   // Check if we received a valid AuthToken; if not, ignore it.
   if (RC_FORBIDDEN == server_response_code) {
     // Server says we're not authenticated.
@@ skipping 92 matching lines @@
 void GaiaAuthenticator::SetUsername(const string& username) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   auth_results_.email = username;
 }
 
 void GaiaAuthenticator::RenewAuthToken(const string& auth_token) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   DCHECK(!this->auth_token().empty());
   auth_results_.auth_token = auth_token;
 }
-void GaiaAuthenticator::SetAuthToken(const string& auth_token,
-                                     SaveCredentials save) {
+void GaiaAuthenticator::SetAuthToken(const string& auth_token) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   auth_results_.auth_token = auth_token;
-  auth_results_.credentials_saved = save;
 }
 
 bool GaiaAuthenticator::Authenticate(const string& user_name,
-                                     const string& password,
-                                     SaveCredentials should_save_credentials,
-                                     SignIn try_first) {
+                                     const string& password) {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   const string empty;
-  return Authenticate(user_name, password, should_save_credentials, empty,
-                      empty, try_first);
+  return Authenticate(user_name, password, empty,
+                      empty);
 }
 
 }  // namepace gaia