cros: Account picker UI for public account.

chrome/browser/ui/webui/chromeos/login/signin_screen_handler.cc

 // Copyright (c) 2012 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/ui/webui/chromeos/login/signin_screen_handler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 50 matching lines @@
     "chrome-extension://mfffpogegjflfpflabcdkioaeobkgjik/main.html";
 // Same as above but offline version.
 const char kGaiaExtStartPageOffline[] =
     "chrome-extension://mfffpogegjflfpflabcdkioaeobkgjik/offline.html";
 
 // User dictionary keys.
 const char kKeyUsername[] = "username";
 const char kKeyDisplayName[] = "displayName";
 const char kKeyEmailAddress[] = "emailAddress";
 const char kKeyNameTooltip[] = "nameTooltip";
+const char kKeyPublicAccount[] = "publicAccount";
 const char kKeySignedIn[] = "signedIn";
 const char kKeyCanRemove[] = "canRemove";
 const char kKeyOauthTokenStatus[] = "oauthTokenStatus";
 
 // Max number of users to show.
 const size_t kMaxUsers = 5;
 
 // The Task posted to PostTaskAndReply in StartClearingDnsCache on the IO
 // thread.
 void ClearDnsCache(IOThread* io_thread) {
@@ skipping 16 matching lines @@
                                   const CrosSettings* cros_settings) {
   bool allow_new_user = true;
   cros_settings->GetBoolean(kAccountsPrefAllowNewUser, &allow_new_user);
   bool allow_guest = true;
   cros_settings->GetBoolean(kAccountsPrefAllowGuest, &allow_guest);
   // Account creation depends on Guest sign-in (http://crosbug.com/24570).
   params->SetBoolean("createAccount", allow_new_user && allow_guest);
   params->SetBoolean("guestSignin", allow_guest);
 }
 
-} //  namespace
+}  // namespace

[bartfab (slow), 2012/11/28 15:18:33]

Nit: We always have two spaces before |namespace|.

[xiyuan, 2012/12/01 00:24:19]

Most of the file are having two spaces before "//" and one space before
"namespace".

 
 // SigninScreenHandler implementation ------------------------------------------
 
 SigninScreenHandler::SigninScreenHandler(
     const scoped_refptr<NetworkStateInformer>& network_state_informer)
     : delegate_(NULL),
       native_window_delegate_(NULL),
       show_on_init_(false),
       oobe_ui_(false),
       focus_stolen_(false),
@@ skipping 64 matching lines @@
   localized_strings->SetString("offlineLogin",
       l10n_util::GetStringUTF16(IDS_OFFLINE_LOGIN_HTML));
   localized_strings->SetString("removeUser",
       l10n_util::GetStringUTF16(IDS_LOGIN_REMOVE));
   localized_strings->SetString("errorTpmFailure",
       l10n_util::GetStringUTF16(IDS_LOGIN_ERROR_TPM_FAILURE));
   localized_strings->SetString("errorTpmFailureReboot",
       l10n_util::GetStringFUTF16(
           IDS_LOGIN_ERROR_TPM_FAILURE_REBOOT,
           l10n_util::GetStringUTF16(IDS_SHORT_PRODUCT_NAME)));
+
+  policy::BrowserPolicyConnector* policy_connector =
+      g_browser_process->browser_policy_connector();
+
   localized_strings->SetString("disabledAddUserTooltip",
       l10n_util::GetStringUTF16(
-          g_browser_process->browser_policy_connector()->IsEnterpriseManaged() ?
+          policy_connector->IsEnterpriseManaged() ?
             IDS_DISABLED_ADD_USER_TOOLTIP_ENTERPRISE :
             IDS_DISABLED_ADD_USER_TOOLTIP));
 
