Show Captcha dialog.

chrome/browser/chromeos/login/existing_user_controller.cc

 // Copyright (c) 2010 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/chromeos/login/existing_user_controller.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "app/l10n_util.h"
@@ skipping 10 matching lines @@
 #include "chrome/browser/chromeos/login/background_view.h"
 #include "chrome/browser/chromeos/login/login_utils.h"
 #include "chrome/browser/chromeos/login/message_bubble.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/wm_ipc.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/profile_manager.h"
 #include "grit/theme_resources.h"
 #include "views/screen.h"
 #include "views/widget/widget.h"
+#include "views/widget/widget_gtk.h"
+#include "views/window/window.h"
 
 namespace chromeos {
 
 namespace {
 
 // Max number of users we'll show. The true max is the min of this and the
 // number of windows that fit on the screen.
 const size_t kMaxUsers = 6;
 
 // Used to indicate no user has been selected.
 const size_t kNotSelected = -1;
 
+// ClientLogin response parameters.
+const char kError[] = "Error=";
+const char kCaptchaError[] = "CaptchaRequired";
+const char kCaptchaUrlParam[] = "CaptchaUrl=";
+const char kCaptchaTokenParam[] = "CaptchaToken=";
+const char kParamSuffix[] = "\n";
+
+// URL prefix for CAPTCHA image.
+const char kCaptchaUrlPrefix[] = "http://www.google.com/accounts/";
+
 }  // namespace
 
 ExistingUserController::ExistingUserController(
     const std::vector<UserManager::User>& users,
     const gfx::Rect& background_bounds)
     : background_bounds_(background_bounds),
       background_window_(NULL),
       background_view_(NULL),
       selected_view_index_(kNotSelected),
       bubble_(NULL) {
@@ skipping 69 matching lines @@
   selected_view_index_ = i - controllers_.begin();
 
   authenticator_ = LoginUtils::Get()->CreateAuthenticator(this);
   Profile* profile = g_browser_process->profile_manager()->GetDefaultProfile();
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(authenticator_.get(),
                         &Authenticator::AuthenticateToLogin,
                         profile,
                         controllers_[selected_view_index_]->user().email(),
-                        UTF16ToUTF8(password)));
+                        UTF16ToUTF8(password),
+                        login_token_,
+                        login_captcha_));
 
   // Disable clicking on other windows.
   SendSetLoginState(false);
 }
 
 void ExistingUserController::LoginOffTheRecord() {
   authenticator_ = LoginUtils::Get()->CreateAuthenticator(this);
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(authenticator_.get(),
@@ skipping 10 matching lines @@
 }
 
 void ExistingUserController::OnUserSelected(UserController* source) {
   std::vector<UserController*>::const_iterator i =
       std::find(controllers_.begin(), controllers_.end(), source);
   DCHECK(i != controllers_.end());
   size_t new_selected_index = i - controllers_.begin();
   if (new_selected_index != selected_view_index_ &&
       selected_view_index_ != kNotSelected) {
     controllers_[selected_view_index_]->ClearAndEnablePassword();
+    ClearCaptchaState();
   }
   selected_view_index_ = new_selected_index;
 }
 
 void ExistingUserController::ActivateWizard(const std::string& screen_name) {
   // WizardController takes care of deleting itself when done.
   WizardController* controller = new WizardController();
   controller->Init(screen_name, background_bounds_, false);
   controller->Show();
 
   // Give the background window to the controller.
   controller->OwnBackground(background_window_, background_view_);
   background_window_ = NULL;
 
   // And schedule us for deletion. We delay for a second as the window manager
   // is doing an animation with our windows.
   delete_timer_.Start(base::TimeDelta::FromSeconds(1), this,
                       &ExistingUserController::Delete);
 }
 
 void ExistingUserController::OnLoginFailure(const std::string& error) {
   LOG(INFO) << "OnLoginFailure";
+  ClearCaptchaState();
 
   // Check networking after trying to login in case user is
   // cached locally or the local admin account.
   NetworkLibrary* network = CrosLibrary::Get()->GetNetworkLibrary();
   if (!network || !CrosLibrary::Get()->EnsureLoaded()) {
     ShowError(IDS_LOGIN_ERROR_NO_NETWORK_LIBRARY, error);
   } else if (!network->Connected()) {
     ShowError(IDS_LOGIN_ERROR_OFFLINE_FAILED_NETWORK_NOT_CONNECTED, error);
   } else {
-    ShowError(IDS_LOGIN_ERROR_AUTHENTICATING, error);
+    std::string error_code = LoginUtils::ExtractClientLoginParam(error,
+                                                                 kError,
+                                                                 kParamSuffix);
+    std::string captcha_url;
+    if (error_code == kCaptchaError)
+      captcha_url = LoginUtils::ExtractClientLoginParam(error,
+                                                        kCaptchaUrlParam,
+                                                        kParamSuffix);
+    if (captcha_url.empty()) {
+      ShowError(IDS_LOGIN_ERROR_AUTHENTICATING, error);
+    } else {
+      // Save token for next login retry.
+      login_token_ = LoginUtils::ExtractClientLoginParam(error,
+                                                         kCaptchaTokenParam,
+                                                         kParamSuffix);
+      gfx::NativeWindow parent = GTK_WINDOW(
+          static_cast<views::WidgetGtk*>(background_window_)->GetNativeView());
+      CaptchaView* view =
+          new CaptchaView(GURL(kCaptchaUrlPrefix + captcha_url));
+      view->set_delegate(this);
+      views::Window* window = views::Window::CreateChromeWindow(parent,
+                                                                gfx::Rect(),
+                                                                view);
+      window->SetIsAlwaysOnTop(true);
+      window->Show();
+    }
   }
 
   controllers_[selected_view_index_]->ClearAndEnablePassword();
 
   // Reenable clicking on other windows.
   SendSetLoginState(true);
 }
 
+void ExistingUserController::ClearCaptchaState() {
+  login_token_.clear();
+  login_captcha_.clear();
+}
+
 void ExistingUserController::ShowError(int error_id,
                                        const std::string& details) {
   ClearErrors();
   std::wstring error_text = l10n_util::GetString(error_id);
   if (!details.empty())
     error_text += L"\n" + ASCIIToWide(details);
   bubble_ = MessageBubble::Show(
       controllers_[selected_view_index_]->controls_window(),
       controllers_[selected_view_index_]->GetScreenBounds(),
       BubbleBorder::BOTTOM_LEFT,
@@ skipping 18 matching lines @@
     LoginUtils::Get()->CompleteLogin(username, credentials);
     // Delay deletion as we're on the stack.
     MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   }
 }
 
 void ExistingUserController::OnOffTheRecordLoginSuccess() {
   LoginUtils::Get()->CompleteOffTheRecordLogin();
 }
 
+void ExistingUserController::OnCaptchaEntered(const std::string& captcha) {
+  login_captcha_ = captcha;
+}
+
 }  // namespace chromeos