appium-mac2-driver 4.5.1 → 4.6.0

package/node_modules/spdy-transport/lib/spdy-transport/priority.js

@@ -0,0 +1,188 @@
+'use strict'
+
+var transport = require('../spdy-transport')
+var utils = transport.utils
+
+var assert = require('assert')
+var debug = require('debug')('spdy:priority')
+
+function PriorityNode (tree, options) {
+  this.tree = tree
+
+  this.id = options.id
+  this.parent = options.parent
+  this.weight = options.weight
+
+  // To be calculated in `addChild`
+  this.priorityFrom = 0
+  this.priorityTo = 1
+  this.priority = 1
+
+  this.children = {
+    list: [],
+    weight: 0
+  }
+
+  if (this.parent !== null) {
+    this.parent.addChild(this)
+  }
+}
+
+function compareChildren (a, b) {
+  return a.weight === b.weight ? a.id - b.id : a.weight - b.weight
+}
+
+PriorityNode.prototype.toJSON = function toJSON () {
+  return {
+    parent: this.parent,
+    weight: this.weight,
+    exclusive: this.exclusive
+  }
+}
+
+PriorityNode.prototype.getPriority = function getPriority () {
+  return this.priority
+}
+
+PriorityNode.prototype.getPriorityRange = function getPriorityRange () {
+  return { from: this.priorityFrom, to: this.priorityTo }
+}
+
+PriorityNode.prototype.addChild = function addChild (child) {
+  child.parent = this
+  utils.binaryInsert(this.children.list, child, compareChildren)
+  this.children.weight += child.weight
+
+  this._updatePriority(this.priorityFrom, this.priorityTo)
+}
+
+PriorityNode.prototype.remove = function remove () {
+  assert(this.parent, 'Can\'t remove root node')
+
+  this.parent.removeChild(this)
+  this.tree._removeNode(this)
+
+  // Move all children to the parent
+  for (var i = 0; i < this.children.list.length; i++) {
+    this.parent.addChild(this.children.list[i])
+  }
+}
+
+PriorityNode.prototype.removeChild = function removeChild (child) {
+  this.children.weight -= child.weight
+  var index = utils.binarySearch(this.children.list, child, compareChildren)
+  if (index !== -1 && this.children.list.length >= index) {
+    this.children.list.splice(index, 1)
+  }
+}
+
+PriorityNode.prototype.removeChildren = function removeChildren () {
+  var children = this.children.list
+  this.children.list = []
+  this.children.weight = 0
+  return children
+}
+
+PriorityNode.prototype._updatePriority = function _updatePriority (from, to) {
+  this.priority = to - from
+  this.priorityFrom = from
+  this.priorityTo = to
+
+  var weight = 0
+  for (var i = 0; i < this.children.list.length; i++) {
+    var node = this.children.list[i]
+    var nextWeight = weight + node.weight
+
+    node._updatePriority(
+      from + this.priority * (weight / this.children.weight),
+      from + this.priority * (nextWeight / this.children.weight)
+    )
+    weight = nextWeight
+  }
+}
+
+function PriorityTree (options) {
+  this.map = {}
+  this.list = []
+  this.defaultWeight = options.defaultWeight || 16
+
+  this.count = 0
+  this.maxCount = options.maxCount
+
+  // Root
+  this.root = this.add({
+    id: 0,
+    parent: null,
+    weight: 1
+  })
+}
+module.exports = PriorityTree
+
+PriorityTree.create = function create (options) {
+  return new PriorityTree(options)
+}
+
+PriorityTree.prototype.add = function add (options) {
+  if (options.id === options.parent) {
+    return this.addDefault(options.id)
+  }
+
+  var parent = options.parent === null ? null : this.map[options.parent]
+  if (parent === undefined) {
+    return this.addDefault(options.id)
+  }
+
+  debug('add node=%d parent=%d weight=%d exclusive=%d',
+    options.id,
+    options.parent === null ? -1 : options.parent,
+    options.weight || this.defaultWeight,
+    options.exclusive ? 1 : 0)
+
+  var children
+  if (options.exclusive) {
+    children = parent.removeChildren()
+  }
+
+  var node = new PriorityNode(this, {
+    id: options.id,
+    parent: parent,
+    weight: options.weight || this.defaultWeight
+  })
+  this.map[options.id] = node
+
+  if (options.exclusive) {
+    for (var i = 0; i < children.length; i++) {
+      node.addChild(children[i])
+    }
+  }
+
+  this.count++
+  if (this.count > this.maxCount) {
+    debug('hit maximum remove id=%d', this.list[0].id)
+    this.list.shift().remove()
+  }
+
+  // Root node is not subject to removal
+  if (node.parent !== null) {
+    this.list.push(node)
+  }
+
+  return node
+}
+
+// Only for testing, should use `node`'s methods
+PriorityTree.prototype.get = function get (id) {
+  return this.map[id]
+}
+
+PriorityTree.prototype.addDefault = function addDefault (id) {
+  debug('creating default node')
+  return this.add({ id: id, parent: 0, weight: this.defaultWeight })
+}
+
+PriorityTree.prototype._removeNode = function _removeNode (node) {
+  delete this.map[node.id]
+  var index = utils.binarySearch(this.list, node, compareChildren)
+  this.list.splice(index, 1)
+  this.count--
+}

