Fix generate_policy_source.py to honour supported_on ranges.

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 44 matching lines @@
                         'choice'),
     'string-enum-list': ('TYPE_LIST',         'StringList',   'StringList',
                         'multi-select'),
   }
 
   class EnumItem:
     def __init__(self, item):
       self.caption = PolicyDetails._RemovePlaceholders(item['caption'])
       self.value = item['value']
 
-  def __init__(self, policy, os, is_chromium_os):
+  def __init__(self, policy, chrome_major_version, os, is_chromium_os):
     self.id = policy['id']
     self.name = policy['name']
     features = policy.get('features', {})
     self.can_be_recommended = features.get('can_be_recommended', False)
     self.can_be_mandatory = features.get('can_be_mandatory', True)
     self.is_deprecated = policy.get('deprecated', False)
     self.is_device_only = policy.get('device_only', False)
     self.schema = policy.get('schema', {})
     self.has_enterprise_default = 'default_for_enterprise_users' in policy
     if self.has_enterprise_default:
       self.enterprise_default = policy['default_for_enterprise_users']
 
     expected_platform = 'chrome_os' if is_chromium_os else os.lower()
     self.platforms = []
-    for platform, version in [ p.split(':') for p in policy['supported_on'] ]:
-      if not version.endswith('-'):
+    for platform, version_range in [ p.split(':')
+                                     for p in policy['supported_on'] ]:
+      split_result = version_range.split('-')
+      if len(split_result) != 2:
+        raise RuntimeError('supported_on must have exactly one dash: "%s"' % p)
+      (version_min, version_max) = split_result
+      if version_min == '':
+        raise RuntimeError('supported_on must define a start version: "%s"' % p)
+
+      # Skip if the current Chromium version does not support the policy.
+      if (int(version_min) > chrome_major_version or
+          version_max != '' and int(version_max) < chrome_major_version):
         continue
 
       if platform.startswith('chrome.'):
         platform_sub = platform[7:]
         if platform_sub == '*':
           self.platforms.extend(['win', 'mac', 'linux'])
         else:
           self.platforms.append(platform_sub)
       else:
         self.platforms.append(platform)
@@ skipping 28 matching lines @@
     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)
       pos = m.end(0)
     result += text[pos:]
     return result
 
 
+def ParseVersionFile(version_path):
+  major_version = None
+  for line in open(version_path, 'r').readlines():
+    key, val = line.rstrip('\r\n').split('=', 1)
+    if key == 'MAJOR':
+      major_version = val
+      break
+  if major_version is None:
+    raise RuntimeError('VERSION file does not contain major version.')
+  return major_version
+
+
 def main():
   parser = OptionParser(usage=__doc__)
   parser.add_option('--pch', '--policy-constants-header', dest='header_path',
                     help='generate header file of policy constants',
                     metavar='FILE')
   parser.add_option('--pcc', '--policy-constants-source', dest='source_path',
                     help='generate source file of policy constants',
                     metavar='FILE')
   parser.add_option('--cpp', '--cloud-policy-protobuf',
                     dest='cloud_policy_proto_path',
                     help='generate cloud policy protobuf file',
                     metavar='FILE')
   parser.add_option('--csp', '--chrome-settings-protobuf',
                     dest='chrome_settings_proto_path',
                     help='generate chrome settings protobuf file',
                     metavar='FILE')
   parser.add_option('--cpd', '--cloud-policy-decoder',
                     dest='cloud_policy_decoder_path',
                     help='generate C++ code decoding the cloud policy protobuf',
                     metavar='FILE')
   parser.add_option('--ard', '--app-restrictions-definition',
                     dest='app_restrictions_path',
                     help='generate an XML file as specified by '
                     'Android\'s App Restriction Schema',
                     metavar='FILE')
 
   (opts, args) = parser.parse_args()
 
-  if len(args) != 3:
-    print 'exactly platform, chromium_os flag and input file must be specified.'
+  if len(args) != 4:
+    print('Please specify path to src/chrome/VERSION, platform, '
+          'chromium_os flag and input file as positional parameters.')
     parser.print_help()
     return 2
 
-  os = args[0]
-  is_chromium_os = args[1] == '1'
-  template_file_name = args[2]
+  version_path = args[0]
+  os = args[1]
+  is_chromium_os = args[2] == '1'
+  template_file_name = args[3]
 
+  major_version = ParseVersionFile(version_path)
   template_file_contents = _LoadJSONFile(template_file_name)
-  policy_details = [ PolicyDetails(policy, os, is_chromium_os)
+  policy_details = [ PolicyDetails(policy, major_version, os, is_chromium_os)
                      for policy in _Flatten(template_file_contents) ]
   sorted_policy_details = sorted(policy_details, key=lambda policy: policy.name)
 
   def GenerateFile(path, writer, sorted=False, xml=False):
     if path:
       with open(path, 'w') as f:
         _OutputGeneratedWarningHeader(f, template_file_name, xml)
         writer(sorted and sorted_policy_details or policy_details, os, f)
 
   GenerateFile(opts.header_path, _WritePolicyConstantHeader, sorted=True)
@@ skipping 844 matching lines @@
   # _WriteAppRestrictions body
   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':
       WriteAppRestriction(policy)
   f.write('</restrictions>')
 
 if __name__ == '__main__':
   sys.exit(main())