[cros] Add blocking UI on offline: OK, online auth: fail case.

chrome/browser/chromeos/login/screen_locker.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/screen_locker.h"
 
 #include <gdk/gdkx.h>
 #include <string>
 #include <vector>
 #include <X11/extensions/XTest.h>
@@ skipping 14 matching lines @@
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/chromeos/cros/input_method_library.h"
 #include "chrome/browser/chromeos/cros/keyboard_library.h"
 #include "chrome/browser/chromeos/cros/login_library.h"
 #include "chrome/browser/chromeos/cros/screen_lock_library.h"
 #include "chrome/browser/chromeos/language_preferences.h"
 #include "chrome/browser/chromeos/login/authenticator.h"
 #include "chrome/browser/chromeos/login/background_view.h"
+#include "chrome/browser/chromeos/login/login_performer.h"
 #include "chrome/browser/chromeos/login/login_utils.h"
 #include "chrome/browser/chromeos/login/message_bubble.h"
 #include "chrome/browser/chromeos/login/screen_lock_view.h"
 #include "chrome/browser/chromeos/login/shutdown_button.h"
 #include "chrome/browser/chromeos/system_key_event_listener.h"
 #include "chrome/browser/chromeos/wm_ipc.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/profile_manager.h"
 #include "chrome/browser/sync/profile_sync_service.h"
 #include "chrome/browser/ui/browser.h"
@@ skipping 673 matching lines @@
     LOG(ERROR) << "authentication_start_time_ is not set";
   } else {
     base::TimeDelta delta = base::Time::Now() - authentication_start_time_;
     VLOG(1) << "Authentication failure time: " << delta.InSecondsF();
     UMA_HISTOGRAM_TIMES("ScreenLocker.AuthenticationFailureTime", delta);
   }
 
   EnableInput();
   // Don't enable signout button here as we're showing
   // MessageBubble.
-  gfx::Rect rect = screen_lock_view_->GetPasswordBoundsRelativeTo(
-      lock_widget_->GetRootView());
-  gfx::Rect lock_widget_bounds;
-  lock_widget_->GetBounds(&lock_widget_bounds, false);
-  rect.Offset(lock_widget_bounds.x(), lock_widget_bounds.y());
 
-  if (error_info_)
-    error_info_->Close();
   std::wstring msg = l10n_util::GetString(IDS_LOGIN_ERROR_AUTHENTICATING);
   const std::string error_text = error.GetErrorString();
   if (!error_text.empty())
     msg += L"\n" + ASCIIToWide(error_text);
 
   InputMethodLibrary* input_method_library =
       CrosLibrary::Get()->GetInputMethodLibrary();
   if (input_method_library->GetNumActiveInputMethods() > 1)
     msg += L"\n" + l10n_util::GetString(IDS_LOGIN_ERROR_KEYBOARD_SWITCH_HINT);
 
-  error_info_ = MessageBubble::ShowNoGrab(
-      lock_window_,
-      rect,
-      BubbleBorder::BOTTOM_LEFT,
-      ResourceBundle::GetSharedInstance().GetBitmapNamed(IDR_WARNING),
-      msg,
-      std::wstring(),  // TODO: add help link
-      this);
-  if (mouse_event_relay_.get()) {
-    MessageLoopForUI::current()->RemoveObserver(mouse_event_relay_.get());
-  }
-  mouse_event_relay_.reset(
-      new MouseEventRelay(lock_widget_->GetNativeView()->window,
-                          error_info_->GetNativeView()->window));
-  MessageLoopForUI::current()->AddObserver(mouse_event_relay_.get());
+  ShowErrorBubble(msg, BubbleBorder::BOTTOM_LEFT);
 }
 
 void ScreenLocker::OnLoginSuccess(
     const std::string& username,
     const std::string& password,
     const GaiaAuthConsumer::ClientLoginResult& unused,
     bool pending_requests) {
   VLOG(1) << "OnLoginSuccess: Sending Unlock request.";
   if (authentication_start_time_.is_null()) {
     LOG(ERROR) << "authentication_start_time_ is not set";
@@ skipping 23 matching lines @@
   if (mouse_event_relay_.get()) {
     MessageLoopForUI::current()->RemoveObserver(mouse_event_relay_.get());
     mouse_event_relay_.reset();
   }
 }
 
 void ScreenLocker::Authenticate(const string16& password) {
   authentication_start_time_ = base::Time::Now();
   screen_lock_view_->SetEnabled(false);
   screen_lock_view_->SetSignoutEnabled(false);
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      NewRunnableMethod(authenticator_.get(),
-                        &Authenticator::AuthenticateToUnlock,
-                        user_.email(),
-                        UTF16ToUTF8(password)));
+
+  // If LoginPerformer instance exists,
+  // initial online login phase is still active.
+  if (LoginPerformer::default_performer()) {
+    DVLOG(1) << "Delegating authentication to LoginPerformer.";
+    LoginPerformer::default_performer()->Login(user_.email(),
+                                               UTF16ToUTF8(password));
+  } else {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        NewRunnableMethod(authenticator_.get(),
+                          &Authenticator::AuthenticateToUnlock,
+                          user_.email(),
+                          UTF16ToUTF8(password)));
+  }
 }
 
 void ScreenLocker::ClearErrors() {
   if (error_info_) {
     error_info_->Close();
     error_info_ = NULL;
   }
 }
 
 void ScreenLocker::EnableInput() {
   if (screen_lock_view_) {
     screen_lock_view_->SetEnabled(true);
     screen_lock_view_->ClearAndSetFocusToPassword();
   }
 }
 
 void ScreenLocker::Signout() {
   if (!error_info_) {
     UserMetrics::RecordAction(UserMetricsAction("ScreenLocker_Signout"));
     if (CrosLibrary::Get()->EnsureLoaded()) {
       CrosLibrary::Get()->GetLoginLibrary()->StopSession("");
     }
 
     // Don't hide yet the locker because the chrome screen may become visible
     // briefly.
   }
 }
 
