flagprocessors: make `processflagsread` a module level function

One more steps toward removing the mixin.

Differential Revision: https://phab.mercurial-scm.org/D6819

hgext/remotefilelog/remotefilelog.py

@@ -328,8 +328,7 b' class remotefilelog(flagutil.flagprocess'
         flags = store.getmeta(self.filename, node).get(constants.METAKEYFLAG, 0)
         if flags == 0:
             return rawtext
-        text, verifyhash, sidedata = self._processflagsread(rawtext, flags)
-        return text
+        return flagutil.processflagsread(self, rawtext, flags)[0]
 
     def rawdata(self, node):
         return self.revision(node, raw=False)

mercurial/revlog.py

@@ -1663,7 +1663,7 b' class revlog(flagutil.flagprocessorsmixi'
             validatehash = self._processflagsraw(rawtext, flags)
             text = rawtext
         else:
-            r = self._processflagsread(rawtext, flags)
+            r = flagutil.processflagsread(self, rawtext, flags)
             text, validatehash, sidedata = r
         if validatehash:
             self.checkhash(text, node, rev=rev)

mercurial/revlogutils/flagutil.py

@@ -96,30 +96,10 b' class flagprocessorsmixin(object):'
         if raw:
             return text, self._processflagsraw(text, flags)
         elif operation == 'read':
-            return self._processflagsread(text, flags)
+            return processflagsread(self, text, flags)
         else: # write operation
             return processflagswrite(self, text, flags)
 
-    def _processflagsread(self, text, flags):
-        """Inspect revision data flags and applies read transformations defined
-        by registered flag processors.
-
-        ``text`` - the revision data to process
-        ``flags`` - the revision flags
-        ``raw`` - an optional argument describing if the raw transform should be
-        applied.
-
-        This method processes the flags in the order (or reverse order if
-        ``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying the
-        flag processors registered for present flags. The order of flags defined
-        in REVIDX_FLAGS_ORDER needs to be stable to allow non-commutativity.
-
-        Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the
-        processed text and ``validatehash`` is a bool indicating whether the
-        returned text should be checked for hash integrity.
-        """
-        return _processflagsfunc(self, text, flags, 'read')
-
     def _processflagsraw(self, text, flags):
         """Inspect revision data flags to check is the content hash should be
         validated.
@@ -157,6 +137,26 b' def processflagswrite(revlog, text, flag'
     return _processflagsfunc(revlog, text, flags, 'write',
                              sidedata=sidedata)[:2]
 
+def processflagsread(revlog, text, flags):
+    """Inspect revision data flags and applies read transformations defined
+    by registered flag processors.
+
+    ``text`` - the revision data to process
+    ``flags`` - the revision flags
+    ``raw`` - an optional argument describing if the raw transform should be
+    applied.
+
+    This method processes the flags in the order (or reverse order if
+    ``operation`` is 'write') defined by REVIDX_FLAGS_ORDER, applying the
+    flag processors registered for present flags. The order of flags defined
+    in REVIDX_FLAGS_ORDER needs to be stable to allow non-commutativity.
+
+    Returns a 2-tuple of ``(text, validatehash)`` where ``text`` is the
+    processed text and ``validatehash`` is a bool indicating whether the
+    returned text should be checked for hash integrity.
+    """
+    return _processflagsfunc(revlog, text, flags, 'read')
+
 def _processflagsfunc(revlog, text, flags, operation, sidedata=None):
     """internal function to process flag on a revlog
 

tests/simplestorerepo.py

@@ -294,7 +294,7 b' class filestorage(flagutil.flagprocessor'
             validatehash = self._processflagsraw(rawtext, flags)
             text = rawtext
         else:
-            r = self._processflagsread(rawtext, flags)
+            r = flagutil.processflagsread(self, rawtext, flags)
             text, validatehash, sidedata = r
         if validatehash:
             self.checkhash(text, node, rev=rev)