package/node_modules/spdy-transport/lib/spdy-transport/protocol/base/constants.js

@@ -0,0 +1,4 @@
+exports.DEFAULT_METHOD = 'GET'
+exports.DEFAULT_HOST = 'localhost'
+exports.MAX_PRIORITY_STREAMS = 100
+exports.DEFAULT_MAX_CHUNK = 8 * 1024

package/node_modules/spdy-transport/lib/spdy-transport/protocol/base/framer.js

@@ -0,0 +1,58 @@
+'use strict'
+
+var util = require('util')
+
+var transport = require('../../../spdy-transport')
+var base = require('./')
+var Scheduler = base.Scheduler
+
+function Framer (options) {
+  Scheduler.call(this)
+
+  this.version = null
+  this.compress = null
+  this.window = options.window
+  this.timeout = options.timeout
+
+  // Wait for `enablePush`
+  this.pushEnabled = null
+}
+util.inherits(Framer, Scheduler)
+module.exports = Framer
+
+Framer.prototype.setVersion = function setVersion (version) {
+  this.version = version
+  this.emit('version')
+}
+
+Framer.prototype.setCompression = function setCompresion (pair) {
+  this.compress = new transport.utils.LockStream(pair.compress)
+}
+
+Framer.prototype.enablePush = function enablePush (enable) {
+  this.pushEnabled = enable
+  this.emit('_pushEnabled')
+}
+
+Framer.prototype._checkPush = function _checkPush (callback) {
+  if (this.pushEnabled === null) {
+    this.once('_pushEnabled', function () {
+      this._checkPush(callback)
+    })
+    return
+  }
+
+  var err = null
+  if (!this.pushEnabled) {
+    err = new Error('PUSH_PROMISE disabled by other side')
+  }
+  process.nextTick(function () {
+    return callback(err)
+  })
+}
+
+Framer.prototype._resetTimeout = function _resetTimeout () {
+  if (this.timeout) {
+    this.timeout.reset()
+  }
+}

package/node_modules/spdy-transport/lib/spdy-transport/protocol/base/index.js

@@ -0,0 +1,7 @@
+'use strict'
+
+exports.utils = require('./utils')
+exports.constants = require('./constants')
+exports.Scheduler = require('./scheduler')
+exports.Parser = require('./parser')
+exports.Framer = require('./framer')

package/node_modules/spdy-transport/lib/spdy-transport/protocol/base/parser.js

@@ -0,0 +1,106 @@
+'use strict'
+
+var transport = require('../../../spdy-transport')
+
+var util = require('util')
+var utils = require('./').utils
+var OffsetBuffer = require('obuf')
+var Transform = require('readable-stream').Transform
+
+function Parser (options) {
+  Transform.call(this, {
+    readableObjectMode: true
+  })
+
+  this.buffer = new OffsetBuffer()
+  this.partial = false
+  this.waiting = 0
+
+  this.window = options.window
+
+  this.version = null
+  this.decompress = null
+  this.dead = false
+}
+module.exports = Parser
+util.inherits(Parser, Transform)
+
+Parser.prototype.error = utils.error
+
+Parser.prototype.kill = function kill () {
+  this.dead = true
+}
+
+Parser.prototype._transform = function transform (data, encoding, cb) {
+  if (!this.dead) { this.buffer.push(data) }
+
+  this._consume(cb)
+}
+
+Parser.prototype._consume = function _consume (cb) {
+  var self = this
+
+  function next (err, frame) {
+    if (err) {
+      return cb(err)
+    }
+
+    if (Array.isArray(frame)) {
+      for (var i = 0; i < frame.length; i++) {
+        self.push(frame[i])
+      }
+    } else if (frame) {
+      self.push(frame)
+    }
+
+    // Consume more packets
+    if (!sync) {
+      return self._consume(cb)
+    }
+
+    process.nextTick(function () {
+      self._consume(cb)
+    })
+  }
+
+  if (this.dead) {
+    return cb()
+  }
+
+  if (this.buffer.size < this.waiting) {
+    // No data at all
+    if (this.buffer.size === 0) {
+      return cb()
+    }
+
+    // Partial DATA frame or something that we can process partially
+    if (this.partial) {
+      var partial = this.buffer.clone(this.buffer.size)
+      this.buffer.skip(partial.size)
+      this.waiting -= partial.size
+
+      this.executePartial(partial, next)
+      return
+    }
+
+    // We shall not do anything until we get all expected data
+    return cb()
+  }
+
+  var sync = true
+
+  var content = this.buffer.clone(this.waiting)
+  this.buffer.skip(this.waiting)
+
+  this.execute(content, next)
+  sync = false
+}
+
+Parser.prototype.setVersion = function setVersion (version) {
+  this.version = version
+  this.emit('version', version)
+}
+
+Parser.prototype.setCompression = function setCompresion (pair) {
+  this.decompress = new transport.utils.LockStream(pair.decompress)
+}

