Add additional restriction to policy schema internal (part1)

components/policy/tools/generate_policy_source.py

Index: components/policy/tools/generate_policy_source.py
diff --git a/components/policy/tools/generate_policy_source.py b/components/policy/tools/generate_policy_source.py
index 315650de2510ed9de2adaabfd24361db4e36c3d3..694141fecf27f2e9b68214fb0473002366943578 100755
--- a/components/policy/tools/generate_policy_source.py
+++ b/components/policy/tools/generate_policy_source.py
@@ -257,7 +257,6 @@ SIMPLE_SCHEMA_NAME_MAP = {
   'string' : 'TYPE_STRING',
 }
 
-
 class SchemaNodesGenerator:
   """Builds the internal structs to represent a JSON schema."""
 
@@ -271,6 +270,9 @@ class SchemaNodesGenerator:
     self.schema_nodes = []
     self.property_nodes = []
     self.properties_nodes = []
+    self.restriction_nodes = []
+    self.int_enums = []
+    self.string_enums = []
     self.simple_types = {
       'boolean': None,
       'integer': None,
@@ -288,6 +290,11 @@ class SchemaNodesGenerator:
     self.schema_nodes.append((type, extra, comment))
     return index
 
+  def AppendRestriction(self, first, second):
+    index = len(self.restriction_nodes)
+    self.restriction_nodes.append((str(first), str(second)))
+    return index

[Joao da Silva, 2014/01/20 10:49:10]

If you look at the output you'll see that there are duplicated range
restrictions, because many enums are [0, 1, 2] or many policies have only
"minimum: 0". For those cases we can reuse the same RestrictionNode. Suggestion:

- add a list of ranges that already exist to self in __init__ above:

  self.ranges = {}

- if (first, second) already exists in self.ranges then reuse that index:

  r = (str(first), str(second))
  if not r in self.ranges:
    self.ranges[r] = len(self.restriction_nodes)
    self.restriction_nodes.append(r)
  return self.ranges[r]

[binjin, 2014/01/20 14:09:23]

Done.

+
   def GetSimpleType(self, name):
     if self.simple_types[name] == None:
       self.simple_types[name] = self.AppendSchema(
@@ -304,14 +311,81 @@ class SchemaNodesGenerator:
           'simple type: stringlist')
     return self.stringlist_type
 
+  def SchemaHaveRestriction(self, schema):
+    return 'minimum' in schema or 'maximum' in schema or 'enum' in schema
+
+  def isConsecutiveInterval(self, seq):

[Joao da Silva, 2014/01/20 10:49:10]

Start the function name with a capital letter:

  def IsConsecutiveInterval

[binjin, 2014/01/20 14:09:23]

Done.

+    if len(seq) == 1:
+      return True

[Joao da Silva, 2014/01/20 10:49:10]

This special case is not needed; xrange(0) will be empty, and all([]) is True.

[binjin, 2014/01/20 14:09:23]

Done.

+    sortedSeq = sorted(seq)
+    return all(sortedSeq[i] + 1 == sortedSeq[i + 1]
+               for i in xrange(len(sortedSeq) - 1))
+
+  def GetEnumIntegerType(self, schema, name):
+    assert all(type(x) == int for x in schema['enum'])
+    possible_values = schema['enum']
+    if self.isConsecutiveInterval(possible_values):
+      index = self.AppendRestriction(max(possible_values), min(possible_values))
+      return self.AppendSchema('TYPE_INTEGER', index,
+          'integer with enumeration restriction(use ranged instead): %s' % name)

[Joao da Silva, 2014/01/20 10:49:10]

nit: space before (, "used range instead":

[binjin, 2014/01/20 14:09:23]

Done.

+    offset_begin = len(self.int_enums)
+    self.int_enums += possible_values
+    offset_end = len(self.int_enums)
+    return self.AppendSchema('TYPE_INTEGER',
+        self.AppendRestriction(offset_begin, offset_end),
+        'integer with enumeration restriction: %s' % name)
+
+  def GetEnumStringType(self, schema, name):
+    assert all(type(x) == str for x in schema['enum'])
+    offset_begin = len(self.string_enums)
+    self.string_enums += schema['enum']
+    offset_end = len(self.string_enums)
+    return self.AppendSchema('TYPE_STRING',
+        self.AppendRestriction(offset_begin, offset_end),
+        'string with enumeration restriction: %s' % name)
+
+  def GetEnumType(self, schema, name):
+    if len(schema['enum']) == 0:
+      raise RuntimeError('Empty enumeration in %s' % name)
+    elif schema['type'] == 'integer':
+      return self.GetEnumIntegerType(schema, name)
+    elif schema['type'] == 'string':
+      return self.GetEnumStringType(schema, name)
+    else:
+      raise RuntimeError('Unknown enumeration type in %s' % name)
+
+  def GetRangedType(self, schema, name):
+    if schema['type'] != 'integer':
+      raise RuntimeError('Unknown ranged type in %s' % name)
+    min_value_set, max_value_set = False, False
+    if 'minimum' in schema:
+      min_value = int(schema['minimum'])
+      min_value_set = True
+    if 'maximum' in schema:
+      max_value = int(schema['minimum'])
+      max_value_set = True
+    if min_value_set and max_value_set and min_value > max_value:
+      raise RuntimeError('Invalid ranged type in %s' % name)
+    index = self.AppendRestriction(
+        str(max_value) if max_value_set else 'INT_MAX',
+        str(min_value) if min_value_set else 'INT_MIN')
+    return self.AppendSchema('TYPE_INTEGER',
+        index,
+        'integer with ranged restriction: %s' % name)
+
   def Generate(self, schema, name):
     """Generates the structs for the given schema.
 
     |schema|: a valid JSON schema in a dictionary.
     |name|: the name of the current node, for the generated comments."""
-    # Simple types use shared nodes.
     if schema['type'] in self.simple_types:
-      return self.GetSimpleType(schema['type'])
+      if not self.SchemaHaveRestriction(schema):
+        # Simple types use shared nodes.
+        return self.GetSimpleType(schema['type'])
+      elif 'enum' in schema:
+        return self.GetEnumType(schema, name)
+      else:
+        return self.GetRangedType(schema, name)
 
     if schema['type'] == 'array':
       # Special case for lists of strings, which is a common policy type.
@@ -380,17 +454,37 @@ class SchemaNodesGenerator:
       f.write('  { %5d, %5d, %5d },  // %s\n' % node)
     f.write('};\n\n')
 
+    f.write('const internal::RestrictionNode kRestrictionNodes[] = {\n')
+    f.write('//   FIRST, SECOND\n')
+    for first, second in self.restriction_nodes:
+      f.write('  {{ %-8s %4s}},\n' % (first + ',', second))
+    f.write('};\n\n')
+
+    f.write('const int kIntegerEnumerations[] = {\n')
+    for possible_values in self.int_enums:
+      f.write('  %d,\n' % possible_values)
+    f.write('};\n\n')
+
+    f.write('const char* kStringEnumerations[] = {\n')
+    for possible_values in self.string_enums:
+      f.write('  %s,\n' % self.GetString(possible_values))
+    f.write('};\n\n')
+
     f.write('const internal::SchemaData kChromeSchemaData = {\n'
             '  kSchemas,\n'
             '  kPropertyNodes,\n'
-            '  kProperties,\n'
-            '};\n\n')
+            '  kProperties,\n');
+    f.write('  kRestrictionNodes,\n' if self.restriction_nodes else '  NULL,\n')
+    f.write('  kIntegerEnumerations,\n' if self.int_enums else '  NULL,\n')
+    f.write('  kStringEnumerations,\n' if self.string_enums else '  NULL,\n')
+    f.write('};\n\n')
 
 
 def _WritePolicyConstantSource(policies, os, f):
   f.write('#include "policy/policy_constants.h"\n'
           '\n'
           '#include <algorithm>\n'
+          '#include <climits>\n'
           '\n'
           '#include "base/logging.h"\n'
           '#include "components/policy/core/common/schema_internal.h"\n'