+  std::string enterprise_domain;
+  if (policy_connector->IsEnterpriseManaged())
+    enterprise_domain = policy_connector->GetEnterpriseDomain();
+
+  if (enterprise_domain.empty()) {

[bartfab (slow), 2012/11/28 15:18:33]

This case would be an error - public accounts defined through policy but no
managing domain. There is no have special code handling such an error in a
particularly pretty way. Just feed the name to |GetStringFUTF16| as you would
normally do and let it return a string with an empty domain inside.

[Nikita (slow), 2012/11/28 18:57:34]

Is this a possible situation:

Chromebook stays at login screen, policy updates so it should show public
account? There's a code that refreshes sign in screen on policy (preferences)
update. That means that strings should be available too i.e. remove conditions?

[bartfab (slow), 2012/11/28 19:19:11]

Yes, this is entirely possible. A policy refresh can happen any time, so user
pods may appear and disappear while the login screen is visible. I know that the
login screen correctly handles this (i.e. pods do get added and removed). It
will be important to make sure that the strings are available for any newly
created pods.

We should also verify that this code handles enrollment correctly. On a virgin
device, IsEnterpriseManaged() returns |false| and the enterprise domain is
empty. If the device is now enrolled, IsEnterpriseManaged() starts returning
|true| and there is an enterprise domain. IIRC, the login screen is redrawn from
scratch after enrollment completes. I would expect the SigninScreenHandler to
also get reinitialized at that point so that it picks up the new managed status
- but it would be good to verify that the domain really is picked up correctly
immediately after enrollment.

[bartfab (slow), 2012/11/29 14:39:39]

Nikita clarified what happens when the login screen is shown after enrollment
completed:

"SigninScreenHandler::Initialize is not called in that case but SendUseList
is called."

So reading the domain name SigninScreenHandler's constructor is not sufficient.
If a device is freshly enrolled, the domain name will never make it to the UI
otherwise.

On 2012/11/28 19:19:11, bartfab wrote:

[xiyuan, 2012/12/01 00:24:19]

In new patch, the domain name is sent as part of user dict for public account
user.

+    localized_strings->SetString("publicAccountInfo", std::string());
+  } else {
+    localized_strings->SetString("publicAccountInfo",
+        l10n_util::GetStringFUTF16(IDS_LOGIN_PUBLIC_ACCOUNT_INFO,
+                                   UTF8ToUTF16(enterprise_domain)));
+  }
+
+  localized_strings->SetString("publicAccountHint",
+       l10n_util::GetStringUTF16(IDS_LOGIN_PUBLIC_ACCOUNT_HINT));
+  localized_strings->SetString("publicAccountEnter",
+       l10n_util::GetStringUTF16(IDS_LOGIN_PUBLIC_ACCOUNT_ENTER));
+
   if (chromeos::KioskModeSettings::Get()->IsKioskModeEnabled()) {
     localized_strings->SetString("demoLoginMessage",
         l10n_util::GetStringUTF16(IDS_KIOSK_MODE_LOGIN_MESSAGE));
   }
 }
 
 void SigninScreenHandler::Show(bool oobe_ui) {
   CHECK(delegate_);
   oobe_ui_ = oobe_ui;
   if (!page_is_ready()) {
@@ skipping 73 matching lines @@
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("getUsers",
       base::Bind(&SigninScreenHandler::HandleGetUsers,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("launchDemoUser",
       base::Bind(&SigninScreenHandler::HandleLaunchDemoUser,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("launchIncognito",
       base::Bind(&SigninScreenHandler::HandleLaunchIncognito,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("launchPublicAccount",
+      base::Bind(&SigninScreenHandler::HandleLaunchPublicAccount,
+                 base::Unretained(this)));
   web_ui()->RegisterMessageCallback("offlineLogin",
       base::Bind(&SigninScreenHandler::HandleOfflineLogin,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("showAddUser",
       base::Bind(&SigninScreenHandler::HandleShowAddUser,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("shutdownSystem",
       base::Bind(&SigninScreenHandler::HandleShutdownSystem,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("loadWallpaper",
@@ skipping 315 matching lines @@
 void SigninScreenHandler::HandleLaunchDemoUser(const base::ListValue* args) {
   if (delegate_)
     delegate_->LoginAsRetailModeUser();
 }
 
 void SigninScreenHandler::HandleLaunchIncognito(const base::ListValue* args) {
   if (delegate_)
     delegate_->LoginAsGuest();
 }
 
+void SigninScreenHandler::HandleLaunchPublicAccount(
+    const base::ListValue* args) {
+  std::string email;
+  if (!args->GetString(0, &email)) {
+    NOTREACHED();
+    return;
+  }
+  email = gaia::SanitizeEmail(email);

[bartfab (slow), 2012/11/28 15:11:38]

This is not used right now. Please remove. I will re-add it as required.

[xiyuan, 2012/12/01 00:24:19]

Removed

+
+  // TODO(xiyuan): Wire this with real public account signin.

[bartfab (slow), 2012/11/28 15:11:38]

Feel free to list me as the TODO owner here. I will start work on that ASAP.

[xiyuan, 2012/12/01 00:24:19]

Done.

+  if (delegate_)
+    delegate_->LoginAsGuest();
+}
+
 void SigninScreenHandler::HandleOfflineLogin(const base::ListValue* args) {
   if (!delegate_ || delegate_->IsShowUsers()) {
     NOTREACHED();
     return;
   }
   if (!args->GetString(0, &email_))
     email_.clear();
 
   // Load auth extension. Parameters are: force reload, do not load extension in
   // background, use offline version.
@@ skipping 92 matching lines @@
 
   ListValue users_list;
   const UserList& users = delegate_->GetUsers();
 
   bool single_user = users.size() == 1;
   for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
     const std::string& email = (*it)->email();
     std::string owner;
     chromeos::CrosSettings::Get()->GetString(chromeos::kDeviceOwner, &owner);
     bool is_owner = (email == owner);
+    bool public_account = ((*it)->GetType() == User::USER_TYPE_PUBLIC_ACCOUNT);
     bool signed_in = *it == UserManager::Get()->GetLoggedInUser();
 
     if (non_owner_count < max_non_owner_users || is_owner) {
       DictionaryValue* user_dict = new DictionaryValue();
       user_dict->SetString(kKeyUsername, email);
       user_dict->SetString(kKeyEmailAddress, (*it)->display_email());
       user_dict->SetString(kKeyDisplayName, (*it)->GetDisplayName());
       user_dict->SetString(kKeyNameTooltip, (*it)->display_email());
+      user_dict->SetBoolean(kKeyPublicAccount, public_account);
       user_dict->SetInteger(kKeyOauthTokenStatus, (*it)->oauth_token_status());
       user_dict->SetBoolean(kKeySignedIn, signed_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
       user_dict->SetBoolean(kKeyCanRemove,
                             !single_user &&
                             !email.empty() &&
                             !is_owner &&
+                            !public_account &&
                             !signed_in);
 
       users_list.Append(user_dict);
       if (!is_owner)
         ++non_owner_count;
     }
   }
 
   base::FundamentalValue animated_value(animated);
   base::FundamentalValue guest_value(delegate_->IsShowGuest());
@@ skipping 234 matching lines @@
                                     ConnectionType last_network_type) {
   base::FundamentalValue state_value(state);
   base::StringValue network_value(network_name);
   base::StringValue reason_value(reason);
   base::FundamentalValue last_network_value(last_network_type);
   web_ui()->CallJavascriptFunction(callback,
       state_value, network_value, reason_value, last_network_value);
 }
 
 }  // namespace chromeos