[Extensions] Use compiled feature files

tools/json_schema_compiler/feature_compiler.py

 # Copyright 2016 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.
 
 import argparse
 import copy
 from datetime import datetime
 import os
 
 from code import Code
@@ skipping 36 matching lines @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // GENERATED FROM THE FEATURES FILE:
 //   %(source_files)s
 // DO NOT EDIT.
 
 #include "%(header_file_path)s"
 
 #include "extensions/common/features/api_feature.h"
+#include "extensions/common/features/behavior_feature.h"
 #include "extensions/common/features/complex_feature.h"
+#include "extensions/common/features/manifest_feature.h"
+#include "extensions/common/features/permission_feature.h"
 
 namespace extensions {
 
 """
 
 # The end of the .cc file for the generated FeatureProvider.
 CC_FILE_END = """
 %(provider_class)s::~%(provider_class)s() {}
 
 }  // namespace extensions
@@ skipping 117 matching lines @@
         }
       }
     },
     'whitelist': {
       list: {'subtype': unicode}
     },
   })
 
 # These keys are used to find the parents of different features, but are not
 # compiled into the features themselves.
-IGNORED_KEYS = ['noparent', 'default_parent']
+IGNORED_KEYS = ['default_parent']
 
 # By default, if an error is encountered, assert to stop the compilation. This
 # can be disabled for testing.
 ENABLE_ASSERTIONS = True
 
 # JSON parsing returns all strings of characters as unicode types. For testing,
 # we can enable converting all string types to unicode to avoid writing u''
 # everywhere.
 STRINGS_TO_UNICODE = False
 
@@ skipping 117 matching lines @@
         if cpp_sub_value:
           cpp_value.append(cpp_sub_value)
       if cpp_value:
         cpp_value = '{' + ','.join(cpp_value) + '}'
     else:
       cpp_value = self._GetCheckedValue(key, expected_type, expected_values,
                                         enum_map, v)
 
     if cpp_value:
       self.feature_values[key] = cpp_value
+    elif key in self.feature_values:
+      # If the key is empty and this feature inherited a value from its parent,
+      # remove the inherited value.
+      del self.feature_values[key]
 
   def SetParent(self, parent):
     """Sets the parent of this feature, and inherits all properties from that
     parent.
     """
     assert not self.feature_values, 'Parents must be set before parsing'
     self.feature_values = copy.deepcopy(parent.feature_values)
     self.has_parent = True
 
   def Parse(self, parsed_json):
@@ skipping 46 matching lines @@
         print('FAILED: Exception encountered while loading "%s"' %
                   abs_source_file)
         raise
       dupes = set(f_json) & set(self._json)
       assert not dupes, 'Duplicate keys found: %s' % list(dupes)
       self._json.update(f_json)
 
   def _FindParent(self, feature_name, feature_value):
     """Checks to see if a feature has a parent. If it does, returns the
     parent."""
+    no_parent = False
+    if type(feature_value) is list:
+      no_parent_values = ['noparent' in v for v in feature_value]
+      no_parent = all(no_parent_values)
+      assert no_parent or not any(no_parent_values), (
+              '"%s:" All child features must contain the same noparent value' %
+                  feature_name)
+    else:
+      no_parent = 'noparent' in feature_value
     sep = feature_name.rfind('.')
-    if sep is -1 or 'noparent' in feature_value:
+    if sep is -1 or no_parent:
       return None
     parent_name = feature_name[:sep]
     if parent_name not in self._features:
       # TODO(devlin): It'd be kind of nice to be able to assert that the
       # deduced parent name is in our features, but some dotted features don't
       # have parents and also don't have noparent, e.g. system.cpu. We should
       # probably just noparent them so that we can assert this.
       #   raise KeyError('Could not find parent "%s" for feature "%s".' %
       #                      (parent_name, feature_name))
       return None
@@ skipping 13 matching lines @@
       assert feature_value['nocompile'], (
           'nocompile should only be true; otherwise omit this key.')
       return
     parent = self._FindParent(feature_name, feature_value)
     # Handle complex features, which are lists of simple features.
     if type(feature_value) is list:
       feature_list = []
       # This doesn't handle nested complex features. I think that's probably for
       # the best.
       for v in feature_value:
-        feature = Feature(feature_name)
-        if parent:
-          feature.SetParent(parent)
-        feature.Parse(v)
-        feature_list.append(feature)
+        try:
+          feature = Feature(feature_name)
+          if parent:
+            feature.SetParent(parent)
+          feature.Parse(v)
+          feature_list.append(feature)
+        except:
+          print('Failure to parse feature "%s"' % feature_name)
+          raise
       self._features[feature_name] = feature_list
       return
 
-    feature = Feature(feature_name)
-    if parent:
-      feature.SetParent(parent)
-    feature.Parse(feature_value)
-    self._features[feature_name] = feature
+    try:
+      feature = Feature(feature_name)
+      if parent:
+        feature.SetParent(parent)
+      feature.Parse(feature_value)
+      self._features[feature_name] = feature
+    except:
+      print('Failure to parse feature "%s"' % feature_name)
+      raise
 
   def Compile(self):
     """Parses all features after loading the input files."""
     self._Load();
     # Iterate over in sorted order so that parents come first.
     for k in sorted(self._json.keys()):
       self._CompileFeature(k, self._json[k])
 
   def Render(self):
     """Returns the Code object for the body of the .cc file, which handles the
@@ skipping 70 matching lines @@
       'out_base_filename', type=str,
       help='The base filename for the C++ files (.h and .cc will be appended)')
   parser.add_argument('source_files', type=str, nargs='+',
                       help='The source features.json files')
   args = parser.parse_args()
   c = FeatureCompiler(args.chrome_root, args.source_files, args.feature_class,
                       args.provider_class, args.out_root,
                       args.out_base_filename)
   c.Compile()
   c.Write()