Docserver: Remove instances of _GetAsyncFetchCallback()

chrome/common/extensions/docs/server2/subversion_file_system.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 posixpath
 import traceback
 import xml.dom.minidom as xml
 from xml.parsers.expat import ExpatError
 
 from appengine_url_fetcher import AppEngineUrlFetcher
@@ skipping 77 matching lines @@
         version = int(_InnerText(version_element))
       except StandardError:
         continue
       child_versions[name] = str(version)
 
     if parent_version and child_versions:
       break
 
   return StatInfo(parent_version, child_versions)
 
-def _GetAsyncFetchCallback(paths, fetcher, args=None, skip_not_found=False):
-  def apply_args(path):
-    return path if args is None else '%s?%s' % (path, args)
-
-  def list_dir(directory):
-    dom = xml.parseString(directory)
-    files = [elem.childNodes[0].data for elem in dom.getElementsByTagName('a')]
-    if '..' in files:
-      files.remove('..')
-    return files
-
-  # A list of tuples of the form (path, Future).
-  fetches = [(path, fetcher.FetchAsync(apply_args(path))) for path in paths]
-
-  def resolve():
-    value = {}
-    for path, future in fetches:
-      try:
-        result = future.Get()
-      except Exception as e:
-        if skip_not_found and IsDownloadError(e): continue
-        exc_type = FileNotFoundError if IsDownloadError(e) else FileSystemError
-        raise exc_type('%s fetching %s for Get: %s' %
-                       (type(e).__name__, path, traceback.format_exc()))
-      if result.status_code == 404:
-        if skip_not_found: continue
-        raise FileNotFoundError('Got 404 when fetching %s for Get, content %s' %
-            (path, result.content))
-      if result.status_code != 200:
-        raise FileSystemError('Got %s when fetching %s for Get, content %s' %
-            (result.status_code, path, result.content))
-      if path.endswith('/'):
-        value[path] = list_dir(result.content)
-      else:
-        value[path] = result.content
-    return value
-
-  return resolve
 
 class SubversionFileSystem(FileSystem):
   '''Class to fetch resources from src.chromium.org.
   '''
   @staticmethod
   def Create(branch='trunk', revision=None):
     if branch == 'trunk':
       svn_path = 'trunk/src'
     else:
       svn_path = 'branches/%s/src' % branch
     return SubversionFileSystem(
         AppEngineUrlFetcher('%s/%s' % (url_constants.SVN_URL, svn_path)),
         AppEngineUrlFetcher('%s/%s' % (url_constants.VIEWVC_URL, svn_path)),
         svn_path,
         revision=revision)
 
   def __init__(self, file_fetcher, stat_fetcher, svn_path, revision=None):
     self._file_fetcher = file_fetcher
     self._stat_fetcher = stat_fetcher
     self._svn_path = svn_path
     self._revision = revision
 
   def Read(self, paths, skip_not_found=False):
     args = None
     if self._revision is not None:
       # |fetcher| gets from svn.chromium.org which uses p= for version.
       args = 'p=%s' % self._revision
-    return Future(callback=_GetAsyncFetchCallback(
-        paths,
-        self._file_fetcher,
-        args=args,
-        skip_not_found=skip_not_found))
+
+    def apply_args(path):
+      return path if args is None else '%s?%s' % (path, args)
+
+    def list_dir(directory):
+      dom = xml.parseString(directory)
+      files = [elem.childNodes[0].data
+               for elem in dom.getElementsByTagName('a')]
+      if '..' in files:
+        files.remove('..')
+      return files
+
+    # A list of tuples of the form (path, Future).
+    fetches = [(path, self._file_fetcher.FetchAsync(apply_args(path)))
+               for path in paths]
+
+    def resolve():
+      value = {}
+      for path, future in fetches:
+        try:
+          result = future.Get()
+        except Exception as e:
+          if skip_not_found and IsDownloadError(e): continue
+          exc_type = (FileNotFoundError if IsDownloadError(e)
+                                       else FileSystemError)
+          raise exc_type('%s fetching %s for Get: %s' %
+                         (type(e).__name__, path, traceback.format_exc()))
+        if result.status_code == 404:
+          if skip_not_found: continue
+          raise FileNotFoundError(
+              'Got 404 when fetching %s for Get, content %s' %
+              (path, result.content))
+        if result.status_code != 200:
+          raise FileSystemError('Got %s when fetching %s for Get, content %s' %
+              (result.status_code, path, result.content))
+        if path.endswith('/'):
+          value[path] = list_dir(result.content)
+        else:
+          value[path] = result.content
+      return value
+    return Future(callback=resolve)
 
   def Refresh(self):
     return Future(value=())
 
   def Stat(self, path):
     return self.StatAsync(path).Get()
 
   def StatAsync(self, path):
     directory, filename = posixpath.split(path)
     if self._revision is not None:
@@ skipping 27 matching lines @@
       return StatInfo(stat_info.child_versions[filename])
 
     return Future(callback=resolve)
 
   def GetIdentity(self):
     # NOTE: no revision here, since it would mess up the caching of reads. It
     # probably doesn't matter since all the caching classes will use the result
     # of Stat to decide whether to re-read - and Stat has a ceiling of the
     # revision - so when the revision changes, so might Stat. That is enough.
     return '@'.join((self.__class__.__name__, StringIdentity(self._svn_path)))