Implement fetching, caching and retrieval of external policy data

chrome/tools/build/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
 template is the path to a .json policy template file.'''
 
 from __future__ import with_statement
 from optparse import OptionParser
 import re
 import sys
 import textwrap
 
 
 CHROME_POLICY_KEY = 'SOFTWARE\\\\Policies\\\\Google\\\\Chrome'
 CHROMIUM_POLICY_KEY = 'SOFTWARE\\\\Policies\\\\Chromium'
 
 
 class PolicyDetails:
   """Parses a policy template and caches all its details."""
 
   # Maps policy types to a tuple with 3 other types:
-  # - the equivalent base::Value::Type
+  # - the equivalent base::Value::Type or 'TYPE_EXTERNAL' if the policy
+  #   references external data
   # - the equivalent Protobuf field type
   # - the name of one of the protobufs for shared policy types
   TYPE_MAP = {
     'dict':         ('TYPE_DICTIONARY',   'string',       'String'),
+    'external':     ('TYPE_EXTERNAL',     'string',       'String'),
     'int':          ('TYPE_INTEGER',      'int64',        'Integer'),
     'int-enum':     ('TYPE_INTEGER',      'int64',        'Integer'),
     'list':         ('TYPE_LIST',         'StringList',   'StringList'),
     'main':         ('TYPE_BOOLEAN',      'bool',         'Boolean'),
     'string':       ('TYPE_STRING',       'string',       'String'),
     'string-enum':  ('TYPE_STRING',       'string',       'String'),
   }
 
   def __init__(self, policy, os, is_chromium_os):
     self.id = policy['id']
@@ skipping 13 matching lines @@
     is_supported = False
     for platform, version in [ p.split(':') for p in policy['supported_on'] ]:
       if (platform == expected_platform or platform == wildcard_platform) and \
           version.endswith('-'):
         is_supported = True
     self.is_supported = is_supported
 
     if not PolicyDetails.TYPE_MAP.has_key(policy['type']):
       raise NotImplementedError('Unknown policy type for %s: %s' %
                                 (policy['name'], policy['type']))
-    self.value_type, self.protobuf_type, self.policy_protobuf_type = \
+    self.policy_type, self.protobuf_type, self.policy_protobuf_type = \
         PolicyDetails.TYPE_MAP[policy['type']]
 
     self.desc = '\n'.join(
         map(str.strip, self._RemovePlaceholders(policy['desc']).splitlines()))
     self.caption = self._RemovePlaceholders(policy['caption'])
+    self.max_size = policy.get('max_size', 0)

[Joao da Silva, 2013/07/19 11:15:15]

Document "max_size" in the template

[bartfab (slow), 2013/07/19 13:06:30]

Done.

 
   PH_PATTERN = re.compile('<ph[^>]*>([^<]*|[^<]*<ex>([^<]*)</ex>[^<]*)</ph>')
 
   # Simplistic grit placeholder stripper.
   def _RemovePlaceholders(self, text):
     result = ''
     pos = 0
     for m in PolicyDetails.PH_PATTERN.finditer(text):
       result += text[pos:m.start(0)]
       result += m.group(2) or m.group(1)
@@ skipping 98 matching lines @@
 
 
 #------------------ policy constants header ------------------------#
 
 def _WritePolicyConstantHeader(policies, os, f):
   f.write('#ifndef CHROME_COMMON_POLICY_CONSTANTS_H_\n'
           '#define CHROME_COMMON_POLICY_CONSTANTS_H_\n'
           '\n'
           '#include <string>\n'
           '\n'
+          '#include "base/basictypes.h"\n'
           '#include "base/values.h"\n'
           '\n'
           'namespace policy {\n\n')
 
   if os == 'win':
     f.write('// The windows registry path where Chrome policy '
             'configuration resides.\n'
             'extern const wchar_t kRegistryChromePolicyKey[];\n')
 
-  f.write('// Lists policy types mapped to their names and expected types.\n'
-          '// Used to initialize ConfigurationPolicyProviders.\n'
+  f.write('// Lists metadata such as name, expected type and id for all\n'
+          '// policies. Used to initialize ConfigurationPolicyProviders and\n'
+          '// CloudExternalDataManagers.\n'
           'struct PolicyDefinitionList {\n'
           '  struct Entry {\n'
           '    const char* name;\n'
           '    base::Value::Type value_type;\n'
           '    bool device_policy;\n'
           '    int id;\n'
+          '    size_t max_external_data_size;\n'
           '  };\n'
           '\n'
           '  const Entry* begin;\n'
           '  const Entry* end;\n'
           '};\n'
           '\n'
           '// Returns true if the given policy is deprecated.\n'
           'bool IsDeprecatedPolicy(const std::string& policy);\n'
           '\n'
           '// Returns the default policy definition list for Chrome.\n'
           'const PolicyDefinitionList* GetChromePolicyDefinitionList();\n\n')
   f.write('// Key names for the policy settings.\n'
           'namespace key {\n\n')
   for policy in policies:
     # TODO(joaodasilva): Include only supported policies in
     # configuration_policy_handler.cc and configuration_policy_handler_list.cc
     # so that these names can be conditional on 'policy.is_supported'.
     # http://crbug.com/223616
     f.write('extern const char k' + policy.name + '[];\n')
   f.write('\n}  // namespace key\n\n'
           '}  // namespace policy\n\n'
           '#endif  // CHROME_COMMON_POLICY_CONSTANTS_H_\n')
 
 
 #------------------ policy constants source ------------------------#
 
+def _GetValueType(policy_type):
+  return policy_type if policy_type != 'TYPE_EXTERNAL' else 'TYPE_DICTIONARY'
+
+
 def _WritePolicyConstantSource(policies, os, f):
   f.write('#include "base/basictypes.h"\n'
           '#include "base/logging.h"\n'
           '#include "policy/policy_constants.h"\n'
           '\n'
           'namespace policy {\n\n')
 
   f.write('namespace {\n\n')
 
   f.write('const PolicyDefinitionList::Entry kEntries[] = {\n')
   for policy in policies:
     if policy.is_supported:
-      f.write('  { key::k%s, base::Value::%s, %s, %s },\n' %
-          (policy.name, policy.value_type,
-              'true' if policy.is_device_only else 'false', policy.id))
+      f.write('  { key::k%s, base::Value::%s, %s, %s, %s },\n' %
+          (policy.name, _GetValueType(policy.policy_type),
+              'true' if policy.is_device_only else 'false', policy.id,
+              policy.max_size))
   f.write('};\n\n')
 
   f.write('const PolicyDefinitionList kChromePolicyList = {\n'
           '  kEntries,\n'
           '  kEntries + arraysize(kEntries),\n'
           '};\n\n')
 
   has_deprecated_policies = any(
       [p.is_supported and p.is_deprecated for p in policies])
 
@@ skipping 150 matching lines @@
 
 CPP_HEAD = '''
 #include <limits>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "base/values.h"
