Put Kiosk App parameters into device settings.

chrome/browser/chromeos/settings/device_settings_provider.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/chromeos/settings/device_settings_provider.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/network_library.h"
-#include "chrome/browser/chromeos/policy/app_pack_updater.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/cros_settings_names.h"
 #include "chrome/browser/chromeos/settings/device_settings_cache.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/cloud/cloud_policy_constants.h"
 #include "chrome/browser/policy/proto/cloud/device_management_backend.pb.h"
 #include "chrome/browser/ui/options/options_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/installer/util/google_update_settings.h"
 
 using google::protobuf::RepeatedPtrField;
 
 namespace em = enterprise_management;
 
 namespace chromeos {
 
 namespace {
 
 // List of settings handled by the DeviceSettingsProvider.
 const char* kKnownSettings[] = {
   kAccountsPrefAllowGuest,
   kAccountsPrefAllowNewUser,
   kAccountsPrefDeviceLocalAccounts,
+  kAccountsPrefDeviceLocalAccountAutoLoginBailoutEnabled,
   kAccountsPrefDeviceLocalAccountAutoLoginDelay,
   kAccountsPrefDeviceLocalAccountAutoLoginId,
   kAccountsPrefEphemeralUsersEnabled,
   kAccountsPrefShowUserNamesOnSignIn,
   kAccountsPrefUsers,
   kAllowRedeemChromeOsRegistrationOffers,
   kAppPack,
   kDeviceAttestationEnabled,
   kDeviceOwner,
   kIdleLogoutTimeout,
@@ skipping 164 matching lines @@
     em::ShowUserNamesOnSigninProto* show =
         device_settings_.mutable_show_user_names();
     bool show_value;
     if (value->GetAsBoolean(&show_value))
       show->set_show_user_names(show_value);
     else
       NOTREACHED();
   } else if (prop == kAccountsPrefDeviceLocalAccounts) {
     em::DeviceLocalAccountsProto* device_local_accounts =
         device_settings_.mutable_device_local_accounts();
-    base::ListValue* accounts_list;
+    device_local_accounts->clear_account();
+    const base::ListValue* accounts_list = NULL;
     if (value->GetAsList(&accounts_list)) {
       for (base::ListValue::const_iterator entry(accounts_list->begin());
            entry != accounts_list->end(); ++entry) {
-        std::string id;
-        if ((*entry)->GetAsString(&id))
-          device_local_accounts->add_account()->set_id(id);
-        else
+        const base::DictionaryValue* entry_dict = NULL;
+        if ((*entry)->GetAsDictionary(&entry_dict)) {
+          em::DeviceLocalAccountInfoProto* account =
+              device_local_accounts->add_account();
+          std::string account_id;
+          if (entry_dict->GetStringWithoutPathExpansion(
+                  kAccountsPrefDeviceLocalAccountsKeyId, &account_id)) {
+            account->set_account_id(account_id);
+          }
+          int type;
+          if (entry_dict->GetIntegerWithoutPathExpansion(
+                  kAccountsPrefDeviceLocalAccountsKeyType, &type)) {
+            account->set_type(
+                static_cast<em::DeviceLocalAccountInfoProto::AccountType>(
+                    type));
+          }
+          std::string kiosk_app_id;
+          if (entry_dict->GetStringWithoutPathExpansion(
+                  kAccountsPrefDeviceLocalAccountsKeyKioskAppId,
+                  &kiosk_app_id)) {
+            account->mutable_kiosk_app()->set_app_id(kiosk_app_id);
+          }
+          std::string kiosk_app_update_url;
+          if (entry_dict->GetStringWithoutPathExpansion(
+                  kAccountsPrefDeviceLocalAccountsKeyKioskAppUpdateURL,
+                  &kiosk_app_update_url)) {
+            account->mutable_kiosk_app()->set_update_url(kiosk_app_update_url);
+          }
+        } else {
           NOTREACHED();
+        }
       }
     } else {
       NOTREACHED();
     }
   } else if (prop == kAccountsPrefDeviceLocalAccountAutoLoginId) {
     em::DeviceLocalAccountsProto* device_local_accounts =
         device_settings_.mutable_device_local_accounts();
     std::string id;
     if (value->GetAsString(&id))
       device_local_accounts->set_auto_login_id(id);
     else
       NOTREACHED();
   } else if (prop == kAccountsPrefDeviceLocalAccountAutoLoginDelay) {
     em::DeviceLocalAccountsProto* device_local_accounts =
         device_settings_.mutable_device_local_accounts();
     int delay;
     if (value->GetAsInteger(&delay))
       device_local_accounts->set_auto_login_delay(delay);
     else
       NOTREACHED();
+  } else if (prop == kAccountsPrefDeviceLocalAccountAutoLoginBailoutEnabled) {
+    em::DeviceLocalAccountsProto* device_local_accounts =
+        device_settings_.mutable_device_local_accounts();
+    bool enabled;
+    if (value->GetAsBoolean(&enabled))
+      device_local_accounts->set_enable_auto_login_bailout(enabled);
+    else
+      NOTREACHED();
   } else if (prop == kSignedDataRoamingEnabled) {
     em::DataRoamingEnabledProto* roam =
         device_settings_.mutable_data_roaming_enabled();
     bool roaming_value = false;
     if (value->GetAsBoolean(&roaming_value))
       roam->set_data_roaming_enabled(roaming_value);
     else
       NOTREACHED();
     ApplyRoamingSetting(roaming_value);
   } else if (prop == kSettingProxyEverywhere) {
@@ skipping 158 matching lines @@
   base::ListValue* list = new base::ListValue();
   const em::UserWhitelistProto& whitelist_proto = policy.user_whitelist();
   const RepeatedPtrField<std::string>& whitelist =
       whitelist_proto.user_whitelist();
   for (RepeatedPtrField<std::string>::const_iterator it = whitelist.begin();
        it != whitelist.end(); ++it) {
     list->Append(new base::StringValue(*it));
   }
   new_values_cache->SetValue(kAccountsPrefUsers, list);
 
-  base::ListValue* account_list = new base::ListValue();
+  scoped_ptr<base::ListValue> account_list(new base::ListValue());
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (!command_line->HasSwitch(switches::kDisableLocalAccounts)) {
     const em::DeviceLocalAccountsProto device_local_accounts_proto =
         policy.device_local_accounts();
     const RepeatedPtrField<em::DeviceLocalAccountInfoProto>& accounts =
         device_local_accounts_proto.account();
     RepeatedPtrField<em::DeviceLocalAccountInfoProto>::const_iterator entry;
     for (entry = accounts.begin(); entry != accounts.end(); ++entry) {
-      if (entry->has_id())
-        account_list->AppendString(entry->id());
+      scoped_ptr<base::DictionaryValue> entry_dict(new base::DictionaryValue());
+      if (entry->has_type()) {
+        if (entry->has_account_id()) {
+          entry_dict->SetStringWithoutPathExpansion(
+              kAccountsPrefDeviceLocalAccountsKeyId, entry->account_id());
+        }
+        entry_dict->SetIntegerWithoutPathExpansion(
+            kAccountsPrefDeviceLocalAccountsKeyType, entry->type());
+        if (entry->kiosk_app().has_app_id()) {
+          entry_dict->SetStringWithoutPathExpansion(
+              kAccountsPrefDeviceLocalAccountsKeyKioskAppId,
+              entry->kiosk_app().app_id());
+        }
+        if (entry->kiosk_app().has_update_url()) {
+          entry_dict->SetStringWithoutPathExpansion(
+              kAccountsPrefDeviceLocalAccountsKeyKioskAppUpdateURL,
+              entry->kiosk_app().update_url());
+        }
+      } else if (entry->has_id()) {
+        // Deprecated public session specification.
+        entry_dict->SetStringWithoutPathExpansion(
+            kAccountsPrefDeviceLocalAccountsKeyId, entry->id());
+        entry_dict->SetIntegerWithoutPathExpansion(
+            kAccountsPrefDeviceLocalAccountsKeyType,
+            DEVICE_LOCAL_ACCOUNT_TYPE_PUBLIC_SESSION);
+      }
+      account_list->Append(entry_dict.release());
     }
   }
-  new_values_cache->SetValue(kAccountsPrefDeviceLocalAccounts, account_list);
-
-  if (policy.has_start_up_flags()) {
-    base::ListValue* list = new base::ListValue();
-    const em::StartUpFlagsProto& flags_proto = policy.start_up_flags();
-    const RepeatedPtrField<std::string>& flags = flags_proto.flags();
-    for (RepeatedPtrField<std::string>::const_iterator it = flags.begin();
-         it != flags.end(); ++it) {
-      list->Append(new base::StringValue(*it));
-    }
-    new_values_cache->SetValue(kStartUpFlags, list);
-  }
+  new_values_cache->SetValue(kAccountsPrefDeviceLocalAccounts,
+                             account_list.release());
 
   if (policy.has_device_local_accounts()) {
     if (policy.device_local_accounts().has_auto_login_id()) {
       new_values_cache->SetString(
           kAccountsPrefDeviceLocalAccountAutoLoginId,
           policy.device_local_accounts().auto_login_id());
     }
     if (policy.device_local_accounts().has_auto_login_delay()) {
       new_values_cache->SetInteger(
           kAccountsPrefDeviceLocalAccountAutoLoginDelay,
           policy.device_local_accounts().auto_login_delay());
     }
   }
+
+  new_values_cache->SetBoolean(
+      kAccountsPrefDeviceLocalAccountAutoLoginBailoutEnabled,
+      policy.device_local_accounts().enable_auto_login_bailout());
+
+  if (policy.has_start_up_flags()) {
+    base::ListValue* list = new base::ListValue();
+    const em::StartUpFlagsProto& flags_proto = policy.start_up_flags();
+    const RepeatedPtrField<std::string>& flags = flags_proto.flags();
+    for (RepeatedPtrField<std::string>::const_iterator it = flags.begin();
+         it != flags.end(); ++it) {
+      list->Append(new base::StringValue(*it));
+    }
+    new_values_cache->SetValue(kStartUpFlags, list);
+  }
 }
 
 void DeviceSettingsProvider::DecodeKioskPolicies(
     const em::ChromeDeviceSettingsProto& policy,
     PrefValueMap* new_values_cache) const {
   if (policy.has_forced_logout_timeouts()) {
     if (policy.forced_logout_timeouts().has_idle_logout_timeout()) {
       new_values_cache->SetInteger(
           kIdleLogoutTimeout,
           policy.forced_logout_timeouts().idle_logout_timeout());
@@ skipping 21 matching lines @@
   }
 
   if (policy.has_app_pack()) {
     typedef RepeatedPtrField<em::AppPackEntryProto> proto_type;
     base::ListValue* list = new base::ListValue;
     const proto_type& app_pack = policy.app_pack().app_pack();
     for (proto_type::const_iterator it = app_pack.begin();
          it != app_pack.end(); ++it) {
       base::DictionaryValue* entry = new base::DictionaryValue;
       if (it->has_extension_id()) {
-        entry->SetString(policy::AppPackUpdater::kExtensionId,
-                         it->extension_id());
+        entry->SetStringWithoutPathExpansion(kAppPackKeyExtensionId,
+                                             it->extension_id());
       }
-      if (it->has_update_url())
-        entry->SetString(policy::AppPackUpdater::kUpdateUrl, it->update_url());
+      if (it->has_update_url()) {
+        entry->SetStringWithoutPathExpansion(kAppPackKeyUpdateUrl,
+                                             it->update_url());
+      }
       list->Append(entry);
     }
     new_values_cache->SetValue(kAppPack, list);
   }
 
   if (policy.has_start_up_urls()) {
     base::ListValue* list = new base::ListValue();
     const em::StartUpUrlsProto& urls_proto = policy.start_up_urls();
     const RepeatedPtrField<std::string>& urls = urls_proto.start_up_urls();
     for (RepeatedPtrField<std::string>::const_iterator it = urls.begin();
@@ skipping 342 matching lines @@
 void DeviceSettingsProvider::AttemptMigration() {
   if (device_settings_service_->HasPrivateOwnerKey()) {
     PrefValueMap::const_iterator i;
     for (i = migration_values_.begin(); i != migration_values_.end(); ++i)
       DoSet(i->first, *i->second);
     migration_values_.Clear();
   }
 }
 
 }  // namespace chromeos