Issue 3993 - Implement Utils.yield() in a better way (ABP/Firefox part)

lib/io.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2016 Eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 60 matching lines @@
    */
   readFromFile: function(/**nsIFile*/ file, /**Object*/ listener, /**Function*/ callback)
   {
     try
     {
       let processing = false;
       let buffer = "";
       let loaded = false;
       let error = null;
 
-      let onProgress = function(data)
+      let onProgress = function*(data)
       {
         let index = (processing ? -1 : Math.max(data.lastIndexOf("\n"), data.lastIndexOf("\r")));
         if (index >= 0)
         {
           // Protect against reentrance in case the listener processes events.
           processing = true;
           try
           {
             let oldBuffer = buffer;
             buffer = data.substr(index + 1);
             data = data.substr(0, index + 1);
             let lines = data.split(/[\r\n]+/);
             lines.pop();
             lines[0] = oldBuffer + lines[0];
             for (let i = 0; i < lines.length; i++)
-              listener.process(lines[i]);
+              yield listener.process(lines[i]);
           }
           finally
           {
             processing = false;
             data = buffer;
             buffer = "";
-            onProgress(data);
+            yield* onProgress(data);
 
             if (loaded)
             {
               loaded = false;
               onSuccess();
             }
 
             if (error)
             {
               let param = error;
               error = null;
               onError(param);
             }
           }
         }
         else
           buffer += data;
       };
 
       let onSuccess = function()
       {
         if (processing)
         {
           // Still processing data, delay processing this event.
           loaded = true;
           return;
         }
 
+        // We are ignoring return value of listener.process() here because
+        // turning this callback into a generator would be complicated, and
+        // delaying isn't really necessary for the last two calls.
         if (buffer !== "")
           listener.process(buffer);
         listener.process(null);
 
         callback(null);
       };
 
       let onError = function(e)
       {
         if (processing)
@@ skipping 29 matching lines @@
         firstRead = false;
 
         let f = yield OS.File.open(file.path, {read: true});
         while (true)
         {
           let array = yield f.read(BUFFER_SIZE);
           if (!array.length)
             break;
 
           let data = decoder.decode(array, {stream: true});
-          onProgress(data);
+          yield* onProgress(data);
         }
         yield f.close();
       }.bind(this)).then(onSuccess, onError);
     }
     catch (e)
     {
       callback(e);
     }
   },
 
@@ skipping 130 matching lines @@
         else
           callback(e);
       });
     }
     catch(e)
     {
       callback(e);
     }
   }
 }