Docserver: Clean up APIListDataSourceTest a bit by constructing a full

chrome/common/extensions/docs/server2/api_list_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.
 
 from operator import itemgetter
 import os
+import posixpath
 
-from third_party.json_schema_compiler.json_parse import Parse
-import third_party.json_schema_compiler.model as model
+from svn_constants import PUBLIC_TEMPLATE_PATH
 import docs_server_utils as utils
 
 def _GetAPICategory(api, documented_apis):
   name = api['name']
   if (name.endswith('Private') or
       name not in documented_apis):
     return 'private'
   if name.startswith('experimental.'):
     return 'experimental'
   return 'chrome'
@@ skipping 11 matching lines @@
     - It has an "extension_types" property in _api_features with either/both
       "extension"/"platform_app" values present.
     - It has a dependency in _{api,manifest,permission}_features with an
       "extension_types" property where either/both "extension"/"platform_app"
       values are present.
   """
   class Factory(object):
     def __init__(self,
                  compiled_fs_factory,
                  file_system,
-                 public_template_path,
                  features_bundle,
                  object_store_creator):
       self._file_system = file_system
-      def NormalizePath(string):
-        return string if string.endswith('/') else (string + '/')
-      self._public_template_path = NormalizePath(public_template_path)
       self._cache = compiled_fs_factory.Create(file_system,
                                                self._CollectDocumentedAPIs,
                                                APIListDataSource)
       self._features_bundle = features_bundle
       self._object_store_creator = object_store_creator
 
     def _CollectDocumentedAPIs(self, base_dir, files):
       def GetDocumentedAPIsForPlatform(names, platform):
         public_templates = []
-        for root, _, files in self._file_system.Walk(
-            self._public_template_path + platform):
+        for root, _, files in self._file_system.Walk(posixpath.join(
+            PUBLIC_TEMPLATE_PATH, platform)):
           public_templates.extend(
               ('%s/%s' % (root, name)).lstrip('/') for name in files)
         template_names = set(os.path.splitext(name)[0]
                              for name in public_templates)
         return [name.replace('_', '.') for name in template_names]
       api_names = set(utils.SanitizeAPIName(name) for name in files)
       return {
         'apps': GetDocumentedAPIsForPlatform(api_names, 'apps'),
         'extensions': GetDocumentedAPIsForPlatform(api_names, 'extensions')
       }
 
     def _GenerateAPIDict(self):
       documented_apis = self._cache.GetFromFileListing(
-          self._public_template_path).Get()
+          PUBLIC_TEMPLATE_PATH).Get()
       api_features = self._features_bundle.GetAPIFeatures()
 
       def FilterAPIs(platform):
         return (api for api in api_features.itervalues()
             if platform in api['platforms'])
 
       def MakeDictForPlatform(platform):
         platform_dict = { 'chrome': [], 'experimental': [], 'private': [] }
         for api in FilterAPIs(platform):
           category = _GetAPICategory(api, documented_apis[platform])
@@ skipping 17 matching lines @@
 
   def _GetCachedAPIData(self):
     data = self._object_store.Get('api_data').Get()
     if data is None:
       data = self._factory._GenerateAPIDict()
       self._object_store.Set('api_data', data)
     return data
 
   def get(self, key):
     return self._GetCachedAPIData().get(key)