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 49 matching lines @@
 const char kGaiaExtStartPage[] =
     "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 kKeyEnterpriseDomain[] = "enterpriseDomain";
 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
 
 // 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 70 matching lines @@
   localized_strings->SetString("errorTpmFailureReboot",
       l10n_util::GetStringFUTF16(
           IDS_LOGIN_ERROR_TPM_FAILURE_REBOOT,
           l10n_util::GetStringUTF16(IDS_SHORT_PRODUCT_NAME)));
   localized_strings->SetString("disabledAddUserTooltip",
       l10n_util::GetStringUTF16(
           g_browser_process->browser_policy_connector()->IsEnterpriseManaged() ?
             IDS_DISABLED_ADD_USER_TOOLTIP_ENTERPRISE :
             IDS_DISABLED_ADD_USER_TOOLTIP));
 
+  localized_strings->SetString("publicAccountInfoFormat",
+      l10n_util::GetStringUTF16(IDS_LOGIN_PUBLIC_ACCOUNT_INFO_FORMAT));
+  localized_strings->SetString("publicAccountReminder",
+       l10n_util::GetStringUTF16(IDS_LOGIN_PUBLIC_ACCOUNT_SIGNOUT_REMINDER));
+  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) {
+  // TODO(bartfab): Wire this with real public account signin.
+}
+
 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);
 
+      if (public_account) {
+        policy::BrowserPolicyConnector* policy_connector =
+            g_browser_process->browser_policy_connector();
+
+        if (policy_connector->IsEnterpriseManaged()) {
+          user_dict->SetString(kKeyEnterpriseDomain,
+                               policy_connector->GetEnterpriseDomain());
+        }
+      }
+
       // 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