+void ScreenLocker::ShowErrorMessage(const std::wstring& message,
+                                    bool sign_out_only) {
+  if (sign_out_only) {
+    screen_lock_view_->SetEnabled(false);
+  } else {
+    EnableInput();
+  }
+  screen_lock_view_->SetSignoutEnabled(sign_out_only);
+  // Make sure that active Sign Out button is not hidden behind the bubble.
+  ShowErrorBubble(message, sign_out_only ?
+      BubbleBorder::BOTTOM_RIGHT : BubbleBorder::BOTTOM_LEFT);
+}
+
 void ScreenLocker::OnGrabInputs() {
   DVLOG(1) << "OnGrabInputs";
   input_grabbed_ = true;
   if (drawn_)
     ScreenLockReady();
 }
 
 // static
 void ScreenLocker::Show() {
   VLOG(1) << "In ScreenLocker::Show";
@@ skipping 125 matching lines @@
   }
 }
 
 void ScreenLocker::OnWindowManagerReady() {
   DVLOG(1) << "OnClientEvent: drawn for lock";
   drawn_ = true;
   if (input_grabbed_)
     ScreenLockReady();
 }
 
+void ScreenLocker::ShowErrorBubble(const std::wstring& message,
+                                   BubbleBorder::ArrowLocation arrow_location) {
+  if (error_info_)
+    error_info_->Close();
+
+  gfx::Rect rect = screen_lock_view_->GetPasswordBoundsRelativeTo(
+      lock_widget_->GetRootView());
+  gfx::Rect lock_widget_bounds;
+  lock_widget_->GetBounds(&lock_widget_bounds, false);
+  rect.Offset(lock_widget_bounds.x(), lock_widget_bounds.y());
+  error_info_ = MessageBubble::ShowNoGrab(
+      lock_window_,
+      rect,
+      arrow_location,
+      ResourceBundle::GetSharedInstance().GetBitmapNamed(IDR_WARNING),
+      message,
+      std::wstring(),  // TODO(nkostylev): Add help link.
+      this);
+
+  if (mouse_event_relay_.get())
+    MessageLoopForUI::current()->RemoveObserver(mouse_event_relay_.get());
+  mouse_event_relay_.reset(
+      new MouseEventRelay(lock_widget_->GetNativeView()->window,
+                          error_info_->GetNativeView()->window));
+  MessageLoopForUI::current()->AddObserver(mouse_event_relay_.get());
+}
+
 void ScreenLocker::StopScreenSaver() {
   if (background_view_->IsScreenSaverVisible()) {
     VLOG(1) << "StopScreenSaver";
     background_view_->HideScreenSaver();
     if (screen_lock_view_) {
       screen_lock_view_->SetVisible(true);
       screen_lock_view_->RequestFocus();
     }
     EnableInput();
   }
@@ skipping 15 matching lines @@
 
 bool ScreenLocker::AcceleratorPressed(const views::Accelerator& accelerator) {
   if (!background_view_->IsScreenSaverVisible()) {
     StartScreenSaver();
     return true;
   }
   return false;
 }
 
 }  // namespace chromeos