log: move log file walk to its own function

This moves the logic that determines which changesets to process during a
'hg log foo.txt' command. Putting it in its own function allows extensions
to modify how the file log is traversed. For instance, the current
implementation uses filelog revs heavily. Other implementations may not have
filelog revs available.

The function throws an exception if the traversal is not possible via the
filelog, so the parent function can do things the slow way if necessary
(by walking the entire commit history).

Aside from the exception throwing, no logic is changed.

mercurial/cmdutil.py

@@ -1005,50 +1005,19 b' def increasingwindows(start, end, window'
             if windowsize < sizelimit:
                 windowsize *= 2
 
-def walkchangerevs(repo, match, opts, prepare):
-    '''Iterate over files and the revs in which they changed.
-
-    Callers most commonly need to iterate backwards over the history
-    in which they are interested. Doing so has awful (quadratic-looking)
-    performance, so we use iterators in a "windowed" way.
+class FileWalkError(Exception):
+    pass
 
-    We walk a window of revisions in the desired order.  Within the
-    window, we first walk forwards to gather data, then in the desired
-    order (usually backwards) to display it.
-
-    This function returns an iterator yielding contexts. Before
-    yielding each context, the iterator will first call the prepare
-    function on each context in the window in forward order.'''
-
-    follow = opts.get('follow') or opts.get('follow_first')
+def walkfilerevs(repo, match, follow, revs, fncache):
+    '''Walks the file history for the matched files.
 
-    if opts.get('rev'):
-        revs = scmutil.revrange(repo, opts.get('rev'))
-    elif follow:
-        revs = repo.revs('reverse(:.)')
-    else:
-        revs = list(repo)
-        revs.reverse()
-    if not revs:
-        return []
-    wanted = set()
-    slowpath = match.anypats() or (match.files() and opts.get('removed'))
-    fncache = {}
-    change = repo.changectx
+    Returns the changeset revs that are involved in the file history.
 
-    # First step is to fill wanted, the set of revisions that we want to yield.
-    # When it does not induce extra cost, we also fill fncache for revisions in
-    # wanted: a cache of filenames that were changed (ctx.files()) and that
-    # match the file filtering conditions.
-
-    if not slowpath and not match.files():
-        # No files, no patterns.  Display all revs.
-        wanted = set(revs)
+    Throws FileWalkError if the file history can't be walked using
+    filelogs alone.
+    '''
+    wanted = set()
     copies = []
-
-    if not slowpath and match.files():
-        # We only have to read through the filelog to find wanted revisions
-
         minrev, maxrev = min(revs), max(revs)
         def filerevgen(filelog, last):
             """
@@ -1090,6 +1059,7 b' def walkchangerevs(repo, match, opts, pr'
                     yield filename, None
             for filename_node in copies:
                 yield filename_node
+
         for file_, node in iterfiles():
             filelog = repo.file(file_)
             if not len(filelog):
@@ -1099,8 +1069,7 b' def walkchangerevs(repo, match, opts, pr'
                     if follow:
                         raise util.Abort(
                             _('cannot follow nonexistent file: "%s"') % file_)
-                    slowpath = True
-                    break
+                raise FileWalkError("Cannot walk via filelog")
                 else:
                     continue
 
@@ -1135,10 +1104,59 b' def walkchangerevs(repo, match, opts, pr'
                 if copied:
                     copies.append(copied)
 
+    return wanted
+
+def walkchangerevs(repo, match, opts, prepare):
+    '''Iterate over files and the revs in which they changed.
+
+    Callers most commonly need to iterate backwards over the history
+    in which they are interested. Doing so has awful (quadratic-looking)
+    performance, so we use iterators in a "windowed" way.
+
+    We walk a window of revisions in the desired order.  Within the
+    window, we first walk forwards to gather data, then in the desired
+    order (usually backwards) to display it.
+
+    This function returns an iterator yielding contexts. Before
+    yielding each context, the iterator will first call the prepare
+    function on each context in the window in forward order.'''
+
+    follow = opts.get('follow') or opts.get('follow_first')
+
+    if opts.get('rev'):
+        revs = scmutil.revrange(repo, opts.get('rev'))
+    elif follow:
+        revs = repo.revs('reverse(:.)')
+    else:
+        revs = list(repo)
+        revs.reverse()
+    if not revs:
+        return []
+    wanted = set()
+    slowpath = match.anypats() or (match.files() and opts.get('removed'))
+    fncache = {}
+    change = repo.changectx
+
+    # First step is to fill wanted, the set of revisions that we want to yield.
+    # When it does not induce extra cost, we also fill fncache for revisions in
+    # wanted: a cache of filenames that were changed (ctx.files()) and that
+    # match the file filtering conditions.
+
+    if not slowpath and not match.files():
+        # No files, no patterns.  Display all revs.
+        wanted = set(revs)
+
+    if not slowpath and match.files():
+        # We only have to read through the filelog to find wanted revisions
+
+        try:
+            wanted = walkfilerevs(repo, match, follow, revs, fncache)
+        except FileWalkError:
+            slowpath = True
+
         # We decided to fall back to the slowpath because at least one
         # of the paths was not a file. Check to see if at least one of them
         # existed in history, otherwise simply return
-        if slowpath:
             for path in match.files():
                 if path == '.' or path in repo.store:
                     break