Fixed: patterns.ini contents are being processed multiple times

lib/io.js

 /*
  * This file is part of Adblock Plus <http://adblockplus.org/>,
  * Copyright (C) 2006-2014 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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 /**
  * @fileOverview Module containing file I/O helpers.
  */
 
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/FileUtils.jsm");
 Cu.import("resource://gre/modules/NetUtil.jsm");
 
 let {TimeLine} = require("timeline");
+let {Utils} = require("utils");
 
 let IO = exports.IO =
 {
   /**
    * Retrieves the platform-dependent line break string.
    */
   get lineBreak()
   {
     let lineBreak = (Services.appinfo.OS == "WINNT" ? "\r\n" : "\n");
     delete IO.lineBreak;
@@ skipping 27 matching lines @@
    * Reads strings from a file asynchronously, calls listener.process() with
    * each line read and with a null parameter once the read operation is done.
    * The callback will be called when the operation is done.
    */
   readFromFile: function(/**nsIFile|nsIURI*/ file, /**Boolean*/ decode, /**Object*/ listener, /**Function*/ callback, /**String*/ timeLineID)
   {
     try
     {
       let processing = false;
       let buffer = "";
-      let loadEvent = null;
-      let errorEvent = null;
+      let loaded = false;
+      let error = Cr.NS_OK;
       let uri = file instanceof Ci.nsIFile ? Services.io.newFileURI(file) : file;
       let request = new XMLHttpRequest();
       request.mozBackgroundRequest = true;
       request.open("GET", uri.spec);
       request.responseType = "moz-chunked-text";
       request.overrideMimeType("text/plain" + (decode ? "? charset=utf-8" : ""));
 
-      let onProgress = function(event)
+      let onProgress = function(data)
       {
         if (timeLineID)
         {
           TimeLine.asyncStart(timeLineID);
         }
 
-        let data = event.target.response;
         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]);
           }
           finally
           {
             processing = false;
-            let e = {
-              target: {response: buffer}
-            };
+            data = buffer;
             buffer = "";
-            onProgress(e);
+            onProgress(data);
 
-            if (loadEvent)
+            if (loaded)
             {
-              let event = loadEvent;
-              loadEvent = null;
-              onLoad(event);
+              loaded = false;
+              onLoad();
             }
 
-            if (errorEvent)
+            if (error != Cr.NS_OK)
             {
-              let event = errorEvent;
-              errorEvent = null;
-              onError(event);
+              let param = error;
+              error = Cr.NS_OK;
+              onError(param);
             }
           }
         }
         else
           buffer += data;
 
         if (timeLineID)
         {
           TimeLine.asyncEnd(timeLineID);
         }
       };
 
-      let onLoad = function(event)
+      let onLoad = function()
       {
         if (processing)
         {
           // Still processing data, delay processing this event.
-          loadEvent = event;
+          loaded = true;
           return;
         }
 
         if (timeLineID)
         {
           TimeLine.asyncStart(timeLineID);
         }
 
         if (buffer !== "")
           listener.process(buffer);
         listener.process(null);
 
         if (timeLineID)
         {
           TimeLine.asyncEnd(timeLineID);
           TimeLine.asyncDone(timeLineID);
         }
 
         callback(null);
       };
 
-      let onError = function(event)
+      let onError = function(status)
       {
         if (processing)
         {
           // Still processing data, delay processing this event.
-          errorEvent = event;
+          error = status;
           return;
         }
 
         let e = Cc["@mozilla.org/js/xpc/Exception;1"].createInstance(Ci.nsIXPCException);
-        e.initialize("File read operation failed", result, null, Components.stack, file, null);
+        e.initialize("File read operation failed", status, null, Components.stack, file, null);
         callback(e);
 
         if (timeLineID)
         {
           TimeLine.asyncDone(timeLineID);
         }
       };
 
-      request.addEventListener("progress", onProgress, false);
-      request.addEventListener("load", onLoad, false);
-      request.addEventListener("error", onError, false);
+      request.addEventListener("progress", function(event)
+      {
+        Utils.runAsync(onProgress.bind(this, event.target.response));
+      }, false);
+      request.addEventListener("load", function(event)
+      {
+        Utils.runAsync(onLoad.bind(this));
+      }, false);
+      request.addEventListener("error", function(event)
+      {
+        Utils.runAsync(onError.bind(this, event.target.channel.status));
+      }, false);
 
       request.send(null);
     }
     catch (e)
     {
       callback(e);
     }
   },
   /**
    * Writes string data to a file asynchronously, optionally encodes it into
@@ skipping 179 matching lines @@
         isFile: exists && file.isFile(),
         lastModified: exists ? file.lastModifiedTime : 0
       });
     }
     catch(e)
     {
       callback(e);
     }
   }
 }