+#include "chrome/browser/policy/cloud/cloud_external_data_manager.h"
 #include "chrome/browser/policy/external_data_fetcher.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "policy/policy_constants.h"
 #include "policy/proto/cloud_policy.pb.h"
 
 using google::protobuf::RepeatedPtrField;
 
 namespace policy {
 
 namespace em = enterprise_management;
@@ skipping 26 matching lines @@
   if (!root || !root->GetAsDictionary(&dict) || !dict) {
     LOG(WARNING) << "Invalid JSON string, ignoring: " << json;
     // TODO(bartfab): Figure out a way to show errors in chrome://policy.
     return new base::DictionaryValue;
   }
 
   ignore_result(root.release());
   return dict;
 }
 
-void DecodePolicy(const em::CloudPolicySettings& policy, PolicyMap* map) {
+void DecodePolicy(const em::CloudPolicySettings& policy,
+                  base::WeakPtr<CloudExternalDataManager> external_data_manager,
+                  PolicyMap* map) {
 '''
 
 
 CPP_FOOT = '''}
 
 }  // namespace policy
 '''
 
 
 def _CreateValue(type, arg):
   if type == 'TYPE_BOOLEAN':
     return 'base::Value::CreateBooleanValue(%s)' % arg
   elif type == 'TYPE_INTEGER':
     return 'DecodeIntegerValue(%s)' % arg
   elif type == 'TYPE_STRING':
     return 'base::Value::CreateStringValue(%s)' % arg
   elif type == 'TYPE_LIST':
     return 'DecodeStringList(%s)' % arg
-  elif type == 'TYPE_DICTIONARY':
+  elif type == 'TYPE_DICTIONARY' or type == 'TYPE_EXTERNAL':
     return 'DecodeDictionaryValue(%s)' % arg
   else:
     raise NotImplementedError('Unknown type %s' % type)
 
 
+def _CreateExternalDataFetcher(type, name):
+  if type == 'TYPE_EXTERNAL':
+    return 'new ExternalDataFetcher(external_data_manager, key::k%s)' % name
+  return 'NULL'
+
+
 def _WritePolicyCode(f, policy):
   membername = policy.name.lower()
   proto_type = '%sPolicyProto' % policy.policy_protobuf_type
   f.write('  if (policy.has_%s()) {\n' % membername)
   f.write('    const em::%s& policy_proto = policy.%s();\n' %
           (proto_type, membername))
   f.write('    if (policy_proto.has_value()) {\n')
   f.write('      PolicyLevel level = POLICY_LEVEL_MANDATORY;\n'
           '      bool do_set = true;\n'
           '      if (policy_proto.has_policy_options()) {\n'
           '        do_set = false;\n'
           '        switch(policy_proto.policy_options().mode()) {\n'
           '          case em::PolicyOptions::MANDATORY:\n'
           '            do_set = true;\n'
           '            level = POLICY_LEVEL_MANDATORY;\n'
           '            break;\n'
           '          case em::PolicyOptions::RECOMMENDED:\n'
           '            do_set = true;\n'
           '            level = POLICY_LEVEL_RECOMMENDED;\n'
           '            break;\n'
           '          case em::PolicyOptions::UNSET:\n'
           '            break;\n'
           '        }\n'
           '      }\n'
           '      if (do_set) {\n')
   f.write('        base::Value* value = %s;\n' %
-          (_CreateValue(policy.value_type, 'policy_proto.value()')))
+          (_CreateValue(policy.policy_type, 'policy_proto.value()')))
+  f.write('        ExternalDataFetcher* external_data_fetcher = %s;\n' %
+          _CreateExternalDataFetcher(policy.policy_type, policy.name))
   f.write('        map->Set(key::k%s, level, POLICY_SCOPE_USER,\n' %
           policy.name)
-  f.write('                 value, NULL);\n')
+  f.write('                 value, external_data_fetcher);\n')
   f.write('      }\n'
           '    }\n'
           '  }\n')
 
 
 def _WriteCloudPolicyDecoder(policies, os, f):
   f.write(CPP_HEAD)
   for policy in policies:
     if policy.is_supported and not policy.is_device_only:
       _WritePolicyCode(f, policy)
   f.write(CPP_FOOT)
 
 
 if __name__ == '__main__':
   sys.exit(main())