cros: Ensure quick unlock is disabled by default for enterprise policy.

components/policy/tools/generate_policy_source.py

 #!/usr/bin/env python
 # 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.
 
 '''python %prog [options] platform chromium_os_flag template
 
 platform specifies which platform source is being generated for
   and can be one of (win, mac, linux)
 chromium_os_flag should be 1 if this is a Chromium OS build
@@ skipping 642 matching lines @@
     might be either int or string. An int type suggests that it's a resolved
     index, but for string type it's unresolved. Resolving a reference is as
     simple as looking up for corresponding ID in self.id_map, and replace the
     old index with the mapped index.
     """
     self.schema_nodes = map(partial(self.ResolveID, 1), self.schema_nodes)
     self.property_nodes = map(partial(self.ResolveID, 1), self.property_nodes)
     self.properties_nodes = map(partial(self.ResolveID, 3),
         self.properties_nodes)
 
+def _GenerateDefaultValue(value):
+  """Converts a JSON object into a base::Value entry. Returns a tuple, the first
+  entry being a list of declaration statements to define the variable, the
+  second entry being a way to access the variable.
+
+  If no definition is needed, the first return value will be an empty list. If
+  any error occurs, the second return value will be None (ie, no way to fetch
+  the value).
+
+  |value|: The deserialized value to convert to base::Value."""
+  if type(value) == bool or type(value) == int:
+    return [], 'base::MakeUnique<base::FundamentalValue>(%s)' %\
+                    json.dumps(value)
+  elif type(value) == str:
+    return [], 'base::MakeUnique<base::StringValue>("%s")' % value
+  elif type(value) == list:
+    setup = ['auto default_value = base::MakeUnique<base::ListValue>();']
+    for entry in value:
+      decl, fetch = _GenerateDefaultValue(entry)
+      # Nested lists are not supported.
+      if decl:
+        return [], None
+      setup.append('default_value->Append(%s);' % fetch)
+    return setup, 'std::move(default_value)'
+  return [], None
+
 def _WritePolicyConstantSource(policies, os, f, riskTags):
   f.write('#include "components/policy/policy_constants.h"\n'
           '\n'
           '#include <algorithm>\n'
           '#include <climits>\n'
           '\n'
           '#include "base/logging.h"\n'
           '#include "base/memory/ptr_util.h"\n'
           '#include "components/policy/core/common/policy_types.h"\n'
           '#include "components/policy/core/common/schema_internal.h"\n'
@@ skipping 57 matching lines @@
 
   f.write('const internal::SchemaData* GetChromeSchemaData() {\n'
           '  return &kChromeSchemaData;\n'
           '}\n\n')
 
   f.write('#if defined (OS_CHROMEOS)\n'
           'void SetEnterpriseUsersDefaults(PolicyMap* policy_map) {\n')
 
   for policy in policies:
     if policy.has_enterprise_default:
-      if policy.policy_type == 'Type::BOOLEAN':
-        creation_expression = 'new base::FundamentalValue(%s)' %\
-                              ('true' if policy.enterprise_default else 'false')
-      elif policy.policy_type == 'Type::INTEGER':
-        creation_expression = 'new base::FundamentalValue(%s)' %\
-                              policy.enterprise_default
-      elif policy.policy_type == 'Type::STRING':
-        creation_expression = 'new base::StringValue("%s")' %\
-                              policy.enterprise_default
-      else:
+      declare_default_stmts, fetch_default =\
+          _GenerateDefaultValue(policy.enterprise_default)
+      if not fetch_default:
         raise RuntimeError('Type %s of policy %s is not supported at '
                            'enterprise defaults' % (policy.policy_type,
                                                     policy.name))
+
+      # Convert declare_default_stmts to a string with the correct identation.
+      if declare_default_stmts:
+        declare_default = '    %s\n' % '\n    '.join(declare_default_stmts)
+      else:
+        declare_default = ''
+
       f.write('  if (!policy_map->Get(key::k%s)) {\n'
+              '%s'
               '    policy_map->Set(key::k%s,\n'
               '                    POLICY_LEVEL_MANDATORY,\n'
               '                    POLICY_SCOPE_USER,\n'
               '                    POLICY_SOURCE_ENTERPRISE_DEFAULT,\n'
-              '                    base::WrapUnique(%s),\n'
-              '                    NULL);\n'
-              '  }\n' % (policy.name, policy.name, creation_expression))
+              '                    %s,\n'
+              '                    nullptr);\n'
+              '  }\n' % (policy.name, declare_default, policy.name,
+                         fetch_default))
 
   f.write('}\n'
           '#endif\n\n')
 
   f.write('const PolicyDetails* GetChromePolicyDetails('
               'const std::string& policy) {\n'
           '  // First index in kPropertyNodes of the Chrome policies.\n'
           '  static const int begin_index = %s;\n'
           '  // One-past-the-end of the Chrome policies in kPropertyNodes.\n'
           '  static const int end_index = %s;\n' %
@@ skipping 401 matching lines @@
   f.write('<restrictions xmlns:android="'
           'http://schemas.android.com/apk/res/android">\n\n')
   for policy in policies:
     if (policy.is_supported and policy.restriction_type != 'invalid' and
          not policy.is_deprecated and not policy.is_future):
       WriteAppRestriction(policy)
   f.write('</restrictions>')
 
 if __name__ == '__main__':
   sys.exit(main())