package/node_modules/spdy-transport/lib/spdy-transport/protocol/base/scheduler.js

@@ -0,0 +1,216 @@
+'use strict'
+
+var transport = require('../../../spdy-transport')
+var utils = transport.utils
+
+var assert = require('assert')
+var util = require('util')
+var debug = require('debug')('spdy:scheduler')
+var Readable = require('readable-stream').Readable
+
+/*
+ * We create following structure in `pending`:
+ * [ [ id = 0 ], [ id = 1 ], [ id = 2 ], [ id = 0 ] ]
+ *     chunks      chunks      chunks      chunks
+ *     chunks                  chunks
+ *     chunks
+ *
+ * Then on the `.tick()` pass we pick one chunks from each item and remove the
+ * item if it is empty:
+ *
+ * [ [ id = 0 ], [ id = 2 ] ]
+ *     chunks      chunks
+ *     chunks
+ *
+ * Writing out: chunks for 0, chunks for 1, chunks for 2, chunks for 0
+ *
+ * This way data is interleaved between the different streams.
+ */
+
+function Scheduler (options) {
+  Readable.call(this)
+
+  // Pretty big window by default
+  this.window = 0.25
+
+  if (options && options.window) { this.window = options.window }
+
+  this.sync = []
+  this.list = []
+  this.count = 0
+  this.pendingTick = false
+}
+util.inherits(Scheduler, Readable)
+module.exports = Scheduler
+
+// Just for testing, really
+Scheduler.create = function create (options) {
+  return new Scheduler(options)
+}
+
+function insertCompare (a, b) {
+  return a.priority === b.priority
+    ? a.stream - b.stream
+    : b.priority - a.priority
+}
+
+Scheduler.prototype.schedule = function schedule (data) {
+  var priority = data.priority
+  var stream = data.stream
+  var chunks = data.chunks
+
+  // Synchronous frames should not be interleaved
+  if (priority === false) {
+    debug('queue sync', chunks)
+    this.sync.push(data)
+    this.count += chunks.length
+
+    this._read()
+    return
+  }
+
+  debug('queue async priority=%d stream=%d', priority, stream, chunks)
+  var item = new SchedulerItem(stream, priority)
+  var index = utils.binaryLookup(this.list, item, insertCompare)
+
+  // Push new item
+  if (index >= this.list.length || insertCompare(this.list[index], item) !== 0) {
+    this.list.splice(index, 0, item)
+  } else { // Coalesce
+    item = this.list[index]
+  }
+
+  item.push(data)
+
+  this.count += chunks.length
+
+  this._read()
+}
+
+Scheduler.prototype._read = function _read () {
+  if (this.count === 0) {
+    return
+  }
+
+  if (this.pendingTick) {
+    return
+  }
+  this.pendingTick = true
+
+  var self = this
+  process.nextTick(function () {
+    self.pendingTick = false
+    self.tick()
+  })
+}
+
+Scheduler.prototype.tick = function tick () {
+  // No luck for async frames
+  if (!this.tickSync()) { return false }
+
+  return this.tickAsync()
+}
+
+Scheduler.prototype.tickSync = function tickSync () {
+  // Empty sync queue first
+  var sync = this.sync
+  var res = true
+  this.sync = []
+  for (var i = 0; i < sync.length; i++) {
+    var item = sync[i]
+    debug('tick sync pending=%d', this.count, item.chunks)
+    for (var j = 0; j < item.chunks.length; j++) {
+      this.count--
+      // TODO: handle stream backoff properly
+      try {
+        res = this.push(item.chunks[j])
+      } catch (err) {
+        this.emit('error', err)
+        return false
+      }
+    }
+    debug('after tick sync pending=%d', this.count)
+
+    // TODO(indutny): figure out the way to invoke callback on actual write
+    if (item.callback) {
+      item.callback(null)
+    }
+  }
+  return res
+}
+
+Scheduler.prototype.tickAsync = function tickAsync () {
+  var res = true
+  var list = this.list
+  if (list.length === 0) {
+    return res
+  }
+
+  var startPriority = list[0].priority
+  for (var index = 0; list.length > 0; index++) {
+    // Loop index
+    index %= list.length
+    if (startPriority - list[index].priority > this.window) { index = 0 }
+    debug('tick async index=%d start=%d', index, startPriority)
+
+    var current = list[index]
+    var item = current.shift()
+
+    if (current.isEmpty()) {
+      list.splice(index, 1)
+      if (index === 0 && list.length > 0) {
+        startPriority = list[0].priority
+      }
+      index--
+    }
+
+    debug('tick async pending=%d', this.count, item.chunks)
+    for (var i = 0; i < item.chunks.length; i++) {
+      this.count--
+      // TODO: handle stream backoff properly
+      try {
+        res = this.push(item.chunks[i])
+      } catch (err) {
+        this.emit('error', err)
+        return false
+      }
+    }
+    debug('after tick pending=%d', this.count)
+
+    // TODO(indutny): figure out the way to invoke callback on actual write
+    if (item.callback) {
+      item.callback(null)
+    }
+    if (!res) { break }
+  }
+
+  return res
+}
+
+Scheduler.prototype.dump = function dump () {
+  this.tickSync()
+
+  // Write everything out
+  while (!this.tickAsync()) {
+    // Intentional no-op
+  }
+  assert.strictEqual(this.count, 0)
+}
+
+function SchedulerItem (stream, priority) {
+  this.stream = stream
+  this.priority = priority
+  this.queue = []
+}
+
+SchedulerItem.prototype.push = function push (chunks) {
+  this.queue.push(chunks)
+}
+
+SchedulerItem.prototype.shift = function shift () {
+  return this.queue.shift()
+}
+
+SchedulerItem.prototype.isEmpty = function isEmpty () {
+  return this.queue.length === 0
+}

