Add login screen locale and input method device policies

chrome/browser/chromeos/policy/device_policy_decoder_chromeos.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/policy/device_policy_decoder_chromeos.h"
 
 #include <limits>
 #include <string>
 
 #include "base/callback.h"
@@ skipping 314 matching lines @@
   }
 
   if (policy.has_login_apps()) {
     const em::LoginAppsProto& login_apps_proto(policy.login_apps());
     std::unique_ptr<base::ListValue> login_apps(new base::ListValue);
     for (const auto& login_app : login_apps_proto.login_apps())
       login_apps->AppendString(login_app);
     policies->Set(key::kLoginApps, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                   POLICY_SOURCE_CLOUD, std::move(login_apps), nullptr);
   }
+
+  if (policy.has_login_screen_power_management()) {
+    const em::LoginScreenPowerManagementProto& container(
+        policy.login_screen_power_management());
+    if (container.has_login_screen_power_management()) {
+      std::unique_ptr<base::Value> decoded_json;
+      decoded_json = DecodeJsonStringAndDropUnknownBySchema(
+          container.login_screen_power_management(),
+          key::kDeviceLoginScreenPowerManagement);
+      if (decoded_json) {
+        policies->Set(key::kDeviceLoginScreenPowerManagement,
+                      POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
+                      POLICY_SOURCE_CLOUD, std::move(decoded_json), nullptr);
+      }
+    }
+  }
+
+  if (policy.has_login_screen_domain_auto_complete()) {
+    const em::LoginScreenDomainAutoCompleteProto& container(
+        policy.login_screen_domain_auto_complete());
+    policies->Set(key::kDeviceLoginScreenDomainAutoComplete,
+                  POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
+                  POLICY_SOURCE_CLOUD,
+                  base::MakeUnique<base::StringValue>(
+                      container.login_screen_domain_auto_complete()),
+                  nullptr);
+  }
+
+  if (policy.has_login_screen_locales()) {
+    std::unique_ptr<base::ListValue> locales(new base::ListValue);
+    const em::LoginScreenLocalesProto& login_screen_locales(
+        policy.login_screen_locales());
+    for (const auto& locale : login_screen_locales.login_screen_locales())
+      locales->AppendString(locale);
+    policies->Set(key::kDeviceLoginScreenLocales, POLICY_LEVEL_MANDATORY,
+                  POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD, std::move(locales),
+                  nullptr);
+  }
+
+  if (policy.has_login_screen_input_methods()) {
+    std::unique_ptr<base::ListValue> input_methods(new base::ListValue);
+    const em::LoginScreenInputMethodsProto& login_screen_input_methods(
+        policy.login_screen_input_methods());
+    for (const auto& input_method :
+         login_screen_input_methods.login_screen_input_methods())
+      input_methods->AppendString(input_method);
+    policies->Set(key::kDeviceLoginScreenInputMethods, POLICY_LEVEL_MANDATORY,
+                  POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
+                  std::move(input_methods), nullptr);
+  }
 }
 
 void DecodeNetworkPolicies(const em::ChromeDeviceSettingsProto& policy,
                            PolicyMap* policies) {
   if (policy.has_data_roaming_enabled()) {
     const em::DataRoamingEnabledProto& container(policy.data_roaming_enabled());
     if (container.has_data_roaming_enabled()) {
       policies->Set(key::kDeviceDataRoamingEnabled, POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                     base::MakeUnique<base::FundamentalValue>(
@@ skipping 401 matching lines @@
     if (policy.attestation_settings().has_content_protection_enabled()) {
       policies->Set(
           key::kAttestationForContentProtectionEnabled, POLICY_LEVEL_MANDATORY,
           POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
           base::MakeUnique<base::FundamentalValue>(
               policy.attestation_settings().content_protection_enabled()),
           nullptr);
     }
   }
 
-  if (policy.has_login_screen_power_management()) {
-    const em::LoginScreenPowerManagementProto& container(
-        policy.login_screen_power_management());
-    if (container.has_login_screen_power_management()) {
-      std::unique_ptr<base::Value> decoded_json;
-      decoded_json = DecodeJsonStringAndDropUnknownBySchema(
-          container.login_screen_power_management(),
-          key::kDeviceLoginScreenPowerManagement);
-      if (decoded_json) {
-        policies->Set(key::kDeviceLoginScreenPowerManagement,
-                      POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-                      POLICY_SOURCE_CLOUD, std::move(decoded_json), nullptr);
-      }
-    }
-  }
-
   if (policy.has_system_settings()) {
     const em::SystemSettingsProto& container(policy.system_settings());
     if (container.has_block_devmode()) {
       policies->Set(
           key::kDeviceBlockDevmode, POLICY_LEVEL_MANDATORY,
           POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
           base::MakeUnique<base::FundamentalValue>(container.block_devmode()),
           nullptr);
     }
   }
 
   if (policy.has_extension_cache_size()) {
     const em::ExtensionCacheSizeProto& container(policy.extension_cache_size());
     if (container.has_extension_cache_size()) {
       policies->Set(key::kExtensionCacheSize, POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                     DecodeIntegerValue(container.extension_cache_size()),
                     nullptr);
     }
   }
 
-  if (policy.has_login_screen_domain_auto_complete()) {
-    const em::LoginScreenDomainAutoCompleteProto& container(
-        policy.login_screen_domain_auto_complete());
-    policies->Set(key::kDeviceLoginScreenDomainAutoComplete,
-                  POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
-                  POLICY_SOURCE_CLOUD,
-                  base::MakeUnique<base::StringValue>(
-                      container.login_screen_domain_auto_complete()),
-                  nullptr);
-  }
-
   if (policy.has_display_rotation_default()) {
     const em::DisplayRotationDefaultProto& container(
         policy.display_rotation_default());
     policies->Set(key::kDisplayRotationDefault, POLICY_LEVEL_MANDATORY,
                   POLICY_SCOPE_MACHINE, POLICY_SOURCE_CLOUD,
                   DecodeIntegerValue(container.display_rotation_default()),
                   nullptr);
   }
 
   if (policy.has_usb_detachable_whitelist()) {
@@ skipping 48 matching lines @@
   // Decode the various groups of policies.
   DecodeLoginPolicies(policy, policies);
   DecodeNetworkPolicies(policy, policies);
   DecodeReportingPolicies(policy, policies);
   DecodeAutoUpdatePolicies(policy, policies);
   DecodeAccessibilityPolicies(policy, policies);
   DecodeGenericPolicies(policy, policies);
 }
 
 }  // namespace policy