Merge remote-tracking branch 'origin/v0.10' into master

Conflicts:
	doc/api/buffer.markdown
	lib/_stream_readable.js
	lib/assert.js
	lib/buffer.js
	lib/child_process.js
	lib/http.js
	lib/string_decoder.js
	lib/zlib.js
	node.gyp
	test/simple/test-buffer.js
	test/simple/test-https-foafssl.js
	test/simple/test-stream2-compatibility.js
	test/simple/test-tls-server-verify.js

diff --cc configure
Simple merge

diff --cc doc/api/buffer.markdown
Simple merge

diff --cc doc/api/console.markdown
Simple merge

diff --cc doc/api/crypto.markdown
Simple merge

diff --cc lib/_stream_readable.js
index a9d9fc6,ae04f22..9991952
mode 100644,100755..100644
--- 1/lib/_stream_readable.js
--- 2/lib/_stream_readable.js
+++ b/lib/_stream_readable.js
@@@ -227,7 -218,7 +224,7 @@@ function howMuchToRead(n, state) 
    if (state.objectMode)
      return n === 0 ? 0 : 1;
  
-   if (isNaN(n) || util.isNull(n)) {
 -  if (n === null || isNaN(n)) {
++  if (util.isNull(n) || isNaN(n)) {
      // only flow one buffer at a time
      if (state.flowing && state.buffer.length)
        return state.buffer[0].length;

diff --cc lib/assert.js
index 7602996,c9b71d4..c83f977
--- 1/lib/assert.js
--- 2/lib/assert.js
+++ b/lib/assert.js
@@@ -57,13 -51,13 +57,13 @@@ assert.AssertionError = function Assert
  util.inherits(assert.AssertionError, Error);
  
  function replacer(key, value) {
 -  if (value === undefined) {
 +  if (util.isUndefined(value)) {
      return '' + value;
    }
-   if (util.isNumber(value) && (isNaN(value) || !isFinite(value))) {
 -  if (typeof value === 'number' && !isFinite(value)) {
++  if (util.isNumber(value) && !isFinite(value)) {
      return value.toString();
    }
 -  if (typeof value === 'function' || value instanceof RegExp) {
 +  if (util.isFunction(value) || util.isRegExp(value)) {
      return value.toString();
    }
    return value;

diff --cc lib/buffer.js
Simple merge

diff --cc lib/net.js
Simple merge

diff --cc lib/zlib.js
index 2460cbb,c72ab92..ad9ceaa
--- 1/lib/zlib.js
--- 2/lib/zlib.js
+++ b/lib/zlib.js
@@@ -387,36 -319,9 +387,38 @@@ function Zlib(opts, mode) 
  
  util.inherits(Zlib, Transform);
  
 -Zlib.prototype.reset = function reset() {
 +Zlib.prototype.params = function(level, strategy, callback) {
 +  if (level < exports.Z_MIN_LEVEL ||
 +      level > exports.Z_MAX_LEVEL) {
 +    throw new RangeError('Invalid compression level: ' + level);
 +  }
 +  if (strategy != exports.Z_FILTERED &&
 +      strategy != exports.Z_HUFFMAN_ONLY &&
 +      strategy != exports.Z_RLE &&
 +      strategy != exports.Z_FIXED &&
 +      strategy != exports.Z_DEFAULT_STRATEGY) {
 +    throw new TypeError('Invalid strategy: ' + strategy);
 +  }
 +
 +  if (this._level !== level || this._strategy !== strategy) {
 +    var self = this;
 +    this.flush(binding.Z_SYNC_FLUSH, function() {
++      assert(!self._closed, 'zlib binding closed');
 +      self._handle.params(level, strategy);
 +      if (!self._hadError) {
 +        self._level = level;
 +        self._strategy = strategy;
 +        if (callback) callback();
 +      }
 +    });
 +  } else {
 +    process.nextTick(callback);
 +  }
 +};
 +
 +Zlib.prototype.reset = function() {
+   assert(!this._closed, 'zlib binding closed');
 -  return this._binding.reset();
 +  return this._handle.reset();
  };
  
  // This is the _flush function called by the transform class,
@@@ -473,9 -373,9 +475,12 @@@ Zlib.prototype._transform = function(ch
    var ending = ws.ending || ws.ended;
    var last = ending && (!chunk || ws.length === chunk.length);
  
 -  if (chunk !== null && !Buffer.isBuffer(chunk))
 +  if (!util.isNull(chunk) && !util.isBuffer(chunk))
      return cb(new Error('invalid input'));
  
++  if (this._closed)
++    return cb(new Error('zlib binding closed'));
++
    // If it's the last chunk, or a final flush, we use the Z_FINISH flush flag.
    // If it's explicitly flushing at some other time, then we use
    // Z_FULL_FLUSH. Otherwise, use Z_NO_FLUSH for maximum compression
@@@ -499,46 -395,15 +504,48 @@@ Zlib.prototype._processChunk = function
    var availOutBefore = this._chunkSize - this._offset;
    var inOff = 0;
  
 -  if (this._closed)
 -    return cb(new Error('zlib binding closed'));
 -  var req = this._binding.write(flushFlag,
 -                                chunk, // in
 -                                inOff, // in_off
 -                                availInBefore, // in_len
 -                                this._buffer, // out
 -                                this._offset, //out_off
 -                                availOutBefore); // out_len
 +  var self = this;
 +
 +  var async = util.isFunction(cb);
 +
 +  if (!async) {
 +    var buffers = [];
 +    var nread = 0;
 +
 +    var error;
 +    this.on('error', function(er) {
 +      error = er;
 +    });
 +
++    assert(!this._closed, 'zlib binding closed');
 +    do {
 +      var res = this._handle.writeSync(flushFlag,
 +                                       chunk, // in
 +                                       inOff, // in_off
 +                                       availInBefore, // in_len
 +                                       this._buffer, // out
 +                                       this._offset, //out_off
 +                                       availOutBefore); // out_len
 +    } while (!this._hadError && callback(res[0], res[1]));
 +
 +    if (this._hadError) {
 +      throw error;
 +    }
 +
 +    var buf = Buffer.concat(buffers, nread);
 +    this.close();
 +
 +    return buf;
 +  }
 +
++  assert(!this._closed, 'zlib binding closed');
 +  var req = this._handle.write(flushFlag,
 +                               chunk, // in
 +                               inOff, // in_off
 +                               availInBefore, // in_len
 +                               this._buffer, // out
 +                               this._offset, //out_off
 +                               availOutBefore); // out_len
  
    req.buffer = chunk;
    req.callback = callback;

diff --cc node.gyp
Simple merge

diff --cc src/node_constants.cc
Simple merge

diff --cc test/simple/test-https-foafssl.js
Simple merge