src/chrome/browser/ui/webui/chromeos/login/gaia_screen_handler.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/webui/chromeos/login/gaia_screen_handler.h"
   6
   7 #include "base/logging.h"
   8 #include "base/values.h"
   9 #include "chrome/browser/browser_process.h"
  10 #include "chrome/browser/chromeos/login/user_adding_screen.h"
  11 #include "chrome/browser/chromeos/login/user_manager.h"
  12 #include "chrome/browser/chromeos/settings/cros_settings.h"
  13 #include "chrome/browser/ui/webui/chromeos/login/signin_screen_handler.h"
  14 #include "chromeos/settings/cros_settings_names.h"
  15 #include "google_apis/gaia/gaia_switches.h"
  16 #include "google_apis/gaia/gaia_urls.h"
  17 #include "grit/chromium_strings.h"
  18 #include "grit/generated_resources.h"
  19 #include "ui/base/l10n/l10n_util.h"
  20
  21 namespace chromeos {
  22
  23 namespace {
  24
  25 const char kJsScreenPath[] = "login.GaiaSigninScreen";
  26
  27 // Updates params dictionary passed to the auth extension with related
  28 // preferences from CrosSettings.
  29 void UpdateAuthParamsFromSettings(base::DictionaryValue* params,
  30                                   const CrosSettings* cros_settings) {
  31   bool allow_new_user = true;
  32   cros_settings->GetBoolean(kAccountsPrefAllowNewUser, &allow_new_user);
  33   bool allow_guest = true;
  34   cros_settings->GetBoolean(kAccountsPrefAllowGuest, &allow_guest);
  35   // Account creation depends on Guest sign-in (http://crosbug.com/24570).
  36   params->SetBoolean("createAccount", allow_new_user && allow_guest);
  37   params->SetBoolean("guestSignin", allow_guest);
  38 }
  39
  40 void UpdateAuthParams(base::DictionaryValue* params, bool has_users) {
  41   UpdateAuthParamsFromSettings(params, CrosSettings::Get());
  42
  43   // Allow locally managed user creation only if:
  44   // 1. Enterprise managed device > is allowed by policy.
  45   // 2. Consumer device > owner exists.
  46   // 3. New users are allowed by owner.
  47
  48   CrosSettings* cros_settings = CrosSettings::Get();
  49   bool allow_new_user = false;
  50   cros_settings->GetBoolean(kAccountsPrefAllowNewUser, &allow_new_user);
  51
  52   bool managed_users_allowed =
  53       UserManager::Get()->AreLocallyManagedUsersAllowed();
  54   bool managed_users_can_create = true;
  55   int message_id = -1;
  56   if (!has_users) {
  57     managed_users_can_create = false;
  58     message_id = IDS_CREATE_LOCALLY_MANAGED_USER_NO_MANAGER_TEXT;
  59   }
  60   if (!allow_new_user) {
  61     managed_users_can_create = false;
  62     message_id = IDS_CREATE_LOCALLY_MANAGED_USER_CREATION_RESTRICTED_TEXT;
  63   }
  64
  65   params->SetBoolean("managedUsersEnabled", managed_users_allowed);
  66   params->SetBoolean("managedUsersCanCreate", managed_users_can_create);
  67   if (!managed_users_can_create) {
  68     params->SetString("managedUsersRestrictionReason",
  69                       l10n_util::GetStringUTF16(message_id));
  70   }
  71
  72   // Now check whether we're in multi-profiles user adding scenario and
  73   // disable GAIA right panel features if that's the case.
  74   if (UserAddingScreen::Get()->IsRunning()) {
  75     params->SetBoolean("createAccount", false);
  76     params->SetBoolean("guestSignin", false);
  77     params->SetBoolean("managedUsersEnabled", false);
  78   }
  79 }
  80
  81 }  // namespace
  82
  83 GaiaContext::GaiaContext()
  84     : force_reload(false),
  85       is_local(false),
  86       password_changed(false),
  87       show_users(false),
  88       use_offline(false),
  89       has_users(false) {}
  90
  91 GaiaScreenHandler::GaiaScreenHandler(
  92     const scoped_refptr<NetworkStateInformer>& network_state_informer)
  93     : BaseScreenHandler(kJsScreenPath),
  94       frame_state_(FRAME_STATE_UNKNOWN),
  95       frame_error_(net::OK),
  96       network_state_informer_(network_state_informer),
  97       signin_screen_handler_(NULL) {
  98   DCHECK(network_state_informer_.get());
  99 }
 100
 101 GaiaScreenHandler::~GaiaScreenHandler() {}
 102
 103 void GaiaScreenHandler::LoadGaia(const GaiaContext& context) {
 104   LOG(WARNING) << "LoadGaia() call.";
 105
 106   base::DictionaryValue params;
 107
 108   params.SetBoolean("forceReload", context.force_reload);
 109   params.SetBoolean("isLocal", context.is_local);
 110   params.SetBoolean("passwordChanged", context.password_changed);
 111   params.SetBoolean("isShowUsers", context.show_users);
 112   params.SetBoolean("useOffline", context.use_offline);
 113   params.SetString("email", context.email);
 114
 115   UpdateAuthParams(&params, context.has_users);
 116
 117   if (!context.use_offline) {
 118     const std::string app_locale = g_browser_process->GetApplicationLocale();
 119     if (!app_locale.empty())
 120       params.SetString("hl", app_locale);
 121   } else {
 122     base::DictionaryValue* localized_strings = new base::DictionaryValue();
 123     localized_strings->SetString(
 124         "stringEmail", l10n_util::GetStringUTF16(IDS_LOGIN_OFFLINE_EMAIL));
 125     localized_strings->SetString(
 126         "stringPassword",
 127         l10n_util::GetStringUTF16(IDS_LOGIN_OFFLINE_PASSWORD));
 128     localized_strings->SetString(
 129         "stringSignIn", l10n_util::GetStringUTF16(IDS_LOGIN_OFFLINE_SIGNIN));
 130     localized_strings->SetString(
 131         "stringEmptyEmail",
 132         l10n_util::GetStringUTF16(IDS_LOGIN_OFFLINE_EMPTY_EMAIL));
 133     localized_strings->SetString(
 134         "stringEmptyPassword",
 135         l10n_util::GetStringUTF16(IDS_LOGIN_OFFLINE_EMPTY_PASSWORD));
 136     localized_strings->SetString(
 137         "stringError", l10n_util::GetStringUTF16(IDS_LOGIN_OFFLINE_ERROR));
 138     params.Set("localizedStrings", localized_strings);
 139   }
 140
 141   const GURL gaia_url =
 142       CommandLine::ForCurrentProcess()->HasSwitch(::switches::kGaiaUrl)
 143           ? GURL(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
 144                 ::switches::kGaiaUrl))
 145           : GaiaUrls::GetInstance()->gaia_url();
 146   params.SetString("gaiaUrl", gaia_url.spec());
 147
 148   frame_state_ = FRAME_STATE_LOADING;
 149   CallJS("loadAuthExtension", params);
 150 }
 151
 152 void GaiaScreenHandler::UpdateGaia(const GaiaContext& context) {
 153   base::DictionaryValue params;
 154   UpdateAuthParams(&params, context.has_users);
 155   CallJS("updateAuthExtension", params);
 156 }
 157
 158 void GaiaScreenHandler::ReloadGaia() {
 159   if (frame_state_ == FRAME_STATE_LOADING)
 160     return;
 161   NetworkStateInformer::State state = network_state_informer_->state();
 162   if (state != NetworkStateInformer::ONLINE) {
 163     LOG(WARNING) << "Skipping reloading of Gaia since "
 164                  << "network state="
 165                  << NetworkStateInformer::StatusString(state);
 166     return;
 167   }
 168   LOG(WARNING) << "Reloading Gaia.";
 169   frame_state_ = FRAME_STATE_LOADING;
 170   CallJS("doReload");
 171 }
 172
 173 void GaiaScreenHandler::DeclareLocalizedValues(
 174     LocalizedValuesBuilder* builder) {
 175   builder->Add("signinScreenTitle", IDS_SIGNIN_SCREEN_TITLE);
 176   builder->Add("signinScreenPasswordChanged",
 177                IDS_SIGNIN_SCREEN_PASSWORD_CHANGED);
 178   builder->Add("createAccount", IDS_CREATE_ACCOUNT_HTML);
 179   builder->Add("guestSignin", IDS_BROWSE_WITHOUT_SIGNING_IN_HTML);
 180   builder->Add("createLocallyManagedUser",
 181                IDS_CREATE_LOCALLY_MANAGED_USER_HTML);
 182   builder->Add("createManagedUserFeatureName",
 183                IDS_CREATE_LOCALLY_MANAGED_USER_FEATURE_NAME);
 184
 185   // Strings used by the fatal error dialog.
 186   builder->Add("fatalErrorMessageGeneric", IDS_LOGIN_FATAL_ERROR_TEXT_GENERIC);
 187   builder->Add("fatalErrorMessageInsecureURL",
 188                IDS_LOGIN_FATAL_ERROR_TEXT_INSECURE_URL);
 189   builder->Add("fatalErrorInstructions", IDS_LOGIN_FATAL_ERROR_INSTRUCTIONS);
 190   builder->Add("fatalErrorDismissButton", IDS_OK);
 191 }
 192
 193 void GaiaScreenHandler::Initialize() {}
 194
 195 void GaiaScreenHandler::RegisterMessages() {
 196   AddCallback("frameLoadingCompleted",
 197               &GaiaScreenHandler::HandleFrameLoadingCompleted);
 198 }
 199
 200 void GaiaScreenHandler::HandleFrameLoadingCompleted(int status) {
 201   const net::Error frame_error = static_cast<net::Error>(-status);
 202   if (frame_error == net::ERR_ABORTED) {
 203     LOG(WARNING) << "Ignoring Gaia frame error: " << frame_error;
 204     return;
 205   }
 206   frame_error_ = frame_error;
 207   if (frame_error == net::OK) {
 208     VLOG(1) << "Gaia is loaded";
 209     frame_state_ = FRAME_STATE_LOADED;
 210   } else {
 211     LOG(WARNING) << "Gaia frame error: " << frame_error_;
 212     frame_state_ = FRAME_STATE_ERROR;
 213   }
 214
 215   if (network_state_informer_->state() != NetworkStateInformer::ONLINE)
 216     return;
 217   if (frame_state_ == FRAME_STATE_LOADED)
 218     UpdateState(ErrorScreenActor::ERROR_REASON_UPDATE);
 219   else if (frame_state_ == FRAME_STATE_ERROR)
 220     UpdateState(ErrorScreenActor::ERROR_REASON_FRAME_ERROR);
 221 }
 222
 223 void GaiaScreenHandler::UpdateState(ErrorScreenActor::ErrorReason reason) {
 224   if (signin_screen_handler_)
 225     signin_screen_handler_->UpdateState(reason);
 226 }
 227
 228 void GaiaScreenHandler::SetSigninScreenHandler(SigninScreenHandler* handler) {
 229   signin_screen_handler_ = handler;
 230 }
 231
 232 }  // namespace chromeos