Doc server: support interfaces in src/extensions

chrome/common/extensions/docs/server2/api_models.py

 # Copyright 2013 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 os
 import posixpath
 
 from compiled_file_system import SingleFile, Unicode
-from extensions_paths import API
+from extensions_paths import API, CORE_API
 from file_system import FileNotFoundError
 from future import Gettable, Future
 from schema_util import ProcessSchema
 from third_party.json_schema_compiler.model import Namespace, UnixName
 
 
 @SingleFile
 @Unicode
 def _CreateAPIModel(path, data):
   schema = ProcessSchema(path, data)[0]
@@ skipping 18 matching lines @@
     api_features = self._features_bundle.GetAPIFeatures().Get()
     return [name for name, feature in api_features.iteritems()
             if ('.' not in name or
                 name.rsplit('.', 1)[0] not in api_features or
                 feature.get('noparent'))]
 
   def GetModel(self, api_name):
     # Callers sometimes specify a filename which includes .json or .idl - if
     # so, believe them. They may even include the 'api/' prefix.
     if os.path.splitext(api_name)[1] in ('.json', '.idl'):
       if not api_name.startswith(API):

[not at google - send to devlin, 2014/03/06 22:16:21]

I guess this isn't a problem yet? I think it may become one at some point. You
might as well deal with it now. I.e. handle both API and CORE_API here.

[Ken Rockot(use gerrit already), 2014/03/06 23:55:16]

Done.

         api_name = posixpath.join(API, api_name)
       return self._model_cache.GetFromFile(api_name)
 
     assert not api_name.startswith(API)
 
     # API names are given as declarativeContent and app.window but file names
     # will be declarative_content and app_window.
     file_name = UnixName(api_name).replace('.', '_')
     # Devtools APIs are in API/devtools/ not API/, and have their
     # "devtools" names removed from the file names.
     basename = posixpath.basename(file_name)
     if 'devtools_' in basename:
       file_name = posixpath.join(
           'devtools', file_name.replace(basename,
                                         basename.replace('devtools_' , '')))
 
     futures = [self._model_cache.GetFromFile(
-                   posixpath.join(API, '%s.%s' % (file_name, ext)))
-               for ext in ('json', 'idl')]
+                   posixpath.join(api_path, '%s.%s' % (file_name, ext)))
+               for ext in ('json', 'idl')
+               for api_path in (API, CORE_API)]
     def resolve():
       for future in futures:
         try:
           return future.Get()
         except FileNotFoundError: pass
-      # Propagate the first FileNotFoundError if neither were found.
+      # Propagate the first FileNotFoundError if no files were found.
       futures[0].Get()
     return Future(delegate=Gettable(resolve))
 
   def IterModels(self):
     future_models = [(name, self.GetModel(name)) for name in self.GetNames()]
     for name, future_model in future_models:
       try:
         model = future_model.Get()
       except FileNotFoundError:
         continue
       if model:
         yield name, model