Remove signin and persist from gaia_authenticator.

chrome/common/net/gaia/gaia_authenticator.h

 // 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.
 //
 // Use this class to authenticate users with Gaia and access cookies sent
 // by the Gaia servers. This class cannot be used on its own becaue it relies
 // on a subclass to provide the virtual Post and GetBackoffDelaySeconds methods.
 //
 // Sample usage:
 // class ActualGaiaAuthenticator : public gaia::GaiaAuthenticator {
 //   Provides actual implementation of Post and GetBackoffDelaySeconds.
 // };
 // ActualGaiaAuthenticator gaia_auth("User-Agent", SERVICE_NAME, kGaiaUrl);
 // if (gaia_auth.Authenticate("email", "passwd", SAVE_IN_MEMORY_ONLY,
 //                            true)) { // Synchronous
 //   // Do something with: gaia_auth.auth_token(), or gaia_auth.sid(),
 //   // or gaia_auth.lsid()
 // }
 //
 // Credentials can also be preserved for subsequent requests, though these are
 // saved in plain-text in memory, and not very secure on client systems. The
 // email address associated with the Gaia account can be read; the password is
 // write-only.
 
 // TODO(sanjeevr): This class has been moved here from the bookmarks sync code.
 // While it is a generic class that handles GAIA authentication, there are some
-// artifacts of the sync code such as the SaveCredentials enum which needs to
-// be cleaned up.
+// artifacts of the sync code which needs to be cleaned up.
 #ifndef CHROME_COMMON_NET_GAIA_GAIA_AUTHENTICATOR_H_
 #define CHROME_COMMON_NET_GAIA_GAIA_AUTHENTICATOR_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/message_loop.h"
-#include "chrome/common/net/gaia/signin.h"
 #include "chrome/common/deprecated/event_sys.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"  // For FRIEND_TEST
 
 namespace gaia {
 
 static const char kGaiaUrl[] =
     "https://www.google.com:443/accounts/ClientLogin";
 
-// Use of the following enum is odd. GaiaAuthenticator only looks at
-// and DONT_SAVE_CREDENTIALS and SAVE_IN_MEMORY_ONLY (PERSIST_TO_DISK is == to
-// SAVE_IN_MEMORY_ONLY for GaiaAuthenticator).
-
-enum SaveCredentials {
-  DONT_SAVE_CREDENTIALS,
-  SAVE_IN_MEMORY_ONLY,
-  PERSIST_TO_DISK // Saved in both memory and disk
-};
-
 // Error codes from Gaia. These will be set correctly for both Gaia V1
 // (/ClientAuth) and V2 (/ClientLogin)
 enum AuthenticationError {
   None                      = 0,
   BadAuthentication         = 1,
   NotVerified               = 2,
   TermsNotAgreed            = 3,
   Unknown                   = 4,
   AccountDeleted            = 5,
   AccountDisabled           = 6,
@@ skipping 44 matching lines @@
   // loop, which is injected here.
   void set_message_loop(const MessageLoop* loop) {
     message_loop_ = loop;
   }
 
   // Pass credentials to authenticate with, or use saved credentials via an
   // overload. If authentication succeeds, you can retrieve the authentication
   // token via the respective accessors. Returns a boolean indicating whether
   // authentication succeeded or not.
   bool Authenticate(const std::string& user_name, const std::string& password,
-                    SaveCredentials should_save_credentials,
                     const std::string& captcha_token,
-                    const std::string& captcha_value,
-                    SignIn try_first);
+                    const std::string& captcha_value);
 
-  bool Authenticate(const std::string& user_name, const std::string& password,
-                    SaveCredentials should_save_credentials,
-                    SignIn try_first);
+  bool Authenticate(const std::string& user_name, const std::string& password);
 
   // Pass the LSID to authenticate with. If the authentication succeeds, you can
   // retrieve the authetication token via the respective accessors. Returns a
   // boolean indicating whether authentication succeeded or not.
-  bool AuthenticateWithLsid(const std::string& lsid, bool long_lived_token);
+  // Always returns a long lived token.
+  bool AuthenticateWithLsid(const std::string& lsid);
 
   // Resets all stored cookies to their default values.
   void ResetCredentials();
 
   void SetUsernamePassword(const std::string& username,
                            const std::string& password);
 
   void SetUsername(const std::string& username);
 
   // Virtual for testing
   virtual void RenewAuthToken(const std::string& auth_token);
-  void SetAuthToken(const std::string& auth_token, SaveCredentials);
+  void SetAuthToken(const std::string& auth_token);
 
   struct AuthResults {
-    SaveCredentials credentials_saved;
     std::string email;
     std::string password;
 
     // Fields that store various cookies.
     std::string sid;
     std::string lsid;
     std::string auth_token;
 
     std::string primary_email;
 
     // Fields for items returned when authentication fails.
     std::string error_msg;
     enum AuthenticationError auth_error;
     std::string auth_error_url;
     std::string captcha_token;
     std::string captcha_url;
-    SignIn signin;
 
-    // TODO(skrul): When auth fails, the "signin" field of the results
-    // struct never gets set, which causes valgrind to complain.  Give
-    // this field a value here so the error is suppressed. It turns
-    // out that the signin field has only one possible value, so the
-    // correct fix here would be to to remove it entirely.
-    AuthResults() : credentials_saved(DONT_SAVE_CREDENTIALS),
-                    auth_error(None),
-                    signin(GMAIL_SIGNIN) { }
+    AuthResults() : auth_error(None) {}
   };
 
  protected:
 
   struct AuthParams {
     GaiaAuthenticator* authenticator;
     uint32 request_id;
-    SaveCredentials should_save_credentials;
     std::string email;
     std::string password;
     std::string captcha_token;
     std::string captcha_value;
-    SignIn try_first;
   };
 
   // mutex_ must be entered before calling this function.
   AuthParams MakeParams(const std::string& user_name,
                         const std::string& password,
-                        SaveCredentials should_save_credentials,
                         const std::string& captcha_token,
-                        const std::string& captcha_value,
-                        SignIn try_first);
+                        const std::string& captcha_value);
 
   // The real Authenticate implementations.
   bool AuthenticateImpl(const AuthParams& params);
   bool AuthenticateImpl(const AuthParams& params, AuthResults* results);
 
   // virtual for testing purposes.
   virtual bool PerformGaiaRequest(const AuthParams& params,
                                   AuthResults* results);
   virtual bool Post(const GURL& url, const std::string& post_body,
                     unsigned long* response_code, std::string* response_body) {
@@ skipping 71 matching lines @@
     return auth_results_;
   }
 
   typedef EventChannel<GaiaAuthEvent, Lock> Channel;
 
   inline Channel* channel() const {
     return channel_;
   }
 
  private:
-  bool IssueAuthToken(AuthResults* results, const std::string& service_id,
-                      bool long_lived_token);
+  bool IssueAuthToken(AuthResults* results, const std::string& service_id);
 
   // Helper method to parse response when authentication succeeds.
   void ExtractTokensFrom(const std::string& response, AuthResults* results);
   // Helper method to parse response when authentication fails.
   void ExtractAuthErrorFrom(const std::string& response, AuthResults* results);
 
   // Fields for the obvious data items.
   const std::string user_agent_;
   const std::string service_id_;
   const std::string gaia_url_;
@@ skipping 23 matching lines @@
 #endif  // defined(OS_WIN)
   int early_auth_attempt_count_;
 
   // The message loop all our methods are invoked on.
   const MessageLoop* message_loop_;
 };
 
 }  // namespace gaia
 #endif  // CHROME_COMMON_NET_GAIA_GAIA_AUTHENTICATOR_H_