package/node_modules/spdy-transport/lib/spdy-transport/protocol/base/utils.js

@@ -0,0 +1,94 @@
+'use strict'
+
+var utils = exports
+
+var util = require('util')
+
+function ProtocolError (code, message) {
+  this.code = code
+  this.message = message
+}
+util.inherits(ProtocolError, Error)
+utils.ProtocolError = ProtocolError
+
+utils.error = function error (code, message) {
+  return new ProtocolError(code, message)
+}
+
+utils.reverse = function reverse (object) {
+  var result = []
+
+  Object.keys(object).forEach(function (key) {
+    result[object[key] | 0] = key
+  })
+
+  return result
+}
+
+// weight [1, 36] <=> priority [0, 7]
+// This way weight=16 is preserved and has priority=3
+utils.weightToPriority = function weightToPriority (weight) {
+  return ((Math.min(35, (weight - 1)) / 35) * 7) | 0
+}
+
+utils.priorityToWeight = function priorityToWeight (priority) {
+  return (((priority / 7) * 35) | 0) + 1
+}
+
+// Copy-Paste from node
+exports.addHeaderLine = function addHeaderLine (field, value, dest) {
+  field = field.toLowerCase()
+  if (/^:/.test(field)) {
+    dest[field] = value
+    return
+  }
+
+  switch (field) {
+    // Array headers:
+    case 'set-cookie':
+      if (dest[field] !== undefined) {
+        dest[field].push(value)
+      } else {
+        dest[field] = [ value ]
+      }
+      break
+
+    /* eslint-disable max-len */
+    // list is taken from:
+    /* eslint-enable max-len */
+    case 'content-type':
+    case 'content-length':
+    case 'user-agent':
+    case 'referer':
+    case 'host':
+    case 'authorization':
+    case 'proxy-authorization':
+    case 'if-modified-since':
+    case 'if-unmodified-since':
+    case 'from':
+    case 'location':
+    case 'max-forwards':
+      // drop duplicates
+      if (dest[field] === undefined) {
+        dest[field] = value
+      }
+      break
+
+    case 'cookie':
+      // make semicolon-separated list
+      if (dest[field] !== undefined) {
+        dest[field] += '; ' + value
+      } else {
+        dest[field] = value
+      }
+      break
+
+    default:
+      // make comma-separated list
+      if (dest[field] !== undefined) {
+        dest[field] += ', ' + value
+      } else {
+        dest[field] = value
+      }
+  }
+}