Issue 507 - Implement lightweight array.slice() method

lib/typedObjects/arrayTypes.js

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2015 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 19 matching lines @@
   {
     // Carefully zero length + size if this is a slice of an array
     Object.defineProperties(this, {
       length: fixedPropertyDescriptor(0),
       size: fixedPropertyDescriptor(0)
     });
   }
   else
   {
     // Remove read-only length property for previously sliced arrays
-    if (this.hasOwnProperty("length"))
-      delete this.length;
+    delete this.length;
 
     this.length = 0;
     this.size = 0;
   }
 };
 
 function createGetter(elementGetter, elementShift)
 {
   return function(index)
   {
@@ skipping 170 matching lines @@
   if (length == 0)
     throw new Error("No elements in the array");
 
   let result = this.get(length - 1);
   this.length = this.length - 1;
   return result;
 }
 
 function createSlicer(elementShift)
 {
+  let {STATE_UNINITIALIZED} = require("typedObjects/objectTypes");
+
   return function slice(start, end)
   {
     start = start | 0;
     end = end | 0;
 
     if (start < 0)
       start = Math.max(0, this.length + start);
     else
       start = Math.min(start, this.length);
 
     if (end > 0)
       end = Math.min(0, end - this.length);
     else
       end = Math.max(end, -1 * this.length);
 
     Object.defineProperties(this, {
       length: {value: this.length, configurable: true}
     });
     this.retain();
 
     let result = Object.create(this, {
       arrayByteOffset: fixedPropertyDescriptor(
         this.arrayByteOffset + start << elementShift
       ),
       length: {value: this.length - start + end, configurable: true},
       _refCount: {value: 1, writable: true},
       _copy: fixedPropertyDescriptor(true),
-      _state: {value: 0, writable: true}
+      _state: {value: STATE_UNINITIALIZED, writable: true}
     });
 
     // TODO
     //  - A sliced array will have a read-only length even if all slices are
     //    released. We could fix this by keeping a count of slices, but is it
     //    worth it?
     //  - A slice of an array still keeps a reference to the array in it's
     //    __proto__ property after it's released. (We can't just replace it
     //    with null as modifying an object's prototype is apparently very slow.)
 
@@ skipping 132 matching lines @@
     meta.watch = {};
 
   meta.watch.length = createLengthWatcher(elementType, elementSetter);
   meta.watch.size = createSizeWatcher(elementType, minElements, bufferSize, buffers, viewTypes, views, firstFree);
 
   let {ObjectBase} = require("typedObjects/objectTypes");
   return ObjectBase.extend(typeDescriptor, meta);
 }
 
 exports.createArrayType = createArrayType;