Extensions Docs Server: Preserve JSON declaration order in extensions documentation

chrome/common/extensions/docs/server2/api_data_source.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 copy
-import json
 import logging
 import os
 
 import compiled_file_system as compiled_fs
 from file_system import FileNotFoundError
-import third_party.json_schema_compiler.json_comment_eater as json_comment_eater
+import third_party.json_schema_compiler.json_parse as json_parse
 import third_party.json_schema_compiler.model as model
 import third_party.json_schema_compiler.idl_schema as idl_schema
 import third_party.json_schema_compiler.idl_parser as idl_parser
 
 # Increment this version when there are changes to the data stored in any of
 # the caches used by APIDataSource. This allows the cache to be invalidated
 # without having to flush memcache on the production server.
-_VERSION = 3
+_VERSION = 4
 
 def _RemoveNoDocs(item):
-  if type(item) == dict:
+  if json_parse.IsDict(item):
     if item.get('nodoc', False):
       return True
     to_remove = []
     for key, value in item.items():
       if _RemoveNoDocs(value):
         to_remove.append(key)
     for k in to_remove:
       del item[k]
   elif type(item) == list:
     to_remove = []
@@ skipping 293 matching lines @@
                            self._idl_cache,
                            self._json_cache_no_refs,
                            self._idl_cache_no_refs,
                            self._names_cache,
                            self._idl_names_cache,
                            self._base_path,
                            samples,
                            disable_refs)
 
     def _LoadPermissions(self, json_str):
-      return json.loads(json_comment_eater.Nom(json_str))
+      return json_parse.Parse(json_str)
 
     def _LoadJsonAPI(self, api, disable_refs):
       return _JSCModel(
-          json.loads(json_comment_eater.Nom(api))[0],
+          json_parse.Parse(api)[0],
           self._ref_resolver_factory.Create() if not disable_refs else None,
           disable_refs).ToDict()
 
     def _LoadIdlAPI(self, api, disable_refs):
       idl = idl_parser.IDLParser().ParseData(api)
       return _JSCModel(
           idl_schema.IDLSchema(idl).process()[0],
           self._ref_resolver_factory.Create() if not disable_refs else None,
           disable_refs).ToDict()
 
@@ skipping 45 matching lines @@
     path = model.UnixName(path.replace('experimental_', ''))
     for filename in ['_permission_features.json', '_manifest_features.json']:
       api_perms = self._GetPermsFromFile(filename).get(path, None)
       if api_perms is not None:
         break
     if api_perms and api_perms['channel'] in ('trunk', 'dev', 'beta'):
       api_perms[api_perms['channel']] = True
     return api_perms
 
   def _GenerateHandlebarContext(self, handlebar_dict, path):
-    return_dict = {
-      'permissions': self._GetFeature(path),
-      'samples': _LazySamplesGetter(path, self._samples)
-    }
-    return_dict.update(handlebar_dict)
-    return return_dict
+    handlebar_dict['permissions'] = self._GetFeature(path)
+    handlebar_dict['samples'] = _LazySamplesGetter(path, self._samples)
+    return handlebar_dict
 
   def _GetAsSubdirectory(self, name):
     if name.startswith('experimental_'):
       parts = name[len('experimental_'):].split('_', 1)
       parts[1] = 'experimental_%s' % parts[1]
       return '/'.join(parts)
     return name.replace('_', '/', 1)
 
   def get(self, key):
     if key.endswith('.html') or key.endswith('.json') or key.endswith('.idl'):
       path, ext = os.path.splitext(key)
     else:
       path = key
     unix_name = model.UnixName(path)
     idl_names = self._idl_names_cache.GetFromFileListing(self._base_path)
     names = self._names_cache.GetFromFileListing(self._base_path)
     if unix_name not in names and self._GetAsSubdirectory(unix_name) in names:
       unix_name = self._GetAsSubdirectory(unix_name)
 
     if self._disable_refs:
       cache, ext = (
           (self._idl_cache_no_refs, '.idl') if (unix_name in idl_names) else
           (self._json_cache_no_refs, '.json'))
     else:
       cache, ext = ((self._idl_cache, '.idl') if (unix_name in idl_names) else
                     (self._json_cache, '.json'))
     return self._GenerateHandlebarContext(
         cache.GetFromFile('%s/%s%s' % (self._base_path, unix_name, ext)),
         path)