Put Kiosk App parameters into device settings.

chrome/browser/chromeos/login/user_manager_impl.cc

 // Copyright (c) 2013 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/user_manager_impl.h"
 
 #include <cstddef>
 #include <set>
 #include <vector>
 
@@ skipping 817 matching lines @@
       local_state->GetDictionary(kUserDisplayEmail);
 
   // Load regular users and locally managed users.
   std::vector<std::string> regular_users;
   std::set<std::string> regular_users_set;
   ParseUserList(*prefs_regular_users, std::set<std::string>(), "",
                 &regular_users, &regular_users_set);
   for (std::vector<std::string>::const_iterator it = regular_users.begin();
        it != regular_users.end(); ++it) {
     User* user = NULL;
-    if (gaia::ExtractDomainName(*it) ==
-            UserManager::kLocallyManagedUserDomain) {
+    const std::string domain = gaia::ExtractDomainName(*it);
+    if (domain == UserManager::kLocallyManagedUserDomain) {
       user = User::CreateLocallyManagedUser(*it);
     } else {
       user = User::CreateRegularUser(*it);
       user->set_oauth_token_status(LoadUserOAuthStatus(*it));
     }
     users_.push_back(user);
 
     string16 display_name;
     if (prefs_display_names->GetStringWithoutPathExpansion(*it,
                                                            &display_name)) {
@@ skipping 28 matching lines @@
   // Schedule a callback if device policy has not yet been verified.
   if (CrosSettingsProvider::TRUSTED != cros_settings_->PrepareTrustedValues(
       base::Bind(&UserManagerImpl::RetrieveTrustedDevicePolicies,
                  base::Unretained(this)))) {
     return;
   }
 
   cros_settings_->GetBoolean(kAccountsPrefEphemeralUsersEnabled,
                              &ephemeral_users_enabled_);
   cros_settings_->GetString(kDeviceOwner, &owner_email_);
-  const base::ListValue* public_accounts;
-  cros_settings_->GetList(kAccountsPrefDeviceLocalAccounts, &public_accounts);
+  base::ListValue public_accounts;
+  ReadPublicAccounts(&public_accounts);
 
   EnsureUsersLoaded();
 
-  bool changed = UpdateAndCleanUpPublicAccounts(*public_accounts);
+  bool changed = UpdateAndCleanUpPublicAccounts(public_accounts);
 
   // If ephemeral users are enabled and we are on the login screen, take this
   // opportunity to clean up by removing all regular users except the owner.
   if (ephemeral_users_enabled_  && !IsUserLoggedIn()) {
     ListPrefUpdate prefs_users_update(g_browser_process->local_state(),
                                       kRegularUsers);
     prefs_users_update->Clear();
     for (UserList::iterator it = users_.begin(); it != users_.end(); ) {
       const std::string user_email = (*it)->email();
       if ((*it)->GetType() == User::USER_TYPE_REGULAR &&
@@ skipping 515 matching lines @@
   else if (active_user_->GetType() == User::USER_TYPE_LOCALLY_MANAGED)
     login_user_type = LoginState::LOGGED_IN_USER_LOCALLY_MANAGED;
   else if (active_user_->GetType() == User::USER_TYPE_KIOSK_APP)
     login_user_type = LoginState::LOGGED_IN_USER_KIOSK_APP;
   else
     login_user_type = LoginState::LOGGED_IN_USER_REGULAR;
 
   LoginState::Get()->SetLoggedInState(logged_in_state, login_user_type);
 }
 
+void UserManagerImpl::ReadPublicAccounts(base::ListValue* public_accounts) {
+  const base::DictionaryValue* device_local_accounts = NULL;
+  if (cros_settings_->GetDictionary(
+          kAccountsPrefDeviceLocalAccounts, &device_local_accounts)) {

[bartfab (slow), 2013/04/25 11:17:28]

By switching from a ListValue to a DictionaryValue for the public accounts, we
are losing information about their ordering. I think this is a bad thing.
Imagine a device pre-configured with three kiosk apps. You would not want the
three pods to appear in random, unpredictable order.

FWIW, I ran into the same problem when moving all user information into a single
data structure in Local State. I ended up going with the obvious solution: A
ListValue that holds a DictionaryValue for each user which then contains a key
"user_id" that tells you what user it is for. You have to do a linear search to
find a particular user but given the expected sizes of these lists, I see no
issues with that.

[Mattias Nissler (ping if slow), 2013/04/26 09:10:05]

Switched to the list.

+    for (base::DictionaryValue::Iterator account(*device_local_accounts);
+         !account.IsAtEnd(); account.Advance()) {
+      const base::DictionaryValue* entry_dict = NULL;
+      if (!account.value().GetAsDictionary(&entry_dict)) {
+        NOTREACHED();
+        continue;
+      }
+
+      if (entry_dict->HasKey(kAccountsPrefDeviceLocalAccountsKeyKioskAppId)) {

[bartfab (slow), 2013/04/25 11:17:28]

As in KioskAppManager, this code should look at account->key() instead.

[Mattias Nissler (ping if slow), 2013/04/26 09:10:05]

Switched to checking the type key.

+        // TODO(mnissler, nkostylev, bartfab): Process Kiosk Apps within the
+        // standard login framework: http://crbug.com/234694
+      } else {
+        // Regular public account.
+        public_accounts->AppendString(account.key());
+      }
+    }
+  }
+}
+
 }  // namespace chromeos