1 files changed, 0 insertions, 351 deletions
diff --git a/addon-sdk/source/lib/sdk/io/buffer.js b/addon-sdk/source/lib/sdk/io/buffer.js
deleted file mode 100644
index 5ea169402..000000000
--- a/addon-sdk/source/lib/sdk/io/buffer.js
+++ /dev/null
@@ -1,351 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-'use strict';
-
-module.metadata = {
-  'stability': 'experimental'
-};
-
-/*
- * Encodings supported by TextEncoder/Decoder:
- * utf-8, utf-16le, utf-16be
- * http://encoding.spec.whatwg.org/#interface-textencoder
- *
- * Node however supports the following encodings:
- * ascii, utf-8, utf-16le, usc2, base64, hex
- */
-
-const { Cu } = require('chrome');
-const { isNumber } = require('sdk/lang/type');
-const { TextEncoder, TextDecoder } = Cu.import('resource://gre/modules/commonjs/toolkit/loader.js', {});
-
-exports.TextEncoder = TextEncoder;
-exports.TextDecoder = TextDecoder;
-
-/**
- * Use WeakMaps to work around Bug 929146, which prevents us from adding
- * getters or values to typed arrays
- * https://bugzilla.mozilla.org/show_bug.cgi?id=929146
- */
-const parents = new WeakMap();
-const views = new WeakMap();
-
-function Buffer(subject, encoding /*, bufferLength */) {
-
-  // Allow invocation without `new` constructor
-  if (!(this instanceof Buffer))
-    return new Buffer(subject, encoding, arguments[2]);
-
-  var type = typeof(subject);
-
-  switch (type) {
-    case 'number':
-      // Create typed array of the given size if number.
-      try {
-        let buffer = new Uint8Array(subject > 0 ? Math.floor(subject) : 0);
-        return buffer;
-      } catch (e) {
-        if (/size and count too large/.test(e.message) ||
-            /invalid arguments/.test(e.message))
-          throw new RangeError('Could not instantiate buffer: size of buffer may be too large');
-        else
-          throw new Error('Could not instantiate buffer');
-      }
-      break;
-    case 'string':
-      // If string encode it and use buffer for the returned Uint8Array
-      // to create a local patched version that acts like node buffer.
-      encoding = encoding || 'utf8';
-      return new Uint8Array(new TextEncoder(encoding).encode(subject).buffer);
-    case 'object':
-      // This form of the constructor uses the form of
-      // new Uint8Array(buffer, offset, length);
-      // So we can instantiate a typed array within the constructor
-      // to inherit the appropriate properties, where both the
-      // `subject` and newly instantiated buffer share the same underlying
-      // data structure.
-      if (arguments.length === 3)
-        return new Uint8Array(subject, encoding, arguments[2]);
-      // If array or alike just make a copy with a local patched prototype.
-      else
-        return new Uint8Array(subject);
-    default:
-      throw new TypeError('must start with number, buffer, array or string');
-  }
-}
-exports.Buffer = Buffer;
-
-// Tests if `value` is a Buffer.
-Buffer.isBuffer = value => value instanceof Buffer
-
-// Returns true if the encoding is a valid encoding argument & false otherwise
-Buffer.isEncoding = function (encoding) {
-  if (!encoding) return false;
-  try {
-    new TextDecoder(encoding);
-  } catch(e) {
-    return false;
-  }
-  return true;
-}
-
-// Gives the actual byte length of a string. encoding defaults to 'utf8'.
-// This is not the same as String.prototype.length since that returns the
-// number of characters in a string.
-Buffer.byteLength = (value, encoding = 'utf8') =>
-  new TextEncoder(encoding).encode(value).byteLength
-
-// Direct copy of the nodejs's buffer implementation:
-// https://github.com/joyent/node/blob/b255f4c10a80343f9ce1cee56d0288361429e214/lib/buffer.js#L146-L177
-Buffer.concat = function(list, length) {
-  if (!Array.isArray(list))
-    throw new TypeError('Usage: Buffer.concat(list[, length])');
-
-  if (typeof length === 'undefined') {
-    length = 0;
-    for (var i = 0; i < list.length; i++)
-      length += list[i].length;
-  } else {
-    length = ~~length;
-  }
-
-  if (length < 0)
-    length = 0;
-
-  if (list.length === 0)
-    return new Buffer(0);
-  else if (list.length === 1)
-    return list[0];
-
-  if (length < 0)
-    throw new RangeError('length is not a positive number');
-
-  var buffer = new Buffer(length);
-  var pos = 0;
-  for (var i = 0; i < list.length; i++) {
-    var buf = list[i];
-    buf.copy(buffer, pos);
-    pos += buf.length;
-  }
-
-  return buffer;
-};
-
-// Node buffer is very much like Uint8Array although it has bunch of methods
-// that typically can be used in combination with `DataView` while preserving
-// access by index. Since in SDK each module has it's own set of bult-ins it
-// ok to patch ours to make it nodejs Buffer compatible.
-const Uint8ArraySet = Uint8Array.prototype.set
-Buffer.prototype = Uint8Array.prototype;
-Object.defineProperties(Buffer.prototype, {
-  parent: {
-    get: function() { return parents.get(this, undefined); }
-  },
-  view: {
-    get: function () {
-      let view = views.get(this, undefined);
-      if (view) return view;
-      view = new DataView(this.buffer);
-      views.set(this, view);
-      return view;
-    }
-  },
-  toString: {
-    value: function(encoding, start, end) {
-      encoding = !!encoding ? (encoding + '').toLowerCase() : 'utf8';
-      start = Math.max(0, ~~start);
-      end = Math.min(this.length, end === void(0) ? this.length : ~~end);
-      return new TextDecoder(encoding).decode(this.subarray(start, end));
-    }
-  },
-  toJSON: {
-    value: function() {
-      return { type: 'Buffer', data: Array.slice(this, 0) };
-    }
-  },
-  get: {
-    value: function(offset) {
-      return this[offset];
-    }
-  },
-  set: {
-    value: function(offset, value) { this[offset] = value; }
-  },
-  copy: {
-    value: function(target, offset, start, end) {
-      let length = this.length;
-      let targetLength = target.length;
-      offset = isNumber(offset) ? offset : 0;
-      start = isNumber(start) ? start : 0;
-
-      if (start < 0)
-        throw new RangeError('sourceStart is outside of valid range');
-      if (end < 0)
-        throw new RangeError('sourceEnd is outside of valid range');
-
-      // If sourceStart > sourceEnd, or targetStart > targetLength,
-      // zero bytes copied
-      if (start > end ||
-          offset > targetLength
-          )
-        return 0;
-
-      // If `end` is not defined, or if it is defined
-      // but would overflow `target`, redefine `end`
-      // so we can copy as much as we can
-      if (end - start > targetLength - offset ||
-          end == null) {
-        let remainingTarget = targetLength - offset;
-        let remainingSource = length - start;
-        if (remainingSource <= remainingTarget)
-          end = length;
-        else
-          end = start + remainingTarget;
-      }
-
-      Uint8ArraySet.call(target, this.subarray(start, end), offset);
-      return end - start;
-    }
-  },
-  slice: {
-    value: function(start, end) {
-      let length = this.length;
-      start = ~~start;
-      end = end != null ? end : length;
-
-      if (start < 0) {
-        start += length;
-        if (start < 0) start = 0;
-      } else if (start > length)
-        start = length;
-
-      if (end < 0) {
-        end += length;
-        if (end < 0) end = 0;
-      } else if (end > length)
-        end = length;
-
-      if (end < start)
-        end = start;
-
-      // This instantiation uses the new Uint8Array(buffer, offset, length) version
-      // of construction to share the same underling data structure
-      let buffer = new Buffer(this.buffer, start, end - start);
-
-      // If buffer has a value, assign its parent value to the
-      // buffer it shares its underlying structure with. If a slice of
-      // a slice, then use the root structure
-      if (buffer.length > 0)
-        parents.set(buffer, this.parent || this);
-
-      return buffer;
-    }
-  },
-  write: {
-    value: function(string, offset, length, encoding = 'utf8') {
-      // write(string, encoding);
-      if (typeof(offset) === 'string' && Number.isNaN(parseInt(offset))) {
-        [offset, length, encoding] = [0, null, offset];
-      }
-      // write(string, offset, encoding);
-      else if (typeof(length) === 'string')
-        [length, encoding] = [null, length];
-
-      if (offset < 0 || offset > this.length)
-        throw new RangeError('offset is outside of valid range');
-
-      offset = ~~offset;
-
-      // Clamp length if it would overflow buffer, or if its
-      // undefined
-      if (length == null || length + offset > this.length)
-        length = this.length - offset;
-
-      let buffer = new TextEncoder(encoding).encode(string);
-      let result = Math.min(buffer.length, length);
-      if (buffer.length !== length)
-        buffer = buffer.subarray(0, length);
-
-      Uint8ArraySet.call(this, buffer, offset);
-      return result;
-    }
-  },
-  fill: {
-    value: function fill(value, start, end) {
-      let length = this.length;
-      value = value || 0;
-      start = start || 0;
-      end = end || length;
-
-      if (typeof(value) === 'string')
-        value = value.charCodeAt(0);
-      if (typeof(value) !== 'number' || isNaN(value))
-        throw TypeError('value is not a number');
-      if (end < start)
-        throw new RangeError('end < start');
-
-      // Fill 0 bytes; we're done
-      if (end === start)
-        return 0;
-      if (length == 0)
-        return 0;
-
-      if (start < 0 || start >= length)
-        throw RangeError('start out of bounds');
-
-      if (end < 0 || end > length)
-        throw RangeError('end out of bounds');
-
-      let index = start;
-      while (index < end) this[index++] = value;
-    }
-  }
-});
-
-// Define nodejs Buffer's getter and setter functions that just proxy
-// to internal DataView's equivalent methods.
-
-// TODO do we need to check architecture to see if it's default big/little endian?
-[['readUInt16LE', 'getUint16', true],
- ['readUInt16BE', 'getUint16', false],
- ['readInt16LE', 'getInt16', true],
- ['readInt16BE', 'getInt16', false],
- ['readUInt32LE', 'getUint32', true],
- ['readUInt32BE', 'getUint32', false],
- ['readInt32LE', 'getInt32', true],
- ['readInt32BE', 'getInt32', false],
- ['readFloatLE', 'getFloat32', true],
- ['readFloatBE', 'getFloat32', false],
- ['readDoubleLE', 'getFloat64', true],
- ['readDoubleBE', 'getFloat64', false],
- ['readUInt8', 'getUint8'],
- ['readInt8', 'getInt8']].forEach(([alias, name, littleEndian]) => {
-  Object.defineProperty(Buffer.prototype, alias, {
-    value: function(offset) {
-      return this.view[name](offset, littleEndian);
-    }
-  });
-});
-
-[['writeUInt16LE', 'setUint16', true],
- ['writeUInt16BE', 'setUint16', false],
- ['writeInt16LE', 'setInt16', true],
- ['writeInt16BE', 'setInt16', false],
- ['writeUInt32LE', 'setUint32', true],
- ['writeUInt32BE', 'setUint32', false],
- ['writeInt32LE', 'setInt32', true],
- ['writeInt32BE', 'setInt32', false],
- ['writeFloatLE', 'setFloat32', true],
- ['writeFloatBE', 'setFloat32', false],
- ['writeDoubleLE', 'setFloat64', true],
- ['writeDoubleBE', 'setFloat64', false],
- ['writeUInt8', 'setUint8'],
- ['writeInt8', 'setInt8']].forEach(([alias, name, littleEndian]) => {
-  Object.defineProperty(Buffer.prototype, alias, {
-    value: function(value, offset) {
-      return this.view[name](offset, value, littleEndian);
-    }
-  });
-});