#include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
#include <algorithm>
+#include <vector>
#include "base/bind.h"
#include "base/bind_helpers.h"
-#include "base/command_line.h"
#include "base/debug/trace_event.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
+#include "base/sys_info.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/browser_process_platform_part_chromeos.h"
#include "chrome/browser/browser_shutdown.h"
#include "chrome/browser/chromeos/input_method/input_method_util.h"
#include "chrome/browser/chromeos/kiosk_mode/kiosk_mode_settings.h"
#include "chrome/browser/chromeos/login/hwid_checker.h"
-#include "chrome/browser/chromeos/login/login_display_host.h"
-#include "chrome/browser/chromeos/login/login_display_host_impl.h"
-#include "chrome/browser/chromeos/login/multi_profile_user_controller.h"
-#include "chrome/browser/chromeos/login/screen_locker.h"
+#include "chrome/browser/chromeos/login/lock/screen_locker.h"
#include "chrome/browser/chromeos/login/screens/core_oobe_actor.h"
-#include "chrome/browser/chromeos/login/user.h"
-#include "chrome/browser/chromeos/login/wallpaper_manager.h"
-#include "chrome/browser/chromeos/login/webui_login_display.h"
+#include "chrome/browser/chromeos/login/ui/login_display_host.h"
+#include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
+#include "chrome/browser/chromeos/login/ui/webui_login_display.h"
+#include "chrome/browser/chromeos/login/users/multi_profile_user_controller.h"
+#include "chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.h"
#include "chrome/browser/chromeos/login/wizard_controller.h"
-#include "chrome/browser/chromeos/net/network_portal_detector.h"
#include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
+#include "chrome/browser/chromeos/policy/consumer_management_service.h"
+#include "chrome/browser/chromeos/policy/device_local_account.h"
#include "chrome/browser/chromeos/profiles/profile_helper.h"
#include "chrome/browser/chromeos/settings/cros_settings.h"
#include "chrome/browser/io_thread.h"
#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/signin/easy_unlock_service.h"
#include "chrome/browser/ui/webui/chromeos/login/authenticated_user_email_retriever.h"
#include "chrome/browser/ui/webui/chromeos/login/error_screen_handler.h"
+#include "chrome/browser/ui/webui/chromeos/login/l10n_util.h"
#include "chrome/browser/ui/webui/chromeos/login/native_window_delegate.h"
#include "chrome/browser/ui/webui/chromeos/login/network_state_informer.h"
#include "chrome/browser/ui/webui/chromeos/login/oobe_ui.h"
-#include "chrome/common/chrome_switches.h"
#include "chrome/common/pref_names.h"
#include "chrome/common/url_constants.h"
-#include "chromeos/chromeos_switches.h"
+#include "chrome/grit/chromium_strings.h"
+#include "chrome/grit/generated_resources.h"
#include "chromeos/dbus/dbus_thread_manager.h"
#include "chromeos/dbus/power_manager_client.h"
+#include "chromeos/ime/ime_keyboard.h"
+#include "chromeos/ime/input_method_descriptor.h"
#include "chromeos/ime/input_method_manager.h"
-#include "chromeos/ime/xkeyboard.h"
+#include "chromeos/login/auth/key.h"
+#include "chromeos/login/auth/user_context.h"
#include "chromeos/network/network_state.h"
#include "chromeos/network/network_state_handler.h"
-#include "content/public/browser/browser_thread.h"
+#include "chromeos/network/portal_detector/network_portal_detector.h"
+#include "components/user_manager/user.h"
+#include "components/user_manager/user_manager.h"
+#include "components/user_manager/user_type.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/web_contents.h"
#include "google_apis/gaia/gaia_auth_util.h"
-#include "grit/chromium_strings.h"
-#include "grit/generated_resources.h"
#include "net/url_request/url_request_context_getter.h"
#include "third_party/cros_system_api/dbus/service_constants.h"
+#include "ui/base/webui/web_ui_util.h"
#if defined(USE_AURA)
#include "ash/shell.h"
#include "ash/wm/lock_state_controller.h"
#endif
-using content::BrowserThread;
-
namespace {
-// User dictionary keys.
-const char kKeyUsername[] = "username";
-const char kKeyDisplayName[] = "displayName";
-const char kKeyEmailAddress[] = "emailAddress";
-const char kKeyEnterpriseDomain[] = "enterpriseDomain";
-const char kKeyPublicAccount[] = "publicAccount";
-const char kKeyLocallyManagedUser[] = "locallyManagedUser";
-const char kKeySignedIn[] = "signedIn";
-const char kKeyCanRemove[] = "canRemove";
-const char kKeyIsOwner[] = "isOwner";
-const char kKeyInitialAuthType[] = "initialAuthType";
-const char kKeyMultiProfilesAllowed[] = "isMultiProfilesAllowed";
-const char kKeyMultiProfilesPolicy[] = "multiProfilesPolicy";
-
// Max number of users to show.
const size_t kMaxUsers = 18;
const char kSourceGaiaSignin[] = "gaia-signin";
const char kSourceAccountPicker[] = "account-picker";
-// The Task posted to PostTaskAndReply in StartClearingDnsCache on the IO
-// thread.
-void ClearDnsCache(IOThread* io_thread) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
- if (browser_shutdown::IsTryingToQuit())
- return;
-
- io_thread->ClearHostCache();
-}
-
static bool Contains(const std::vector<std::string>& container,
const std::string& value) {
return std::find(container.begin(), container.end(), value) !=
container.end();
}
+class CallOnReturn {
+ public:
+ explicit CallOnReturn(const base::Closure& callback)
+ : callback_(callback), call_scheduled_(false) {}
+
+ ~CallOnReturn() {
+ if (call_scheduled_ && !callback_.is_null())
+ callback_.Run();
+ }
+
+ void ScheduleCall() { call_scheduled_ = true; }
+
+ private:
+ base::Closure callback_;
+ bool call_scheduled_;
+
+ DISALLOW_COPY_AND_ASSIGN(CallOnReturn);
+};
+
} // namespace
namespace chromeos {
static bool SetUserInputMethodImpl(
const std::string& username,
- chromeos::input_method::InputMethodManager* manager) {
- PrefService* const local_state = g_browser_process->local_state();
-
- const base::DictionaryValue* users_lru_input_methods =
- local_state->GetDictionary(prefs::kUsersLRUInputMethod);
-
- if (users_lru_input_methods == NULL) {
- DLOG(WARNING) << "SetUserInputMethod('" << username
- << "'): no kUsersLRUInputMethod";
- return false;
- }
-
- std::string input_method;
-
- if (!users_lru_input_methods->GetStringWithoutPathExpansion(username,
- &input_method)) {
- DVLOG(0) << "SetUserInputMethod('" << username
- << "'): no input method for this user";
- return false;
- }
-
- if (input_method.empty())
- return false;
-
- if (!manager->IsLoginKeyboard(input_method)) {
+ const std::string& user_input_method,
+ input_method::InputMethodManager::State* ime_state) {
+ if (!chromeos::input_method::InputMethodManager::Get()->IsLoginKeyboard(
+ user_input_method)) {
LOG(WARNING) << "SetUserInputMethod('" << username
- << "'): stored user LRU input method '" << input_method
+ << "'): stored user LRU input method '" << user_input_method
<< "' is no longer Full Latin Keyboard Language"
<< " (entry dropped). Use hardware default instead.";
+ PrefService* const local_state = g_browser_process->local_state();
DictionaryPrefUpdate updater(local_state, prefs::kUsersLRUInputMethod);
base::DictionaryValue* const users_lru_input_methods = updater.Get();
return false;
}
- if (!Contains(manager->GetActiveInputMethodIds(), input_method)) {
- if (!manager->EnableInputMethod(input_method)) {
+ if (!Contains(ime_state->GetActiveInputMethodIds(), user_input_method)) {
+ if (!ime_state->EnableInputMethod(user_input_method)) {
DLOG(ERROR) << "SigninScreenHandler::SetUserInputMethod('" << username
- << "'): user input method '" << input_method
+ << "'): user input method '" << user_input_method
<< "' is not enabled and enabling failed (ignored!).";
}
}
- manager->ChangeInputMethod(input_method);
+ ime_state->ChangeInputMethod(user_input_method, false /* show_message */);
return true;
}
-void RecordSAMLScrapingVerificationResultInHistogram(bool success) {
- UMA_HISTOGRAM_BOOLEAN("ChromeOS.SAML.Scraping.VerificationResult", success);
-}
-
-bool ShouldForceOnlineSignIn(const User* user) {
- // Public sessions are always allowed to log in offline.
- // Supervised user are allowed to log in offline if their OAuth token status
- // is unknown or valid.
- // For all other users, force online sign in if:
- // * The flag to force online sign-in is set for the user.
- // * The user's OAuth token is invalid.
- // * The user's OAuth token status is unknown (except supervised users,
- // see above).
- if (user->is_logged_in())
- return false;
-
- const User::OAuthTokenStatus token_status = user->oauth_token_status();
- const bool is_locally_managed_user =
- user->GetType() == User::USER_TYPE_LOCALLY_MANAGED;
- const bool is_public_session =
- user->GetType() == User::USER_TYPE_PUBLIC_ACCOUNT;
-
- if (is_locally_managed_user &&
- token_status == User::OAUTH_TOKEN_STATUS_UNKNOWN) {
- return false;
- }
-
- if (is_public_session)
- return false;
-
- return user->force_online_signin() ||
- (token_status == User::OAUTH2_TOKEN_STATUS_INVALID) ||
- (token_status == User::OAUTH_TOKEN_STATUS_UNKNOWN);
-}
-
} // namespace
// LoginScreenContext implementation ------------------------------------------
native_window_delegate_(NULL),
show_on_init_(false),
oobe_ui_(false),
- focus_stolen_(false),
- gaia_silent_load_(false),
is_account_picker_showing_first_time_(false),
- dns_cleared_(false),
- dns_clear_task_running_(false),
- cookies_cleared_(false),
network_state_informer_(network_state_informer),
- using_saml_api_(false),
- test_expects_complete_login_(false),
- weak_factory_(this),
webui_visible_(false),
preferences_changed_delayed_(false),
error_screen_actor_(error_screen_actor),
offline_login_active_(false),
last_network_state_(NetworkStateInformer::UNKNOWN),
has_pending_auth_ui_(false),
- caps_lock_enabled_(false),
- gaia_screen_handler_(gaia_screen_handler) {
+ caps_lock_enabled_(chromeos::input_method::InputMethodManager::Get()
+ ->GetImeKeyboard()
+ ->CapsLockIsEnabled()),
+ gaia_screen_handler_(gaia_screen_handler),
+ oobe_ui_observer_added_(false),
+ weak_factory_(this) {
DCHECK(network_state_informer_.get());
DCHECK(error_screen_actor_);
DCHECK(core_oobe_actor_);
DCHECK(gaia_screen_handler_);
gaia_screen_handler_->SetSigninScreenHandler(this);
network_state_informer_->AddObserver(this);
- allow_new_user_subscription_ = CrosSettings::Get()->AddSettingsObserver(
- kAccountsPrefAllowNewUser,
- base::Bind(&SigninScreenHandler::UserSettingsChanged,
- base::Unretained(this)));
- allow_guest_subscription_ = CrosSettings::Get()->AddSettingsObserver(
- kAccountsPrefAllowGuest,
- base::Bind(&SigninScreenHandler::UserSettingsChanged,
- base::Unretained(this)));
registrar_.Add(this,
chrome::NOTIFICATION_AUTH_NEEDED,
registrar_.Add(this,
chrome::NOTIFICATION_AUTH_CANCELLED,
content::NotificationService::AllSources());
+
+ chromeos::input_method::ImeKeyboard* keyboard =
+ chromeos::input_method::InputMethodManager::Get()->GetImeKeyboard();
+ if (keyboard)
+ keyboard->AddObserver(this);
+
+#if !defined(USE_ATHENA)
+ max_mode_delegate_.reset(new TouchViewControllerDelegate());
+ max_mode_delegate_->AddObserver(this);
+#endif
+
+ policy::ConsumerManagementService* consumer_management =
+ g_browser_process->platform_part()->browser_policy_connector_chromeos()->
+ GetConsumerManagementService();
+ is_enrolling_consumer_management_ =
+ consumer_management &&
+ consumer_management->GetEnrollmentStage() ==
+ policy::ConsumerManagementService::ENROLLMENT_STAGE_REQUESTED;
}
SigninScreenHandler::~SigninScreenHandler() {
- ash::Shell::GetInstance()->RemovePreTargetHandler(this);
+ OobeUI* oobe_ui = GetOobeUI();
+ if (oobe_ui && oobe_ui_observer_added_)
+ oobe_ui->RemoveObserver(this);
+ chromeos::input_method::ImeKeyboard* keyboard =
+ chromeos::input_method::InputMethodManager::Get()->GetImeKeyboard();
+ if (keyboard)
+ keyboard->RemoveObserver(this);
weak_factory_.InvalidateWeakPtrs();
if (delegate_)
delegate_->SetWebUIHandler(NULL);
network_state_informer_->RemoveObserver(this);
+ if (max_mode_delegate_) {
+ max_mode_delegate_->RemoveObserver(this);
+ max_mode_delegate_.reset(NULL);
+ }
+ ScreenlockBridge::Get()->SetLockHandler(NULL);
+ ScreenlockBridge::Get()->SetFocusedUser("");
}
void SigninScreenHandler::DeclareLocalizedValues(
IDS_MULTI_PROFILES_NOT_ALLOWED_POLICY_MSG);
builder->Add("multiProfilesPrimaryOnlyPolicyMsg",
IDS_MULTI_PROFILES_PRIMARY_ONLY_POLICY_MSG);
+ builder->Add("multiProfilesOwnerPrimaryOnlyMsg",
+ IDS_MULTI_PROFILES_OWNER_PRIMARY_ONLY_MSG);
// Strings used by password changed dialog.
builder->Add("passwordChangedTitle", IDS_LOGIN_PASSWORD_CHANGED_TITLE);
builder->Add("publicAccountInfoFormat", IDS_LOGIN_PUBLIC_ACCOUNT_INFO_FORMAT);
builder->Add("publicAccountReminder",
IDS_LOGIN_PUBLIC_ACCOUNT_SIGNOUT_REMINDER);
+ builder->Add("publicSessionLanguageAndInput",
+ IDS_LOGIN_PUBLIC_SESSION_LANGUAGE_AND_INPUT);
builder->Add("publicAccountEnter", IDS_LOGIN_PUBLIC_ACCOUNT_ENTER);
builder->Add("publicAccountEnterAccessibleName",
IDS_LOGIN_PUBLIC_ACCOUNT_ENTER_ACCESSIBLE_NAME);
- builder->AddF("removeUserWarningText",
- IDS_LOGIN_POD_USER_REMOVE_WARNING,
+ builder->Add("publicSessionSelectLanguage", IDS_LANGUAGE_SELECTION_SELECT);
+ builder->Add("publicSessionSelectKeyboard", IDS_KEYBOARD_SELECTION_SELECT);
+ builder->Add("removeUserWarningText",
+ base::string16());
+ builder->AddF("removeSupervisedUserWarningText",
+ IDS_LOGIN_POD_SUPERVISED_USER_REMOVE_WARNING,
base::UTF8ToUTF16(chrome::kSupervisedUserManagementDisplayURL));
builder->Add("removeUserWarningButtonTitle",
IDS_LOGIN_POD_USER_REMOVE_WARNING_BUTTON);
builder->Add("confirmPasswordText", IDS_LOGIN_CONFIRM_PASSWORD_TEXT);
builder->Add("confirmPasswordErrorText",
IDS_LOGIN_CONFIRM_PASSWORD_ERROR_TEXT);
- builder->Add("easyUnlockTooltip",
- IDS_LOGIN_EASY_UNLOCK_TOOLTIP);
builder->Add("fatalEnrollmentError",
IDS_ENTERPRISE_ENROLLMENT_AUTH_FATAL_ERROR);
+ builder->Add("insecureURLEnrollmentError",
+ IDS_ENTERPRISE_ENROLLMENT_AUTH_INSECURE_URL_ERROR);
if (chromeos::KioskModeSettings::Get()->IsKioskModeEnabled())
builder->Add("demoLoginMessage", IDS_KIOSK_MODE_LOGIN_MESSAGE);
-
- builder->Add("runType", CommandLine::ForCurrentProcess()->HasSwitch(
- switches::kFirstExecAfterBoot) ? "firstExecAfterBoot" :
- "notFirstExecAfterBoot");
}
void SigninScreenHandler::Show(const LoginScreenContext& context) {
// Just initialize internal fields from context and call ShowImpl().
oobe_ui_ = context.oobe_ui();
- if (!context.email().empty())
- email_ = context.email();
- else
- email_.clear();
+
+ std::string email;
+ if (is_enrolling_consumer_management_) {
+ // We don't check if the value of the owner e-mail is trusted because it is
+ // only used to pre-fill the e-mail field in Gaia sign-in page and a cached
+ // value is sufficient.
+ CrosSettings::Get()->GetString(kDeviceOwner, &email);
+ } else {
+ email = context.email();
+ }
+ gaia_screen_handler_->PopulateEmail(email);
ShowImpl();
}
}
void SigninScreenHandler::OnNetworkReady() {
- LOG(WARNING) << "OnNetworkReady() call.";
- MaybePreloadAuthExtension();
+ VLOG(1) << "OnNetworkReady() call.";
+ DCHECK(gaia_screen_handler_);
+ gaia_screen_handler_->MaybePreloadAuthExtension();
}
void SigninScreenHandler::UpdateState(ErrorScreenActor::ErrorReason reason) {
UpdateStateInternal(reason, false);
}
+void SigninScreenHandler::SetFocusPODCallbackForTesting(
+ base::Closure callback) {
+ test_focus_pod_callback_ = callback;
+}
+
// SigninScreenHandler, private: -----------------------------------------------
void SigninScreenHandler::ShowImpl() {
return;
}
- if (oobe_ui_) {
+ if (!ime_state_.get())
+ ime_state_ = input_method::InputMethodManager::Get()->GetActiveIMEState();
+
+ if (!oobe_ui_observer_added_) {
+ oobe_ui_observer_added_ = true;
+ GetOobeUI()->AddObserver(this);
+ }
+
+ if (oobe_ui_ || is_enrolling_consumer_management_) {
// Shows new user sign-in for OOBE.
- OnShowAddUser(email_);
+ OnShowAddUser();
} else {
// Populates account picker. Animation is turned off for now until we
// figure out how to make it fast enough.
- SendUserList(false);
+ delegate_->HandleGetUsers();
// Reset Caps Lock state when login screen is shown.
- input_method::InputMethodManager::Get()->GetXKeyboard()->
- SetCapsLockEnabled(false);
+ input_method::InputMethodManager::Get()
+ ->GetImeKeyboard()
+ ->SetCapsLockEnabled(false);
base::DictionaryValue params;
params.SetBoolean("disableAddUser", AllWhitelistedUsersPresent());
}
}
-// TODO (ygorshenin@): split this method into small parts.
-// TODO (ygorshenin@): move this logic to GaiaScreenHandler.
+// TODO(ygorshenin@): split this method into small parts.
+// TODO(ygorshenin@): move this logic to GaiaScreenHandler.
void SigninScreenHandler::UpdateStateInternal(
ErrorScreenActor::ErrorReason reason,
bool force_update) {
return;
}
- // TODO (ygorshenin@): switch log level to INFO once signin screen
- // will be tested well.
- LOG(WARNING) << "SigninScreenHandler::UpdateStateInternal(): "
- << "state=" << NetworkStateInformer::StatusString(state) << ", "
- << "network_name=" << network_name << ", "
- << "reason=" << ErrorScreenActor::ErrorReasonString(reason)
- << ", force_update=" << force_update;
update_state_closure_.Cancel();
if ((state == NetworkStateInformer::OFFLINE && !force_update) ||
is_online && last_network_state_ != NetworkStateInformer::ONLINE;
last_network_state_ = state;
+ CallOnReturn reload_gaia(base::Bind(
+ &SigninScreenHandler::ReloadGaia, weak_factory_.GetWeakPtr(), true));
+
if (is_online || !is_behind_captive_portal)
error_screen_actor_->HideCaptivePortal();
if (reason == ErrorScreenActor::ERROR_REASON_NETWORK_STATE_CHANGED &&
from_not_online_to_online_transition) {
// Schedules a immediate retry.
- LOG(WARNING) << "Retry page load since network has been changed.";
- ReloadGaiaScreen();
+ LOG(WARNING) << "Retry frame load since network has been changed.";
+ reload_gaia.ScheduleCall();
}
if (reason == ErrorScreenActor::ERROR_REASON_PROXY_CONFIG_CHANGED &&
error_screen_should_overlay) {
// Schedules a immediate retry.
- LOG(WARNING) << "Retry page load since proxy settings has been changed.";
- ReloadGaiaScreen();
+ LOG(WARNING) << "Retry frameload since proxy settings has been changed.";
+ reload_gaia.ScheduleCall();
}
if (reason == ErrorScreenActor::ERROR_REASON_FRAME_ERROR &&
!IsProxyError(state, reason, FrameError())) {
- LOG(WARNING) << "Retry page load due to reason: "
+ LOG(WARNING) << "Retry frame load due to reason: "
<< ErrorScreenActor::ErrorReasonString(reason);
- ReloadGaiaScreen();
+ reload_gaia.ScheduleCall();
+ }
+
+ if (is_gaia_loading_timeout) {
+ LOG(WARNING) << "Retry frame load due to loading timeout.";
+ reload_gaia.ScheduleCall();
}
if ((!is_online || is_gaia_loading_timeout || is_gaia_error) &&
// Forces a reload for Gaia screen on hiding error message.
if (IsGaiaVisible() || IsGaiaHiddenByError())
- ReloadGaiaScreen();
+ ReloadGaia(false);
}
-void SigninScreenHandler::ReloadGaiaScreen() {
- gaia_screen_handler_->ReloadGaia();
+void SigninScreenHandler::ReloadGaia(bool force_reload) {
+ gaia_screen_handler_->ReloadGaia(force_reload);
}
void SigninScreenHandler::Initialize() {
if (!delegate_)
return;
- // Make sure the event is processed by this before the IME.
- ash::Shell::GetInstance()->PrependPreTargetHandler(this);
-
if (show_on_init_) {
show_on_init_ = false;
ShowImpl();
}
void SigninScreenHandler::RegisterMessages() {
- AddCallback("usingSAMLAPI", &SigninScreenHandler::HandleUsingSAMLAPI);
- AddCallback("scrapedPasswordCount",
- &SigninScreenHandler::HandleScrapedPasswordCount);
- AddCallback("scrapedPasswordVerificationFailed",
- &SigninScreenHandler::HandleScrapedPasswordVerificationFailed);
AddCallback("authenticateUser", &SigninScreenHandler::HandleAuthenticateUser);
- AddCallback("completeLogin", &SigninScreenHandler::HandleCompleteLogin);
- AddCallback("completeAuthentication",
- &SigninScreenHandler::HandleCompleteAuthentication);
+ AddCallback("attemptUnlock", &SigninScreenHandler::HandleAttemptUnlock);
AddCallback("getUsers", &SigninScreenHandler::HandleGetUsers);
AddCallback("launchDemoUser", &SigninScreenHandler::HandleLaunchDemoUser);
AddCallback("launchIncognito", &SigninScreenHandler::HandleLaunchIncognito);
- AddCallback("showLocallyManagedUserCreationScreen",
- &SigninScreenHandler::HandleShowLocallyManagedUserCreationScreen);
- AddCallback("launchPublicAccount",
- &SigninScreenHandler::HandleLaunchPublicAccount);
+ AddCallback("showSupervisedUserCreationScreen",
+ &SigninScreenHandler::HandleShowSupervisedUserCreationScreen);
+ AddCallback("launchPublicSession",
+ &SigninScreenHandler::HandleLaunchPublicSession);
AddRawCallback("offlineLogin", &SigninScreenHandler::HandleOfflineLogin);
AddCallback("rebootSystem", &SigninScreenHandler::HandleRebootSystem);
AddRawCallback("showAddUser", &SigninScreenHandler::HandleShowAddUser);
&SigninScreenHandler::HandleToggleEnrollmentScreen);
AddCallback("toggleKioskEnableScreen",
&SigninScreenHandler::HandleToggleKioskEnableScreen);
- AddCallback("toggleResetScreen",
- &SigninScreenHandler::HandleToggleResetScreen);
AddCallback("createAccount", &SigninScreenHandler::HandleCreateAccount);
AddCallback("accountPickerReady",
&SigninScreenHandler::HandleAccountPickerReady);
AddCallback("wallpaperReady", &SigninScreenHandler::HandleWallpaperReady);
- AddCallback("loginWebuiReady", &SigninScreenHandler::HandleLoginWebuiReady);
AddCallback("signOutUser", &SigninScreenHandler::HandleSignOutUser);
- AddCallback("networkErrorShown",
- &SigninScreenHandler::HandleNetworkErrorShown);
AddCallback("openProxySettings",
&SigninScreenHandler::HandleOpenProxySettings);
AddCallback("loginVisible", &SigninScreenHandler::HandleLoginVisible);
AddCallback("updateOfflineLogin",
&SigninScreenHandler::HandleUpdateOfflineLogin);
AddCallback("focusPod", &SigninScreenHandler::HandleFocusPod);
- AddCallback("customButtonClicked",
- &SigninScreenHandler::HandleCustomButtonClicked);
+ AddCallback("hardlockPod", &SigninScreenHandler::HandleHardlockPod);
AddCallback("retrieveAuthenticatedUserEmail",
&SigninScreenHandler::HandleRetrieveAuthenticatedUserEmail);
+ AddCallback("getPublicSessionKeyboardLayouts",
+ &SigninScreenHandler::HandleGetPublicSessionKeyboardLayouts);
+ AddCallback("cancelConsumerManagementEnrollment",
+ &SigninScreenHandler::HandleCancelConsumerManagementEnrollment);
+ AddCallback("getTouchViewState",
+ &SigninScreenHandler::HandleGetTouchViewState);
+
// This message is sent by the kiosk app menu, but is handled here
// so we can tell the delegate to launch the app.
registry->RegisterDictionaryPref(prefs::kUsersLRUInputMethod);
}
+void SigninScreenHandler::OnCurrentScreenChanged(OobeUI::Screen current_screen,
+ OobeUI::Screen new_screen) {
+ if (new_screen == OobeUI::SCREEN_ACCOUNT_PICKER) {
+ // Restore active IME state if returning to user pod row screen.
+ input_method::InputMethodManager::Get()->SetState(ime_state_);
+ }
+}
+
+std::string SigninScreenHandler::GetUserLRUInputMethod(
+ const std::string& username) const {
+ PrefService* const local_state = g_browser_process->local_state();
+ const base::DictionaryValue* users_lru_input_methods =
+ local_state->GetDictionary(prefs::kUsersLRUInputMethod);
+
+ if (users_lru_input_methods == NULL) {
+ DLOG(WARNING) << "GetUserLRUInputMethod('" << username
+ << "'): no kUsersLRUInputMethod";
+ return std::string();
+ }
+
+ std::string input_method;
+
+ if (!users_lru_input_methods->GetStringWithoutPathExpansion(username,
+ &input_method)) {
+ DVLOG(0) << "GetUserLRUInputMethod('" << username
+ << "'): no input method for this user";
+ return std::string();
+ }
+
+ return input_method;
+}
+
void SigninScreenHandler::HandleGetUsers() {
- SendUserList(false);
+ if (delegate_)
+ delegate_->HandleGetUsers();
}
void SigninScreenHandler::ClearAndEnablePassword() {
core_oobe_actor_->RefocusCurrentPod();
}
-void SigninScreenHandler::OnLoginSuccess(const std::string& username) {
- core_oobe_actor_->OnLoginSuccess(username);
-}
-
void SigninScreenHandler::OnUserRemoved(const std::string& username) {
CallJS("login.AccountPickerScreen.removeUser", username);
if (delegate_->GetUsers().empty())
- OnShowAddUser("");
+ OnShowAddUser();
}
-void SigninScreenHandler::OnUserImageChanged(const User& user) {
+void SigninScreenHandler::OnUserImageChanged(const user_manager::User& user) {
if (page_is_ready())
CallJS("login.AccountPickerScreen.updateUserImage", user.email());
}
if (delegate_ && !delegate_->IsShowUsers()) {
HandleShowAddUser(NULL);
} else {
- SendUserList(false);
+ if (delegate_)
+ delegate_->HandleGetUsers();
UpdateUIState(UI_STATE_ACCOUNT_PICKER, NULL);
}
preferences_changed_delayed_ = false;
SetDelegate(NULL);
}
-void SigninScreenHandler::ShowBannerMessage(const std::string& message) {
- CallJS("login.AccountPickerScreen.showBannerMessage", message);
-}
-
-void SigninScreenHandler::ShowUserPodButton(
- const std::string& username,
- const std::string& iconURL,
- const base::Closure& click_callback) {
- user_pod_button_callback_map_[username] = click_callback;
- CallJS("login.AccountPickerScreen.showUserPodButton", username, iconURL);
-
- // TODO(tengs): Move this code once we move unlocking to native code.
- if (ScreenLocker::default_screen_locker()) {
- UserManager* user_manager = UserManager::Get();
- const User* user = user_manager->FindUser(username);
- if (!user)
- return;
- PrefService* profile_prefs =
- user_manager->GetProfileByUser(user)->GetPrefs();
- if (profile_prefs->GetBoolean(prefs::kEasyUnlockShowTutorial)) {
- CallJS("login.AccountPickerScreen.showEasyUnlockBubble");
- profile_prefs->SetBoolean(prefs::kEasyUnlockShowTutorial, false);
- }
- }
-}
-
-void SigninScreenHandler::HideUserPodButton(const std::string& username) {
- CallJS("login.AccountPickerScreen.hideUserPodButton", username);
-}
-
-void SigninScreenHandler::SetAuthType(const std::string& username,
- LoginDisplay::AuthType auth_type,
- const std::string& initial_value) {
- user_auth_type_map_[username] = auth_type;
- CallJS("login.AccountPickerScreen.setAuthType",
- username,
- static_cast<int>(auth_type),
- base::StringValue(initial_value));
-}
-
-LoginDisplay::AuthType SigninScreenHandler::GetAuthType(
- const std::string& username) const {
- if (user_auth_type_map_.find(username) == user_auth_type_map_.end())
- return LoginDisplay::OFFLINE_PASSWORD;
- return user_auth_type_map_.find(username)->second;
-}
-
void SigninScreenHandler::ShowError(int login_attempts,
const std::string& error_text,
const std::string& help_link_text,
}
void SigninScreenHandler::ShowGaiaPasswordChanged(const std::string& username) {
- email_ = username;
- password_changed_for_.insert(email_);
- core_oobe_actor_->ShowSignInUI(email_);
+ gaia_screen_handler_->PasswordChangedFor(username);
+ gaia_screen_handler_->PopulateEmail(username);
+ core_oobe_actor_->ShowSignInUI(username);
CallJS("login.setAuthType",
username,
- static_cast<int>(LoginDisplay::ONLINE_SIGN_IN),
+ static_cast<int>(ONLINE_SIGN_IN),
base::StringValue(""));
}
void SigninScreenHandler::ShowSigninScreenForCreds(
const std::string& username,
const std::string& password) {
- VLOG(2) << "ShowSigninScreenForCreds for user " << username
- << ", frame_state=" << FrameState();
-
- test_user_ = username;
- test_pass_ = password;
- test_expects_complete_login_ = true;
-
- // Submit login form for test if gaia is ready. If gaia is loading, login
- // will be attempted in HandleLoginWebuiReady after gaia is ready. Otherwise,
- // reload gaia then follow the loading case.
- if (FrameState() == GaiaScreenHandler::FRAME_STATE_LOADED)
- SubmitLoginFormForTest();
- else if (FrameState() != GaiaScreenHandler::FRAME_STATE_LOADING)
- HandleShowAddUser(NULL);
+ DCHECK(gaia_screen_handler_);
+ gaia_screen_handler_->ShowSigninScreenForCreds(username, password);
}
-void SigninScreenHandler::OnCookiesCleared(base::Closure on_clear_callback) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
- cookies_cleared_ = true;
- on_clear_callback.Run();
+void SigninScreenHandler::SetPublicSessionDisplayName(
+ const std::string& user_id,
+ const std::string& display_name) {
+ CallJS("login.AccountPickerScreen.setPublicSessionDisplayName",
+ user_id,
+ display_name);
}
-void SigninScreenHandler::OnKeyEvent(ui::KeyEvent* key) {
- if (key->type() == ui::ET_KEY_PRESSED &&
- key->key_code() == ui::VKEY_CAPITAL) {
- caps_lock_enabled_ = !caps_lock_enabled_;
- if (page_is_ready())
- CallJS("login.AccountPickerScreen.setCapsLockState", caps_lock_enabled_);
- }
+void SigninScreenHandler::SetPublicSessionLocales(
+ const std::string& user_id,
+ scoped_ptr<base::ListValue> locales,
+ const std::string& default_locale,
+ bool multipleRecommendedLocales) {
+ CallJS("login.AccountPickerScreen.setPublicSessionLocales",
+ user_id,
+ *locales,
+ default_locale,
+ multipleRecommendedLocales);
}
void SigninScreenHandler::Observe(int type,
has_pending_auth_ui_ = false;
// Reload auth extension as proxy credentials are supplied.
if (!IsSigninScreenHiddenByError() && ui_state_ == UI_STATE_GAIA_SIGNIN)
- ReloadGaiaScreen();
+ ReloadGaia(true);
update_state_closure_.Cancel();
break;
case chrome::NOTIFICATION_AUTH_CANCELLED: {
}
}
-void SigninScreenHandler::OnDnsCleared() {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
- dns_clear_task_running_ = false;
- dns_cleared_ = true;
- ShowSigninScreenIfReady();
+void SigninScreenHandler::ShowBannerMessage(const base::string16& message) {
+ CallJS("login.AccountPickerScreen.showBannerMessage", message);
}
-// Update keyboard layout to least recently used by the user.
-void SigninScreenHandler::SetUserInputMethod(const std::string& username) {
- UserManager* user_manager = UserManager::Get();
- if (user_manager->IsUserLoggedIn()) {
- // We are on sign-in screen inside user session (adding new user to
- // the session or on lock screen), don't switch input methods in this case.
- // TODO(dpolukhin): adding user and sign-in should be consistent
- // crbug.com/292774
+void SigninScreenHandler::ShowUserPodCustomIcon(
+ const std::string& username,
+ const ScreenlockBridge::UserPodCustomIconOptions& icon_options) {
+ scoped_ptr<base::DictionaryValue> icon = icon_options.ToDictionaryValue();
+ if (!icon || icon->empty())
return;
- }
+ CallJS("login.AccountPickerScreen.showUserPodCustomIcon", username, *icon);
+}
- chromeos::input_method::InputMethodManager* const manager =
- chromeos::input_method::InputMethodManager::Get();
+void SigninScreenHandler::HideUserPodCustomIcon(const std::string& username) {
+ CallJS("login.AccountPickerScreen.hideUserPodCustomIcon", username);
+}
- const bool succeed = SetUserInputMethodImpl(username, manager);
+void SigninScreenHandler::EnableInput() {
+ // Only for lock screen at the moment.
+ ScreenLocker::default_screen_locker()->EnableInput();
+}
- // This is also a case when LRU layout is set only for a few local users,
- // thus others need to be switched to default locale.
- // Otherwise they will end up using another user's locale to log in.
- if (!succeed) {
- DVLOG(0) << "SetUserInputMethod('" << username
- << "'): failed to set user layout. Switching to default.";
+void SigninScreenHandler::SetAuthType(
+ const std::string& username,
+ ScreenlockBridge::LockHandler::AuthType auth_type,
+ const base::string16& initial_value) {
+ if (delegate_->GetAuthType(username) ==
+ ScreenlockBridge::LockHandler::FORCE_OFFLINE_PASSWORD)
+ return;
- manager->SetInputMethodLoginDefault();
- }
+ delegate_->SetAuthType(username, auth_type);
+
+ CallJS("login.AccountPickerScreen.setAuthType",
+ username,
+ static_cast<int>(auth_type),
+ base::StringValue(initial_value));
}
-void SigninScreenHandler::ShowSigninScreenIfReady() {
- LOG(WARNING) << "ShowSigninScreenIfReady() call.";
+ScreenlockBridge::LockHandler::AuthType SigninScreenHandler::GetAuthType(
+ const std::string& username) const {
+ return delegate_->GetAuthType(username);
+}
- if (!dns_cleared_ || !cookies_cleared_ || !delegate_)
+void SigninScreenHandler::Unlock(const std::string& user_email) {
+ DCHECK(ScreenLocker::default_screen_locker());
+ ScreenLocker::Hide();
+}
+
+void SigninScreenHandler::AttemptEasySignin(const std::string& user_email,
+ const std::string& secret,
+ const std::string& key_label) {
+ DCHECK(!ScreenLocker::default_screen_locker());
+ if (!delegate_)
return;
- std::string active_network_path = network_state_informer_->network_path();
- if (gaia_silent_load_ &&
- (network_state_informer_->state() != NetworkStateInformer::ONLINE ||
- gaia_silent_load_network_ != active_network_path)) {
- // Network has changed. Force Gaia reload.
- gaia_silent_load_ = false;
- // Gaia page will be realoded, so focus isn't stolen anymore.
- focus_stolen_ = false;
- }
+ UserContext user_context(user_email);
+ user_context.SetAuthFlow(UserContext::AUTH_FLOW_EASY_UNLOCK);
+ user_context.SetKey(Key(secret));
+ user_context.GetKey()->SetLabel(key_label);
- // Note that LoadAuthExtension clears |email_|.
- if (email_.empty())
- delegate_->LoadSigninWallpaper();
- else
- delegate_->LoadWallpaper(email_);
+ // TODO(tbarzic): Handle empty secret. The delegate will end up ignoring login
+ // attempt if the key is not set, and the UI will remain disabled.
+ DCHECK(!secret.empty());
- // Set Least Recently Used input method for the user.
- if (!email_.empty())
- SetUserInputMethod(email_);
+ delegate_->Login(user_context, SigninSpecifics());
+}
- LoadAuthExtension(!gaia_silent_load_, false, false);
- UpdateUIState(UI_STATE_GAIA_SIGNIN, NULL);
+void SigninScreenHandler::OnMaximizeModeStarted() {
+ CallJS("login.AccountPickerScreen.setTouchViewState", true);
+}
- if (gaia_silent_load_) {
- // The variable is assigned to false because silently loaded Gaia page was
- // used.
- gaia_silent_load_ = false;
- if (focus_stolen_)
- HandleLoginWebuiReady();
- }
+void SigninScreenHandler::OnMaximizeModeEnded() {
+ CallJS("login.AccountPickerScreen.setTouchViewState", false);
+}
- UpdateState(ErrorScreenActor::ERROR_REASON_UPDATE);
+bool SigninScreenHandler::ShouldLoadGaia() const {
+ // Fetching of the extension is not started before account picker page is
+ // loaded because it can affect the loading speed.
+ // Do not load the extension for the screen locker, see crosbug.com/25018.
+ return !ScreenLocker::default_screen_locker() &&
+ is_account_picker_showing_first_time_;
}
-void SigninScreenHandler::LoadAuthExtension(
- bool force, bool silent_load, bool offline) {
- GaiaContext context;
- context.force_reload = force;
- context.is_local = offline;
- context.password_changed =
- !email_.empty() && password_changed_for_.count(email_);
- if (delegate_)
- context.show_users = delegate_->IsShowUsers();
- context.use_offline = offline;
- if (delegate_)
- context.has_users = !delegate_->GetUsers().empty();
- context.email = email_;
+// Update keyboard layout to least recently used by the user.
+void SigninScreenHandler::SetUserInputMethod(
+ const std::string& username,
+ input_method::InputMethodManager::State* ime_state) {
+ bool succeed = false;
- email_.clear();
+ const std::string input_method = GetUserLRUInputMethod(username);
- DCHECK(gaia_screen_handler_);
- gaia_screen_handler_->LoadGaia(context);
+ if (!input_method.empty())
+ succeed = SetUserInputMethodImpl(username, input_method, ime_state);
+
+ // This is also a case when LRU layout is set only for a few local users,
+ // thus others need to be switched to default locale.
+ // Otherwise they will end up using another user's locale to log in.
+ if (!succeed) {
+ DVLOG(0) << "SetUserInputMethod('" << username
+ << "'): failed to set user layout. Switching to default.";
+
+ ime_state->SetInputMethodLoginDefault();
+ }
}
+
void SigninScreenHandler::UserSettingsChanged() {
DCHECK(gaia_screen_handler_);
GaiaContext context;
AllWhitelistedUsersPresent());
}
-void SigninScreenHandler::HandleUsingSAMLAPI() {
- SetSAMLPrincipalsAPIUsed(true);
-}
-
-void SigninScreenHandler::HandleScrapedPasswordCount(int password_count) {
- SetSAMLPrincipalsAPIUsed(false);
- // Use a histogram that has 11 buckets, one for each of the values in [0, 9]
- // and an overflow bucket at the end.
- UMA_HISTOGRAM_ENUMERATION(
- "ChromeOS.SAML.Scraping.PasswordCount", std::min(password_count, 10), 11);
- if (password_count == 0)
- HandleScrapedPasswordVerificationFailed();
-}
-
-void SigninScreenHandler::HandleScrapedPasswordVerificationFailed() {
- RecordSAMLScrapingVerificationResultInHistogram(false);
-}
-
-void SigninScreenHandler::HandleCompleteLogin(const std::string& typed_email,
- const std::string& password,
- bool using_saml) {
- if (!delegate_)
- return;
-
- if (using_saml && !using_saml_api_)
- RecordSAMLScrapingVerificationResultInHistogram(true);
-
- const std::string sanitized_email = gaia::SanitizeEmail(typed_email);
- delegate_->SetDisplayEmail(sanitized_email);
- delegate_->CompleteLogin(UserContext(
- sanitized_email,
- password,
- std::string(), // auth_code
- std::string(), // username_hash
- true, // using_oauth
- using_saml ? UserContext::AUTH_FLOW_GAIA_WITH_SAML
- : UserContext::AUTH_FLOW_GAIA_WITHOUT_SAML));
-
- if (test_expects_complete_login_) {
- VLOG(2) << "Complete test login for " << typed_email
- << ", requested=" << test_user_;
-
- test_expects_complete_login_ = false;
- test_user_.clear();
- test_pass_.clear();
- }
-}
-
-void SigninScreenHandler::HandleCompleteAuthentication(
- const std::string& email,
- const std::string& password,
- const std::string& auth_code) {
+void SigninScreenHandler::HandleAuthenticateUser(const std::string& username,
+ const std::string& password) {
if (!delegate_)
return;
- const std::string sanitized_email = gaia::SanitizeEmail(email);
- delegate_->SetDisplayEmail(sanitized_email);
- delegate_->CompleteLogin(UserContext(sanitized_email, password, auth_code));
+ UserContext user_context(username);
+ user_context.SetKey(Key(password));
+ delegate_->Login(user_context, SigninSpecifics());
}
-void SigninScreenHandler::HandleAuthenticateUser(const std::string& username,
- const std::string& password) {
- if (!delegate_)
+void SigninScreenHandler::HandleAttemptUnlock(const std::string& username) {
+ EasyUnlockService* service = GetEasyUnlockServiceForUser(username);
+ if (!service)
return;
- delegate_->Login(UserContext(gaia::SanitizeEmail(username),
- password,
- std::string())); // auth_code
+ service->AttemptAuth(username);
}
void SigninScreenHandler::HandleLaunchDemoUser() {
+ UserContext context(user_manager::USER_TYPE_RETAIL_MODE, std::string());
if (delegate_)
- delegate_->LoginAsRetailModeUser();
+ delegate_->Login(context, SigninSpecifics());
}
void SigninScreenHandler::HandleLaunchIncognito() {
+ UserContext context(user_manager::USER_TYPE_GUEST, std::string());
if (delegate_)
- delegate_->LoginAsGuest();
+ delegate_->Login(context, SigninSpecifics());
}
-void SigninScreenHandler::HandleShowLocallyManagedUserCreationScreen() {
- if (!UserManager::Get()->AreLocallyManagedUsersAllowed()) {
+void SigninScreenHandler::HandleShowSupervisedUserCreationScreen() {
+ if (!user_manager::UserManager::Get()->AreSupervisedUsersAllowed()) {
LOG(ERROR) << "Managed users not allowed.";
return;
}
scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
LoginDisplayHostImpl::default_host()->
- StartWizard(WizardController::kLocallyManagedUserCreationScreenName,
+ StartWizard(WizardController::kSupervisedUserCreationScreenName,
params.Pass());
}
-void SigninScreenHandler::HandleLaunchPublicAccount(
- const std::string& username) {
- if (delegate_)
- delegate_->LoginAsPublicAccount(username);
+void SigninScreenHandler::HandleLaunchPublicSession(
+ const std::string& user_id,
+ const std::string& locale,
+ const std::string& input_method) {
+ if (!delegate_)
+ return;
+
+ UserContext context(user_manager::USER_TYPE_PUBLIC_ACCOUNT, user_id);
+ context.SetPublicSessionLocale(locale),
+ context.SetPublicSessionInputMethod(input_method);
+ delegate_->Login(context, SigninSpecifics());
}
void SigninScreenHandler::HandleOfflineLogin(const base::ListValue* args) {
NOTREACHED();
return;
}
- if (!args->GetString(0, &email_))
- email_.clear();
+ std::string email;
+ args->GetString(0, &email);
+
+ gaia_screen_handler_->PopulateEmail(email);
// Load auth extension. Parameters are: force reload, do not load extension in
// background, use offline version.
- LoadAuthExtension(true, false, true);
+ gaia_screen_handler_->LoadAuthExtension(true, false, true);
UpdateUIState(UI_STATE_GAIA_SIGNIN, NULL);
}
// |args| can be null if it's OOBE.
if (args)
args->GetString(0, &email);
- OnShowAddUser(email);
+ gaia_screen_handler_->PopulateEmail(email);
+ OnShowAddUser();
}
void SigninScreenHandler::HandleToggleEnrollmentScreen() {
}
}
-void SigninScreenHandler::HandleToggleResetScreen() {
- policy::BrowserPolicyConnectorChromeOS* connector =
- g_browser_process->platform_part()->browser_policy_connector_chromeos();
- if (delegate_ && !connector->IsEnterpriseManaged())
- delegate_->ShowResetScreen();
-}
-
void SigninScreenHandler::HandleToggleKioskAutolaunchScreen() {
policy::BrowserPolicyConnectorChromeOS* connector =
g_browser_process->platform_part()->browser_policy_connector_chromeos();
delegate_->ShowKioskAutolaunchScreen();
}
-void SigninScreenHandler::FillUserDictionary(User* user,
- bool is_owner,
- bool is_signin_to_add,
- LoginDisplay::AuthType auth_type,
- base::DictionaryValue* user_dict) {
- const std::string& email = user->email();
- const bool is_public_account =
- user->GetType() == User::USER_TYPE_PUBLIC_ACCOUNT;
- const bool is_locally_managed_user =
- user->GetType() == User::USER_TYPE_LOCALLY_MANAGED;
-
- user_dict->SetString(kKeyUsername, email);
- user_dict->SetString(kKeyEmailAddress, user->display_email());
- user_dict->SetString(kKeyDisplayName, user->GetDisplayName());
- user_dict->SetBoolean(kKeyPublicAccount, is_public_account);
- user_dict->SetBoolean(kKeyLocallyManagedUser, is_locally_managed_user);
- user_dict->SetInteger(kKeyInitialAuthType, auth_type);
- user_dict->SetBoolean(kKeySignedIn, user->is_logged_in());
- user_dict->SetBoolean(kKeyIsOwner, is_owner);
-
- // Fill in multi-profiles related fields.
- if (is_signin_to_add) {
- MultiProfileUserController* multi_profile_user_controller =
- UserManager::Get()->GetMultiProfileUserController();
- std::string behavior = multi_profile_user_controller->
- GetCachedValue(user->email());
- user_dict->SetBoolean(kKeyMultiProfilesAllowed,
- multi_profile_user_controller->IsUserAllowedInSession(email) ==
- MultiProfileUserController::ALLOWED);
- user_dict->SetString(kKeyMultiProfilesPolicy, behavior);
- } else {
- user_dict->SetBoolean(kKeyMultiProfilesAllowed, true);
- }
-
- if (is_public_account) {
- policy::BrowserPolicyConnectorChromeOS* policy_connector =
- g_browser_process->platform_part()->browser_policy_connector_chromeos();
-
- if (policy_connector->IsEnterpriseManaged()) {
- user_dict->SetString(kKeyEnterpriseDomain,
- policy_connector->GetEnterpriseDomain());
- }
- }
-}
-
-void SigninScreenHandler::SendUserList(bool animated) {
- if (!delegate_)
- return;
- TRACE_EVENT_ASYNC_STEP_INTO0("ui",
- "ShowLoginWebUI",
- LoginDisplayHostImpl::kShowLoginWebUIid,
- "SendUserList");
- BootTimesLoader::Get()->RecordCurrentStats("login-send-user-list");
-
- base::ListValue users_list;
- const UserList& users = delegate_->GetUsers();
-
- // TODO(nkostylev): Move to a separate method in UserManager.
- // http://crbug.com/230852
- bool is_signin_to_add = LoginDisplayHostImpl::default_host() &&
- UserManager::Get()->IsUserLoggedIn();
-
- user_pod_button_callback_map_.clear();
- user_auth_type_map_.clear();
-
- bool single_user = users.size() == 1;
- std::string owner;
- chromeos::CrosSettings::Get()->GetString(chromeos::kDeviceOwner, &owner);
- bool has_owner = owner.size() > 0;
- size_t max_non_owner_users = has_owner ? kMaxUsers - 1 : kMaxUsers;
- size_t non_owner_count = 0;
- policy::BrowserPolicyConnectorChromeOS* connector =
- g_browser_process->platform_part()->
- browser_policy_connector_chromeos();
- bool is_enterprise_managed = connector->IsEnterpriseManaged();
-
-
- for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
- const std::string& email = (*it)->email();
- bool is_owner = (email == owner);
- bool is_public_account =
- ((*it)->GetType() == User::USER_TYPE_PUBLIC_ACCOUNT);
-
- if ((is_public_account && !is_signin_to_add) ||
- is_owner ||
- (!is_public_account && non_owner_count < max_non_owner_users)) {
- LoginDisplay::AuthType initial_auth_type =
- ShouldForceOnlineSignIn(*it) ? LoginDisplay::ONLINE_SIGN_IN
- : LoginDisplay::OFFLINE_PASSWORD;
- user_auth_type_map_[email] = initial_auth_type;
-
- base::DictionaryValue* user_dict = new base::DictionaryValue();
- FillUserDictionary(
- *it, is_owner, is_signin_to_add, initial_auth_type, user_dict);
- bool signed_in = (*it)->is_logged_in();
- // Single user check here is necessary because owner info might not be
- // available when running into login screen on first boot.
- // See http://crosbug.com/12723
- bool can_remove_user = ((!single_user || is_enterprise_managed) &&
- !email.empty() && !is_owner && !is_public_account &&
- !signed_in && !is_signin_to_add);
- user_dict->SetBoolean(kKeyCanRemove, can_remove_user);
-
- if (!is_owner)
- ++non_owner_count;
- if (is_owner && users_list.GetSize() > kMaxUsers) {
- // Owner is always in the list.
- users_list.Insert(kMaxUsers - 1, user_dict);
- } else {
- users_list.Append(user_dict);
- }
- }
- }
- while (users_list.GetSize() > kMaxUsers)
- users_list.Remove(kMaxUsers, NULL);
-
- CallJS("login.AccountPickerScreen.loadUsers", users_list, animated,
+void SigninScreenHandler::LoadUsers(const base::ListValue& users_list,
+ bool showGuest) {
+ CallJS("login.AccountPickerScreen.loadUsers",
+ users_list,
delegate_->IsShowGuest());
}
PrefService* prefs = g_browser_process->local_state();
if (prefs->GetBoolean(prefs::kFactoryResetRequested)) {
- HandleToggleResetScreen();
- return;
+ if (core_oobe_actor_) {
+ core_oobe_actor_->ShowDeviceResetScreen();
+ return;
+ }
}
is_account_picker_showing_first_time_ = true;
- MaybePreloadAuthExtension();
+ gaia_screen_handler_->MaybePreloadAuthExtension();
- if (ScreenLocker::default_screen_locker())
+ ScreenlockBridge::Get()->SetLockHandler(this);
+ if (ScreenLocker::default_screen_locker()) {
ScreenLocker::default_screen_locker()->delegate()->OnLockWebUIReady();
+ }
if (delegate_)
delegate_->OnSigninScreenReady();
}
}
-void SigninScreenHandler::HandleLoginWebuiReady() {
- if (focus_stolen_) {
- // Set focus to the Gaia page.
- // TODO(altimofeev): temporary solution, until focus parameters are
- // implemented on the Gaia side.
- // Do this only once. Any subsequent call would relod GAIA frame.
- focus_stolen_ = false;
- const char code[] =
- "if (typeof gWindowOnLoad != 'undefined') gWindowOnLoad();";
- content::RenderFrameHost* frame =
- LoginDisplayHostImpl::GetGaiaAuthIframe(web_ui()->GetWebContents());
- frame->ExecuteJavaScript(base::ASCIIToUTF16(code));
- }
- if (!gaia_silent_load_) {
- content::NotificationService::current()->Notify(
- chrome::NOTIFICATION_LOGIN_WEBUI_LOADED,
- content::NotificationService::AllSources(),
- content::NotificationService::NoDetails());
- } else {
- focus_stolen_ = true;
- // Prevent focus stealing by the Gaia page.
- // TODO(altimofeev): temporary solution, until focus parameters are
- // implemented on the Gaia side.
- const char code[] = "var gWindowOnLoad = window.onload; "
- "window.onload=function() {};";
- content::RenderFrameHost* frame =
- LoginDisplayHostImpl::GetGaiaAuthIframe(web_ui()->GetWebContents());
- frame->ExecuteJavaScript(base::ASCIIToUTF16(code));
- // As we could miss and window.onload could already be called, restore
- // focus to current pod (see crbug/175243).
- RefocusCurrentPod();
- }
- DCHECK(gaia_screen_handler_);
- gaia_screen_handler_->HandleFrameLoadingCompleted(0);
-
- if (test_expects_complete_login_)
- SubmitLoginFormForTest();
-}
-
void SigninScreenHandler::HandleSignOutUser() {
if (delegate_)
delegate_->Signout();
}
-void SigninScreenHandler::HandleNetworkErrorShown() {
- content::NotificationService::current()->Notify(
- chrome::NOTIFICATION_LOGIN_NETWORK_ERROR_SHOWN,
- content::NotificationService::AllSources(),
- content::NotificationService::NoDetails());
-}
-
void SigninScreenHandler::HandleCreateAccount() {
if (delegate_)
delegate_->CreateAccount();
}
void SigninScreenHandler::HandleLoginVisible(const std::string& source) {
- LOG(WARNING) << "Login WebUI >> loginVisible, src: " << source << ", "
- << "webui_visible_: " << webui_visible_;
+ VLOG(1) << "Login WebUI >> loginVisible, src: " << source << ", "
+ << "webui_visible_: " << webui_visible_;
if (!webui_visible_) {
// There might be multiple messages from OOBE UI so send notifications after
// the first one only.
}
void SigninScreenHandler::HandleCancelPasswordChangedFlow() {
- StartClearingCookies(base::Bind(
- &SigninScreenHandler::CancelPasswordChangedFlowInternal,
- weak_factory_.GetWeakPtr()));
+ gaia_screen_handler_->StartClearingCookies(
+ base::Bind(&SigninScreenHandler::CancelPasswordChangedFlowInternal,
+ weak_factory_.GetWeakPtr()));
}
void SigninScreenHandler::HandleCancelUserAdding() {
}
void SigninScreenHandler::HandleUnlockOnLoginSuccess() {
- DCHECK(UserManager::Get()->IsUserLoggedIn());
+ DCHECK(user_manager::UserManager::Get()->IsUserLoggedIn());
if (ScreenLocker::default_screen_locker())
ScreenLocker::default_screen_locker()->UnlockOnLoginSuccess();
}
}
void SigninScreenHandler::HandleFocusPod(const std::string& user_id) {
- SetUserInputMethod(user_id);
+ SetUserInputMethod(user_id, ime_state_.get());
+#if !defined(USE_ATHENA)
+ // TODO(dpolukhin): crbug.com/408734.
WallpaperManager::Get()->SetUserWallpaperDelayed(user_id);
+#endif
+ ScreenlockBridge::Get()->SetFocusedUser(user_id);
+ if (!test_focus_pod_callback_.is_null())
+ test_focus_pod_callback_.Run();
}
-void SigninScreenHandler::HandleCustomButtonClicked(
- const std::string& username) {
- if (user_pod_button_callback_map_.find(username)
- == user_pod_button_callback_map_.end()) {
- LOG(WARNING) << "User pod custom button clicked but no callback found";
+void SigninScreenHandler::HandleHardlockPod(const std::string& user_id) {
+ SetAuthType(user_id,
+ ScreenlockBridge::LockHandler::OFFLINE_PASSWORD,
+ base::string16());
+ EasyUnlockService* service = GetEasyUnlockServiceForUser(user_id);
+ if (!service)
return;
- }
- user_pod_button_callback_map_[username].Run();
+ service->SetHardlockState(EasyUnlockScreenlockStateHandler::USER_HARDLOCK);
}
void SigninScreenHandler::HandleRetrieveAuthenticatedUserEmail(
double attempt_token) {
+ // TODO(antrim) : move GaiaSigninScreen dependency to GaiaSigninScreen.
email_retriever_.reset(new AuthenticatedUserEmailRetriever(
base::Bind(&SigninScreenHandler::CallJS<double, std::string>,
base::Unretained(this),
Profile::FromWebUI(web_ui())->GetRequestContext()));
}
-void SigninScreenHandler::HandleLaunchKioskApp(const std::string& app_id,
- bool diagnostic_mode) {
- delegate_->LoginAsKioskApp(app_id, diagnostic_mode);
+void SigninScreenHandler::HandleGetPublicSessionKeyboardLayouts(
+ const std::string& user_id,
+ const std::string& locale) {
+ GetKeyboardLayoutsForLocale(
+ base::Bind(&SigninScreenHandler::SendPublicSessionKeyboardLayouts,
+ weak_factory_.GetWeakPtr(),
+ user_id,
+ locale),
+ locale);
}
-void SigninScreenHandler::StartClearingDnsCache() {
- if (dns_clear_task_running_ || !g_browser_process->io_thread())
- return;
-
- dns_cleared_ = false;
- BrowserThread::PostTaskAndReply(
- BrowserThread::IO, FROM_HERE,
- base::Bind(&ClearDnsCache, g_browser_process->io_thread()),
- base::Bind(&SigninScreenHandler::OnDnsCleared,
- weak_factory_.GetWeakPtr()));
- dns_clear_task_running_ = true;
+void SigninScreenHandler::SendPublicSessionKeyboardLayouts(
+ const std::string& user_id,
+ const std::string& locale,
+ scoped_ptr<base::ListValue> keyboard_layouts) {
+ CallJS("login.AccountPickerScreen.setPublicSessionKeyboardLayouts",
+ user_id,
+ locale,
+ *keyboard_layouts);
}
-void SigninScreenHandler::StartClearingCookies(
- const base::Closure& on_clear_callback) {
- cookies_cleared_ = false;
- ProfileHelper* profile_helper =
- g_browser_process->platform_part()->profile_helper();
- LOG_ASSERT(
- Profile::FromWebUI(web_ui()) == profile_helper->GetSigninProfile());
- profile_helper->ClearSigninProfile(base::Bind(
- &SigninScreenHandler::OnCookiesCleared,
- weak_factory_.GetWeakPtr(), on_clear_callback));
+void SigninScreenHandler::HandleLaunchKioskApp(const std::string& app_id,
+ bool diagnostic_mode) {
+ UserContext context(user_manager::USER_TYPE_KIOSK_APP, app_id);
+ SigninSpecifics specifics;
+ specifics.kiosk_diagnostic_mode = diagnostic_mode;
+ if (delegate_)
+ delegate_->Login(context, specifics);
}
-void SigninScreenHandler::MaybePreloadAuthExtension() {
- LOG(WARNING) << "MaybePreloadAuthExtension() call.";
+void SigninScreenHandler::HandleCancelConsumerManagementEnrollment() {
+ policy::ConsumerManagementService* consumer_management =
+ g_browser_process->platform_part()->browser_policy_connector_chromeos()->
+ GetConsumerManagementService();
+ CHECK(consumer_management);
+ consumer_management->SetEnrollmentStage(
+ policy::ConsumerManagementService::ENROLLMENT_STAGE_CANCELED);
+ is_enrolling_consumer_management_ = false;
+ ShowImpl();
+}
- // Fetching of the extension is not started before account picker page is
- // loaded because it can affect the loading speed. Also if cookies clearing
- // was initiated or |dns_clear_task_running_| then auth extension showing has
- // already been initiated and preloading is senseless.
- // Do not load the extension for the screen locker, see crosbug.com/25018.
- if (is_account_picker_showing_first_time_ &&
- !gaia_silent_load_ &&
- !ScreenLocker::default_screen_locker() &&
- !cookies_cleared_ &&
- !dns_clear_task_running_ &&
- network_state_informer_->state() == NetworkStateInformer::ONLINE) {
- gaia_silent_load_ = true;
- gaia_silent_load_network_ = network_state_informer_->network_path();
- LoadAuthExtension(true, true, false);
+void SigninScreenHandler::HandleGetTouchViewState() {
+ if (max_mode_delegate_) {
+ CallJS("login.AccountPickerScreen.setTouchViewState",
+ max_mode_delegate_->IsMaximizeModeEnabled());
}
}
cros_settings->GetBoolean(kAccountsPrefAllowNewUser, &allow_new_user);
if (allow_new_user)
return false;
- UserManager* user_manager = UserManager::Get();
- const UserList& users = user_manager->GetUsers();
+ user_manager::UserManager* user_manager = user_manager::UserManager::Get();
+ const user_manager::UserList& users = user_manager->GetUsers();
if (!delegate_ || users.size() > kMaxUsers) {
return false;
}
}
}
+OobeUI* SigninScreenHandler::GetOobeUI() const {
+ return static_cast<OobeUI*>(web_ui()->GetController());
+}
+
+EasyUnlockService* SigninScreenHandler::GetEasyUnlockServiceForUser(
+ const std::string& username) const {
+ if (!ScreenLocker::default_screen_locker() &&
+ GetOobeUI()->display_type() != OobeUI::kLoginDisplay)
+ return NULL;
+
+ const user_manager::User* unlock_user = NULL;
+ const user_manager::UserList& users = delegate_->GetUsers();
+ for (user_manager::UserList::const_iterator it = users.begin();
+ it != users.end();
+ ++it) {
+ if ((*it)->email() == username) {
+ unlock_user = *it;
+ break;
+ }
+ }
+ if (!unlock_user)
+ return NULL;
+
+ ProfileHelper* profile_helper = ProfileHelper::Get();
+ Profile* profile = profile_helper->GetProfileByUser(unlock_user);
+
+ // The user profile should exists if and only if this is lock screen.
+ DCHECK_NE(!profile, !ScreenLocker::default_screen_locker());
+
+ if (!profile)
+ profile = profile_helper->GetSigninProfile();
+
+ return EasyUnlockService::Get(profile);
+}
+
OobeUI::Screen SigninScreenHandler::GetCurrentScreen() const {
OobeUI::Screen screen = OobeUI::SCREEN_UNKNOWN;
- OobeUI* oobe_ui = static_cast<OobeUI*>(web_ui()->GetController());
+ OobeUI* oobe_ui = GetOobeUI();
if (oobe_ui)
screen = oobe_ui->current_screen();
return screen;
return !show_pods;
}
-void SigninScreenHandler::SubmitLoginFormForTest() {
- VLOG(2) << "Submit login form for test, user=" << test_user_;
-
- std::string code;
- code += "document.getElementById('Email').value = '" + test_user_ + "';";
- code += "document.getElementById('Passwd').value = '" + test_pass_ + "';";
- code += "document.getElementById('signIn').click();";
-
- content::RenderFrameHost* frame =
- LoginDisplayHostImpl::GetGaiaAuthIframe(web_ui()->GetWebContents());
- frame->ExecuteJavaScript(base::ASCIIToUTF16(code));
-
- // Test properties are cleared in HandleCompleteLogin because the form
- // submission might fail and login will not be attempted after reloading
- // if they are cleared here.
-}
-
void SigninScreenHandler::ContinueKioskEnableFlow(
policy::AutoEnrollmentState state) {
// Do not proceed with kiosk enable when auto enroll will be enforced.
auto_enrollment_progress_subscription_.reset();
}
-void SigninScreenHandler::OnShowAddUser(const std::string& email) {
- email_ = email;
+void SigninScreenHandler::OnShowAddUser() {
is_account_picker_showing_first_time_ = false;
-
- if (gaia_silent_load_ && email_.empty()) {
- dns_cleared_ = true;
- cookies_cleared_ = true;
- ShowSigninScreenIfReady();
- } else {
- LOG(ERROR) << "OnShowAddUser 2";
- StartClearingDnsCache();
- StartClearingCookies(base::Bind(
- &SigninScreenHandler::ShowSigninScreenIfReady,
- weak_factory_.GetWeakPtr()));
- }
-}
-
-void SigninScreenHandler::SetSAMLPrincipalsAPIUsed(bool api_used) {
- using_saml_api_ = api_used;
- UMA_HISTOGRAM_BOOLEAN("ChromeOS.SAML.APIUsed", api_used);
+ DCHECK(gaia_screen_handler_);
+ gaia_screen_handler_->ShowGaia(is_enrolling_consumer_management_);
}
GaiaScreenHandler::FrameState SigninScreenHandler::FrameState() const {
return gaia_screen_handler_->frame_error();
}
+void SigninScreenHandler::OnCapsLockChanged(bool enabled) {
+ caps_lock_enabled_ = enabled;
+ if (page_is_ready())
+ CallJS("login.AccountPickerScreen.setCapsLockState", caps_lock_enabled_);
+}
+
} // namespace chromeos
projects / platform / framework / web / crosswalk.git / blobdiff