[Extensions] Trim some fat around what we use in generated schemas

tools/json_schema_compiler/cpp_bundle_generator.py

 # 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.
 
 import code
 import cpp_util
 from model import Platforms
 from schema_util import CapitalizeFirstLetter
 from schema_util import JsFunctionNameToClassName
 
+import copy
 import json
 import os
 import re
 
 
-def _RemoveDescriptions(node):
-  """Returns a copy of |schema| with "description" fields removed.
+def _RemoveKey(node, key, type_restriction):
+  if isinstance(node, dict):
+    if key in node and isinstance(node[key], type_restriction):
+      del node[key]
+    for value in node.values():
+      _RemoveKey(value, key, type_restriction)
+  elif isinstance(node, list):
+    for value in node:
+      _RemoveKey(value, key, type_restriction)
+
+def _RemoveUnneededFields(schema):
+  """Returns a copy of |schema| with fields that aren't necessary at runtime
+  removed.
   """
-  if isinstance(node, dict):
-    result = {}
-    for key, value in node.items():
-      # Some schemas actually have properties called "description", so only
-      # remove descriptions that have string values.
-      if key == 'description' and isinstance(value, basestring):
-        continue
-      result[key] = _RemoveDescriptions(value)
-    return result
-  if isinstance(node, list):
-    return [_RemoveDescriptions(v) for v in node]
-  return node
+  # Return a copy so that we don't pollute the global api object, which may be
+  # used elsewhere.
+  ret = copy.deepcopy(schema)

[Devlin, 2016/08/22 17:08:58]

Note: I changed this (back) to returning a copy, because I realized we might not
want to change the api object itself if it will be used in other compilations.

+  _RemoveKey(ret, "description", basestring)
+  _RemoveKey(ret, "compiler_options", dict)
+  _RemoveKey(ret, "nodoc", bool)
+  _RemoveKey(ret, "noinline_doc", bool)
+  return ret
 
 
 class CppBundleGenerator(object):
   """This class contains methods to generate code based on multiple schemas.
   """
 
   def __init__(self,
                root,
                model,
                api_defs,
@@ skipping 235 matching lines @@
     c.Append()
     c.Append('#include "%s"' % (os.path.join(self._bundle._source_file_dir,
                                              'generated_schemas.h')))
     c.Append()
     c.Append('#include "base/lazy_instance.h"')
     c.Append()
     c.Append('namespace {')
     for api in self._bundle._api_defs:
       namespace = self._bundle._model.namespaces[api.get('namespace')]
       # JSON parsing code expects lists of schemas, so dump a singleton list.
-      json_content = json.dumps([_RemoveDescriptions(api)],
+      json_content = json.dumps([_RemoveUnneededFields(api)],
                                 separators=(',', ':'))
       # Escape all double-quotes and backslashes. For this to output a valid
       # JSON C string, we need to escape \ and ". Note that some schemas are
       # too large to compile on windows. Split the JSON up into several
       # strings, since apparently that helps.
       max_length = 8192
       segments = [json_content[i:i + max_length].replace('\\', '\\\\')
                                                 .replace('"', '\\"')
                   for i in xrange(0, len(json_content), max_length)]
       c.Append('const char %s[] = "%s";' %
@@ skipping 25 matching lines @@
     c.Append()
     c.Append('// static')
     c.Sblock('bool %s::IsGenerated(std::string name) {' %
              self._bundle._GenerateBundleClass('GeneratedSchemas'))
     c.Append('return g_lazy_instance.Get().schemas.count(name) > 0;')
     c.Eblock('}')
     c.Append()
     c.Concat(cpp_util.CloseNamespace(self._bundle._cpp_namespace))
     c.Append()
     return c