Move the "extension" namespace from extension_api.json into extension_api_extension.json.

chrome/common/extensions/docs/build/directory.py

 #!/usr/bin/python
 # Copyright (c) 2011 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.
 
 """Class for parsing metadata about extension samples."""
 
 import locale
 import os
 import os.path
@@ skipping 39 matching lines @@
   try:
     json_obj = json.load(json_file, encoding)
   except ValueError, msg:
     raise Exception("Failed to parse JSON out of file %s: %s" % (path, msg))
   finally:
     json_file.close()
 
   return json_obj
 
 class ApiManifest(object):
-  """ Represents the list of API methods contained in extension_api.json """
+  """ Represents the list of API methods contained in the extension API JSON """
 
   _MODULE_DOC_KEYS = ['functions', 'events']
   """ Keys which may be passed to the _parseModuleDocLinksByKey method."""
 
   def __init__(self, manifest_paths):
     """ Read the supplied manifest file and parse its contents.
 
     Args:
-      manifest_paths: Array of paths to API schemas (extension_api.json etc).
+      manifest_paths: Array of paths to API schemas.
     """
     self._manifest = [];
     for path in manifest_paths:
       self._manifest.extend(parse_json_file(path))
 
   def _getDocLink(self, method, hashprefix):
     """
     Given an API method, return a partial URL corresponding to the doc
     file for that method.
 
     Args:
       method: A string like 'chrome.foo.bar' or 'chrome.experimental.foo.onBar'
       hashprefix: The prefix to put in front of hash links - 'method' for
           methods and 'event' for events.
 
     Returns:
       A string like 'foo.html#method-bar' or 'experimental.foo.html#event-onBar'
     """
     urlpattern = '%%s.html#%s-%%s' % hashprefix
     urlparts = tuple(method.replace('chrome.', '').rsplit('.', 1))
     return urlpattern % urlparts
 
   def _parseModuleDocLinksByKey(self, module, key):
     """
     Given a specific API module, returns a dict of methods or events mapped to
     documentation URLs.
 
     Args:
-      module: The data in extension_api.json corresponding to a single module.
+      module: The data in the extension API JSON for a single module.
       key: A key belonging to _MODULE_DOC_KEYS to determine which set of
           methods to parse, and what kind of documentation URL to generate.
 
     Returns:
       A dict of extension methods mapped to file and hash URL parts for the
       corresponding documentation links, like:
         {
           "chrome.tabs.remove": "tabs.html#method-remove",
           "chrome.tabs.onDetached" : "tabs.html#event-onDetatched"
         }
@@ skipping 23 matching lines @@
   def getModuleNames(self):
     """ Returns the names of individual modules in the API.
 
     Returns:
       The namespace """
     # Exclude modules with a "nodoc" property.
     return set(module['namespace'].encode() for module in self._manifest
                if "nodoc" not in module)
 
   def getDocumentationLinks(self):
-    """ Parses the extension_api.json manifest and returns a dict of all
+    """ Parses the extension API JSON manifest and returns a dict of all
     events and methods for every module, mapped to relative documentation links.
 
     Returns:
       A dict of methods/events => partial doc links for every module.
     """
     api_dict = {}
     for module in self._manifest:
       api_dict.update(self._parseModuleDocLinksByKey(module, 'functions'))
       api_dict.update(self._parseModuleDocLinksByKey(module, 'events'))
     return api_dict
@@ skipping 562 matching lines @@
           zip_file.write(abspath, relpath)
           if file == 'manifest.json':
             info = zip_file.getinfo(zip_manifest_path)
             info.comment = self['source_hash']
     except RuntimeError, msg:
       raise Exception("Could not write zip at %s: %s" % (zip_path, msg))
     finally:
       zip_file.close()
 
     return self._get_relative_zip_path()