Further reduction of feature_compiler.py generated code

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 339 matching lines @@
     """Parses the feature from the given json value."""
     for key in parsed_json.keys():
       if key not in FEATURE_GRAMMAR:
         self._AddError(key, 'Unrecognized key')
     for key, key_grammar in FEATURE_GRAMMAR.iteritems():
       self._ParseKey(key, parsed_json, key_grammar)
 
   def GetCode(self, feature_class):
     """Returns the Code object for generating this feature."""
     c = Code()
-    c.Append('std::unique_ptr<%s> feature(new %s());' %
-                 (feature_class, feature_class))
+    c.Append('%s* feature(new %s());' % (feature_class, feature_class))
     c.Append('feature->set_name("%s");' % self.name)
     for key in sorted(self.feature_values.keys()):
       if key in IGNORED_KEYS:
         continue;
       c.Append('feature->set_%s(%s);' % (key, self.feature_values[key]))
     return c
 
 class FeatureCompiler(object):
   """A compiler to load, parse, and generate C++ code for a number of
   features.json files."""
@@ skipping 107 matching lines @@
   def Render(self):
     """Returns the Code object for the body of the .cc file, which handles the
     initialization of all features."""
     c = Code()
     c.Append('%s::%s() {' % (self._provider_class, self._provider_class))
     c.Sblock()
     for k in sorted(self._features.keys()):
       c.Sblock('{')
       feature = self._features[k]
       if type(feature) is list:
-        c.Append('std::unique_ptr<ComplexFeature::FeatureList> features(')
-        c.Append('    new ComplexFeature::FeatureList());')
+        c.Append('ComplexFeature::FeatureList* features('
+                 'new ComplexFeature::FeatureList());')
         for f in feature:
           c.Sblock('{')
           c.Concat(f.GetCode(self._feature_class))
-          c.Append('features->push_back(std::move(feature));')
+          c.Append('features->push_back(feature);')
           c.Eblock('}')
-        c.Append('std::unique_ptr<ComplexFeature> feature(')
-        c.Append('    new ComplexFeature(std::move(features)));')
+        c.Append('ComplexFeature* feature(new ComplexFeature(features));')
         c.Append('feature->set_name("%s");' % k)
       else:
         c.Concat(feature.GetCode(self._feature_class))
-      c.Append('AddFeature("%s", std::move(feature));' % k)
+      c.Append('AddFeature("%s", feature);' % k)
       c.Eblock('}')
     c.Eblock('}')
     return c
 
   def Write(self):
     """Writes the output."""
     header_file_path = self._out_base_filename + '.h'
     cc_file_path = self._out_base_filename + '.cc'
     substitutions = ({
         'header_file_path': header_file_path,
@@ skipping 39 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()