Sync: Remove pthreads from event_sys code. Remove asynch version of GaiaAuthe...

chrome/browser/sync/engine/net/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/browser/sync/engine/net/gaia_authenticator.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 86 matching lines @@
       early_auth_attempt_count_(0) {
   GaiaAuthEvent done = { GaiaAuthEvent::GAIA_AUTHENTICATOR_DESTROYED, None,
                          this };
   channel_ = new Channel(done);
 }
 
 GaiaAuthenticator::~GaiaAuthenticator() {
   delete channel_;
 }
 
-bool GaiaAuthenticator::LaunchAuthenticate(const AuthParams& params,
-                                           bool synchronous) {
-  if (synchronous)
-    return AuthenticateImpl(params);
-  AuthParams* copy = new AuthParams;
-  *copy = params;
-  pthread_t thread_id;
-  int result = pthread_create(&thread_id, 0, &GaiaAuthenticator::ThreadMain,
-                              copy);
-  if (result)
-    return false;
-  return true;
-}
-
-
-void* GaiaAuthenticator::ThreadMain(void* arg) {
-  NameCurrentThreadForDebugging("SyncEngine_GaiaAuthenticatorThread");
-  AuthParams* const params = reinterpret_cast<AuthParams*>(arg);
-  params->authenticator->AuthenticateImpl(*params);
-  delete params;
-  return 0;
-}
-
 // 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) {
   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,
-                                     bool synchronous,
                                      const string& captcha_token,
                                      const string& captcha_value,
                                      SignIn try_first) {
-  mutex_.Lock();
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
+
   AuthParams const params =
     MakeParams(user_name, password, should_save_credentials, captcha_token,
                captcha_value, try_first);
-  mutex_.Unlock();
-  return LaunchAuthenticate(params, synchronous);
+  return AuthenticateImpl(params);
 }
 
 bool GaiaAuthenticator::AuthenticateImpl(const AuthParams& params) {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   AuthResults results;
   const bool succeeded = AuthenticateImpl(params, &results);
-  mutex_.Lock();
   if (params.request_id == request_count_) {
     auth_results_ = results;
     GaiaAuthEvent event = { succeeded ? GaiaAuthEvent::GAIA_AUTH_SUCCEEDED
                                       : GaiaAuthEvent::GAIA_AUTH_FAILED,
                                       results.auth_error, this };
-    mutex_.Unlock();
     channel_->NotifyListeners(event);
-  } else {
-    mutex_.Unlock();
   }
   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 = "";
   }
@@ skipping 17 matching lines @@
       next_allowed_auth_attempt_time_ = now + delay_;
       return false;
     }
   }
 
   return PerformGaiaRequest(params, results);
 }
 
 bool GaiaAuthenticator::PerformGaiaRequest(const AuthParams& params,
                                            AuthResults* results) {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   GURL gaia_auth_url(gaia_url_);
 
   string post_body;
   post_body += "Email=" + CgiEscapeString(params.email);
   post_body += "&Passwd=" + CgiEscapeString(params.password);
   post_body += "&source=" + CgiEscapeString(user_agent_);
   post_body += "&service=" + service_id_;
   if (!params.captcha_token.empty() && !params.captcha_value.empty()) {
     post_body += "&logintoken=" + CgiEscapeString(params.captcha_token);
     post_body += "&logincaptcha=" + CgiEscapeString(params.captcha_value);
@@ skipping 26 matching lines @@
       return false;
 
     return LookupEmail(results);
   } else {
     results->auth_error = Unknown;
     return false;
   }
 }
 
 bool GaiaAuthenticator::LookupEmail(AuthResults* results) {
+  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(kGetUserInfoPath);
   repl.SetPathStr(path);
   url = url.ReplaceComponents(repl);
 
   string post_body;
   post_body += "LSID=";
@@ skipping 26 matching lines @@
     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) {
+  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=";
@@ skipping 22 matching lines @@
     // ExtractTokensFrom(...), but simply assign the token.
     int last_index = message_text.length() - 1;
     if ('\n' == message_text[last_index])
       message_text.erase(last_index);
     results->auth_token = message_text;
     return true;
   }
   return false;
 }
 
-// TOOD(sync): This passing around of AuthResults makes it really unclear who
-// actually owns the authentication state and when it is valid, but this is
-// endemic to this implementation. We should fix this.
-bool GaiaAuthenticator::AuthenticateService(const string& service_id,
-                                            const string& sid,
-                                            const string& lsid,
-                                            string* other_service_cookie) {
-  // Copy the AuthResults structure and overload the auth_token field
-  // in the copy, local_results, to mean the auth_token for service_id.
-  AuthResults local_results;
-  local_results.sid = sid;
-  local_results.lsid = lsid;
-
-  if (!IssueAuthToken(&local_results, service_id, true)) {
-    LOG(ERROR) << "[AUTH] Failed to obtain cookie for " << service_id;
-    return false;
-  }
-
-  swap(*other_service_cookie, local_results.auth_token);
-  return true;
-}
-
 // Helper method that extracts tokens from a successful reply, and saves them
 // in the right fields.
 void GaiaAuthenticator::ExtractTokensFrom(const string& response,
                                           AuthResults* results) {
   vector<pair<string, string> > tokens;
   SplitStringIntoKeyValuePairs(response, '=', '\n', &tokens);
   for (vector<pair<string, string> >::iterator i = tokens.begin();
       i != tokens.end(); ++i) {
     if (i->first == "SID") {
       results->sid = i->second;
@@ skipping 43 matching lines @@
   } else if (error_msg == "CaptchaRequired" || error_msg == "cr") {
     results->auth_error = CaptchaRequired;
   } else if (error_msg == "ServiceUnavailable" || error_msg == "ire") {
     results->auth_error = ServiceUnavailable;
   }
 }
 
 // Reset all stored credentials, perhaps in preparation for letting a different
 // user sign in.
 void GaiaAuthenticator::ResetCredentials() {
-  PThreadScopedLock<PThreadMutex> enter(&mutex_);
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   AuthResults blank;
   auth_results_ = blank;
 }
 
 void GaiaAuthenticator::SetUsernamePassword(const string& username,
                                             const string& password) {
-  PThreadScopedLock<PThreadMutex> enter(&mutex_);
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   auth_results_.password = password;
   auth_results_.email = username;
 }
 
 void GaiaAuthenticator::SetUsername(const string& username) {
-  PThreadScopedLock<PThreadMutex> enter(&mutex_);
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   auth_results_.email = username;
 }
 
 void GaiaAuthenticator::SetAuthToken(const string& auth_token,
                                      SaveCredentials save) {
-  PThreadScopedLock<PThreadMutex> enter(&mutex_);
+  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,
-                                     bool synchronous, SignIn try_first) {
+                                     SignIn try_first) {
+  DCHECK_EQ(MessageLoop::current(), message_loop_);
   const string empty;
-  return Authenticate(user_name, password, should_save_credentials, synchronous,
-                      empty, empty, try_first);
+  return Authenticate(user_name, password, should_save_credentials, empty,
+                      empty, try_first);
 }
 
 }  // namespace browser_sync