infinitepush: ensure fileindex bookmarks use '/' separators (issue5840)

After loading up with status messages, I noticed that the subsequent matcher was
rejecting 'scratch\mybranch' on Windows.  No bookmarks were reported back, and
the tests subsequently failed.  I did a search for 'match', and nothing else
looks like it needs to be fixed up, but someone who understands this code should
also take a look.

I also tried setting `infinitepush.branchpattern=re:scratch\\.*` in
library-infinitepush.sh without this change, but that didn't work.  Still,
should we ban '\' in these bookmarks to avoid confusion?  I thought I saw code
that sandwiches a pattern between 're:^' and '.*', so perhaps regex characters
will need special care?

I also noticed comments in externalbundlestore.{read,write} that it won't work
on Windows because of opening an open file.  But I don't see a test failure, so
this may lack test coverage.

hgext/infinitepush/fileindexapi.py

@@ -1,107 +1,110 b''
 # Infinite push
 #
 # Copyright 2016 Facebook, Inc.
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 """
     [infinitepush]
     # Server-side option. Used only if indextype=disk.
     # Filesystem path to the index store
     indexpath = PATH
 """
 
 from __future__ import absolute_import
 
 import os
 
+from mercurial import util
+
 from mercurial.utils import stringutil
 
 from . import indexapi
 
 class fileindexapi(indexapi.indexapi):
     def __init__(self, repo):
         super(fileindexapi, self).__init__()
         self._repo = repo
         root = repo.ui.config('infinitepush', 'indexpath')
         if not root:
             root = os.path.join('scratchbranches', 'index')
 
         self._nodemap = os.path.join(root, 'nodemap')
         self._bookmarkmap = os.path.join(root, 'bookmarkmap')
         self._metadatamap = os.path.join(root, 'nodemetadatamap')
         self._lock = None
 
     def __enter__(self):
         self._lock = self._repo.wlock()
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         if self._lock:
             self._lock.__exit__(exc_type, exc_val, exc_tb)
 
     def addbundle(self, bundleid, nodesctx):
         for node in nodesctx:
             nodepath = os.path.join(self._nodemap, node.hex())
             self._write(nodepath, bundleid)
 
     def addbookmark(self, bookmark, node):
         bookmarkpath = os.path.join(self._bookmarkmap, bookmark)
         self._write(bookmarkpath, node)
 
     def addmanybookmarks(self, bookmarks):
         for bookmark, node in bookmarks.items():
             self.addbookmark(bookmark, node)
 
     def deletebookmarks(self, patterns):
         for pattern in patterns:
             for bookmark, _ in self._listbookmarks(pattern):
                 bookmarkpath = os.path.join(self._bookmarkmap, bookmark)
                 self._delete(bookmarkpath)
 
     def getbundle(self, node):
         nodepath = os.path.join(self._nodemap, node)
         return self._read(nodepath)
 
     def getnode(self, bookmark):
         bookmarkpath = os.path.join(self._bookmarkmap, bookmark)
         return self._read(bookmarkpath)
 
     def getbookmarks(self, query):
         return dict(self._listbookmarks(query))
 
     def saveoptionaljsonmetadata(self, node, jsonmetadata):
         vfs = self._repo.vfs
         vfs.write(os.path.join(self._metadatamap, node), jsonmetadata)
 
     def _listbookmarks(self, pattern):
         if pattern.endswith('*'):
             pattern = 're:^' + pattern[:-1] + '.*'
         kind, pat, matcher = stringutil.stringmatcher(pattern)
         prefixlen = len(self._bookmarkmap) + 1
         for dirpath, _, books in self._repo.vfs.walk(self._bookmarkmap):
             for book in books:
                 bookmark = os.path.join(dirpath, book)[prefixlen:]
+                bookmark = util.pconvert(bookmark)
                 if not matcher(bookmark):
                     continue
                 yield bookmark, self._read(os.path.join(dirpath, book))
 
     def _write(self, path, value):
         vfs = self._repo.vfs
         dirname = vfs.dirname(path)
         if not vfs.exists(dirname):
             vfs.makedirs(dirname)
 
         vfs.write(path, value)
 
     def _read(self, path):
         vfs = self._repo.vfs
         if not vfs.exists(path):
             return None
         return vfs.read(path)
 
     def _delete(self, path):
         vfs = self._repo.vfs
         if not vfs.exists(path):
             return
         return vfs.unlink(path)