Implement the gaia captcha state and unlock capability in the sync setup wiza...

chrome/browser/sync/engine/syncapi.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/syncapi.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 688 matching lines @@
   // 3. Tell the ServerConnectionManager to pass the newly received GAIA auth
   //    token to a sync server to obtain a sync token.
   // 4. On receipt of this token, the ServerConnectionManager broadcasts
   //    a server-reachable event, which will unblock the SyncerThread,
   //    and the rest is the future.
   //
   // If authentication fails, an event will be broadcast all the way up to
   // the SyncManager::Observer. It may, in turn, decide to try again with new
   // credentials. Calling this method again is the appropriate course of action
   // to "retry".
-  void Authenticate(const std::string& username, const std::string& password);
+  void Authenticate(const std::string& username, const std::string& password,
+                    const std::string& captcha);
 
   // Call periodically from a database-safe thread to persist recent changes
   // to the syncapi model.
   void SaveChanges();
 
   // This listener is called upon completion of a syncable transaction, and
   // builds the list of sync-engine initiated changes that will be forwarded to
   // the SyncManager's Observers.
   void HandleChangeEvent(const syncable::DirectoryChangeEvent& event);
   void HandleTransactionCompleteChangeEvent(
@@ skipping 207 matching lines @@
                      gaia_service_id,
                      gaia_source,
                      use_ssl,
                      post_factory,
                      auth_post_factory,
                      model_safe_worker,
                      attempt_last_user_authentication,
                      user_agent);
 }
 
-void SyncManager::Authenticate(const char* username, const char* password) {
-  data_->Authenticate(std::string(username), std::string(password));
+void SyncManager::Authenticate(const char* username, const char* password,
+    const char* captcha) {
+  data_->Authenticate(std::string(username), std::string(password),
+                      std::string(captcha));
 }
 
 const std::string& SyncManager::GetAuthenticatedUsername() {
   DCHECK(data_);
   return data_->username_for_share();
 }
 
 bool SyncManager::SyncInternal::Init(
     const FilePath& database_location,
     const std::string& sync_server_and_path,
@@ skipping 102 matching lines @@
       return;
     initialized_ = true;
   }
 
   // Notify that initialization is complete.
   if (observer_)
     observer_->OnInitializationComplete();
 }
 
 void SyncManager::SyncInternal::Authenticate(const std::string& username,
-                                             const std::string& password) {
+                                             const std::string& password,
+                                             const std::string& captcha) {
   DCHECK(username_for_share().empty() || username == username_for_share())
         << "Username change from valid username detected";
   if (allstatus()->status().authenticated)
     return;
   if (password.empty()) {
     // TODO(timsteele): Seems like this shouldn't be needed, but auth_watcher
     // currently drops blank password attempts on the floor and doesn't update
     // state; it only LOGs an error in this case. We want to make sure we set
     // our GoogleServiceAuthError state to denote an error.
     RaiseAuthNeededEvent();
   }
-  auth_watcher()->Authenticate(username, password, true);
+  auth_watcher()->Authenticate(username, password, std::string(),
+                               captcha, true);
 }
 
 void SyncManager::SyncInternal::AuthenticateForLastKnownUser() {
   std::string username;
   std::string auth_token;
   if (!(auth_watcher()->settings()->GetLastUserAndServiceToken(
         SYNC_SERVICE_NAME, &username, &auth_token))) {
     RaiseAuthNeededEvent();
     return;
   }
@@ skipping 344 matching lines @@
         // Start watching the syncer channel directly here.
         DCHECK(syncer_thread() != NULL);
         syncer_event_.reset(NewEventListenerHookup(syncer_thread()->channel(),
             this, &SyncInternal::HandleSyncerEvent));
       }
       return;
     // Authentication failures translate to GoogleServiceAuthError events.
     case AuthWatcherEvent::GAIA_AUTH_FAILED:     // Invalid GAIA credentials.
       if (event.auth_results->auth_error == browser_sync::CaptchaRequired) {
         auth_problem_ = AuthError::CAPTCHA_REQUIRED;
-        GURL captcha("http://www.google.com/accounts/");
-        GURL::Replacements replacer;
-        replacer.SetPathStr(captcha.path().append(
-            event.auth_results->captcha_url));
-        captcha = captcha.ReplaceComponents(replacer);
+        std::string url_string("http://www.google.com/accounts/");
+        url_string += event.auth_results->captcha_url;
+        GURL captcha(url_string);
         observer_->OnAuthError(AuthError::FromCaptchaChallenge(
             event.auth_results->captcha_token, captcha,
             GURL(event.auth_results->auth_error_url)));
         return;
       }
     case AuthWatcherEvent::SERVICE_AUTH_FAILED:  // Expired GAIA credentials.
       auth_problem_ = AuthError::INVALID_GAIA_CREDENTIALS;
       break;
     case AuthWatcherEvent::SERVICE_USER_NOT_SIGNED_UP:
       auth_problem_ = AuthError::USER_NOT_SIGNED_UP;
@@ skipping 74 matching lines @@
 BaseTransaction::~BaseTransaction() {
   delete lookup_;
 }
 
 UserShare* SyncManager::GetUserShare() const {
   DCHECK(data_->initialized()) << "GetUserShare requires initialization!";
   return data_->GetUserShare();
 }
 
 }  // namespace sync_api