Index: trunk/src/libs/xpcom18a4/xpcom/io/nsPipe3.cpp
===================================================================
--- trunk/src/libs/xpcom18a4/xpcom/io/nsPipe3.cpp	(revision 101808)
+++ 	(revision )
@@ -1,1276 +1,0 @@
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Darin Fisher <darin@netscape.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsIPipe.h"
-#include "nsIEventTarget.h"
-#include "nsISeekableStream.h"
-#include "nsSegmentedBuffer.h"
-#include "nsStreamUtils.h"
-#include "nsAutoLock.h"
-#include "nsCOMPtr.h"
-#include "nsCRT.h"
-#include "prlog.h"
-#include "nsInt64.h"
-
-#if defined(PR_LOGGING)
-//
-// set NSPR_LOG_MODULES=nsPipe:5
-//
-static PRLogModuleInfo *gPipeLog = nsnull;
-#define LOG(args) PR_LOG(gPipeLog, PR_LOG_DEBUG, args)
-#else
-#define LOG(args)
-#endif
-
-#define DEFAULT_SEGMENT_SIZE  4096
-#define DEFAULT_SEGMENT_COUNT 16
-
-class nsPipe;
-class nsPipeEvents;
-class nsPipeInputStream;
-class nsPipeOutputStream;
-
-//-----------------------------------------------------------------------------
-
-// this class is used to delay notifications until the end of a particular
-// scope.  it helps avoid the complexity of issuing callbacks while inside
-// a critical section.
-class nsPipeEvents
-{
-public:
-    nsPipeEvents() { }
-   ~nsPipeEvents();
-
-    inline void NotifyInputReady(nsIAsyncInputStream *stream,
-                                 nsIInputStreamCallback *callback)
-    {
-        NS_ASSERTION(!mInputCallback, "already have an input event");
-        mInputStream = stream;
-        mInputCallback = callback;
-    }
-
-    inline void NotifyOutputReady(nsIAsyncOutputStream *stream,
-                                  nsIOutputStreamCallback *callback)
-    {
-        NS_ASSERTION(!mOutputCallback, "already have an output event");
-        mOutputStream = stream;
-        mOutputCallback = callback;
-    }
-
-private:
-    nsCOMPtr<nsIAsyncInputStream>     mInputStream;
-    nsCOMPtr<nsIInputStreamCallback>  mInputCallback;
-    nsCOMPtr<nsIAsyncOutputStream>    mOutputStream;
-    nsCOMPtr<nsIOutputStreamCallback> mOutputCallback;
-};
-
-//-----------------------------------------------------------------------------
-
-// the input end of a pipe (allocated as a member of the pipe).
-class nsPipeInputStream : public nsIAsyncInputStream
-                        , public nsISeekableStream
-                        , public nsISearchableInputStream
-{
-public:
-    // since this class will be allocated as a member of the pipe, we do not
-    // need our own ref count.  instead, we share the lifetime (the ref count)
-    // of the entire pipe.  this macro is just convenience since it does not
-    // declare a mRefCount variable; however, don't let the name fool you...
-    // we are not inheriting from nsPipe ;-)
-    NS_DECL_ISUPPORTS_INHERITED
-
-    NS_DECL_NSIINPUTSTREAM
-    NS_DECL_NSIASYNCINPUTSTREAM
-    NS_DECL_NSISEEKABLESTREAM
-    NS_DECL_NSISEARCHABLEINPUTSTREAM
-
-    nsPipeInputStream(nsPipe *pipe)
-        : mPipe(pipe)
-        , mReaderRefCnt(0)
-        , mLogicalOffset(0)
-        , mBlocking(PR_TRUE)
-        , mBlocked(PR_FALSE)
-        , mAvailable(0)
-        , mCallbackFlags(0)
-        { }
-
-    nsresult Fill();
-    void SetNonBlocking(PRBool aNonBlocking) { mBlocking = !aNonBlocking; }
-
-    PRUint32 Available() { return mAvailable; }
-    void     ReduceAvailable(PRUint32 avail) { mAvailable -= avail; }
-
-    // synchronously wait for the pipe to become readable.
-    nsresult Wait();
-
-    // these functions return true to indicate that the pipe's monitor should
-    // be notified, to wake up a blocked reader if any.
-    PRBool   OnInputReadable(PRUint32 bytesWritten, nsPipeEvents &);
-    PRBool   OnInputException(nsresult, nsPipeEvents &);
-
-private:
-    nsPipe                        *mPipe;
-
-    // separate refcnt so that we know when to close the consumer
-    nsrefcnt                       mReaderRefCnt;
-    nsInt64                        mLogicalOffset;
-    PRPackedBool                   mBlocking;
-
-    // these variables can only be accessed while inside the pipe's monitor
-    PRPackedBool                   mBlocked;
-    PRUint32                       mAvailable;
-    nsCOMPtr<nsIInputStreamCallback> mCallback;
-    PRUint32                       mCallbackFlags;
-};
-
-//-----------------------------------------------------------------------------
-
-// the output end of a pipe (allocated as a member of the pipe).
-class nsPipeOutputStream : public nsIAsyncOutputStream
-                         , public nsISeekableStream
-{
-public:
-    // since this class will be allocated as a member of the pipe, we do not
-    // need our own ref count.  instead, we share the lifetime (the ref count)
-    // of the entire pipe.  this macro is just convenience since it does not
-    // declare a mRefCount variable; however, don't let the name fool you...
-    // we are not inheriting from nsPipe ;-)
-    NS_DECL_ISUPPORTS_INHERITED
-
-    NS_DECL_NSIOUTPUTSTREAM
-    NS_DECL_NSIASYNCOUTPUTSTREAM
-    NS_DECL_NSISEEKABLESTREAM
-
-    nsPipeOutputStream(nsPipe *pipe)
-        : mPipe(pipe)
-        , mWriterRefCnt(0)
-        , mLogicalOffset(0)
-        , mBlocking(PR_TRUE)
-        , mBlocked(PR_FALSE)
-        , mWritable(PR_TRUE)
-        , mCallbackFlags(0)
-        { }
-
-    void SetNonBlocking(PRBool aNonBlocking) { mBlocking = !aNonBlocking; }
-    void SetWritable(PRBool writable) { mWritable = writable; }
-
-    // synchronously wait for the pipe to become writable.
-    nsresult Wait();
-
-    // these functions return true to indicate that the pipe's monitor should
-    // be notified, to wake up a blocked writer if any.
-    PRBool   OnOutputWritable(nsPipeEvents &);
-    PRBool   OnOutputException(nsresult, nsPipeEvents &);
-
-private:
-    nsPipe                         *mPipe;
-
-    // separate refcnt so that we know when to close the producer
-    nsrefcnt                        mWriterRefCnt;
-    nsInt64                         mLogicalOffset;
-    PRPackedBool                    mBlocking;
-
-    // these variables can only be accessed while inside the pipe's monitor
-    PRPackedBool                    mBlocked;
-    PRPackedBool                    mWritable;
-    nsCOMPtr<nsIOutputStreamCallback> mCallback;
-    PRUint32                        mCallbackFlags;
-};
-
-//-----------------------------------------------------------------------------
-
-class nsPipe : public nsIPipe
-{
-public:
-    friend class nsPipeInputStream;
-    friend class nsPipeOutputStream;
-
-    NS_DECL_ISUPPORTS
-    NS_DECL_NSIPIPE
-
-    // nsPipe methods:
-    nsPipe();
-
-private:
-    ~nsPipe();
-
-public:
-    //
-    // methods below may only be called while inside the pipe's monitor
-    //
-
-    void PeekSegment(PRUint32 n, char *&cursor, char *&limit);
-
-    //
-    // methods below may be called while outside the pipe's monitor
-    //
- 
-    nsresult GetReadSegment(const char *&segment, PRUint32 &segmentLen);
-    void     AdvanceReadCursor(PRUint32 count);
-
-    nsresult GetWriteSegment(char *&segment, PRUint32 &segmentLen);
-    void     AdvanceWriteCursor(PRUint32 count);
-
-    void     OnPipeException(nsresult reason, PRBool outputOnly = PR_FALSE);
-
-protected:
-    // We can't inherit from both nsIInputStream and nsIOutputStream
-    // because they collide on their Close method. Consequently we nest their
-    // implementations to avoid the extra object allocation.
-    nsPipeInputStream   mInput;
-    nsPipeOutputStream  mOutput;
-
-    PRMonitor*          mMonitor;
-    nsSegmentedBuffer   mBuffer;
-
-    char*               mReadCursor;
-    char*               mReadLimit;
-
-    PRInt32             mWriteSegment;
-    char*               mWriteCursor;
-    char*               mWriteLimit;
-
-    nsresult            mStatus;
-};
-
-//
-// NOTES on buffer architecture:
-//
-//       +-----------------+ - - mBuffer.GetSegment(0)
-//       |                 |
-//       + - - - - - - - - + - - mReadCursor
-//       |/////////////////|
-//       |/////////////////|
-//       |/////////////////|
-//       |/////////////////|
-//       +-----------------+ - - mReadLimit
-//                |
-//       +-----------------+
-//       |/////////////////|
-//       |/////////////////|
-//       |/////////////////|
-//       |/////////////////|
-//       |/////////////////|
-//       |/////////////////|
-//       +-----------------+
-//                |
-//       +-----------------+ - - mBuffer.GetSegment(mWriteSegment)
-//       |/////////////////|
-//       |/////////////////|
-//       |/////////////////|
-//       + - - - - - - - - + - - mWriteCursor
-//       |                 |
-//       |                 |
-//       +-----------------+ - - mWriteLimit
-//
-// (shaded region contains data)
-//
-// NOTE: on some systems (notably OS/2), the heap allocator uses an arena for
-// small allocations (e.g., 64 byte allocations).  this means that buffers may
-// be allocated back-to-back.  in the diagram above, for example, mReadLimit
-// would actually be pointing at the beginning of the next segment.  when
-// making changes to this file, please keep this fact in mind.
-//
-
-//-----------------------------------------------------------------------------
-// nsPipe methods:
-//-----------------------------------------------------------------------------
-
-nsPipe::nsPipe()
-    : mInput(this)
-    , mOutput(this)
-    , mMonitor(nsnull)
-    , mReadCursor(nsnull)
-    , mReadLimit(nsnull)
-    , mWriteSegment(-1)
-    , mWriteCursor(nsnull)
-    , mWriteLimit(nsnull)
-    , mStatus(NS_OK)
-{
-}
-
-nsPipe::~nsPipe()
-{
-    if (mMonitor)
-        PR_DestroyMonitor(mMonitor);
-}
-
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsPipe, nsIPipe)
-
-NS_IMETHODIMP
-nsPipe::Init(PRBool nonBlockingIn,
-             PRBool nonBlockingOut,
-             PRUint32 segmentSize,
-             PRUint32 segmentCount,
-             nsIMemory *segmentAlloc)
-{
-    mMonitor = PR_NewMonitor();
-    if (!mMonitor)
-        return NS_ERROR_OUT_OF_MEMORY;
-
-    if (segmentSize == 0)
-        segmentSize = DEFAULT_SEGMENT_SIZE;
-    if (segmentCount == 0)
-        segmentCount = DEFAULT_SEGMENT_COUNT;
-
-    // protect against overflow
-    PRUint32 maxCount = PRUint32(-1) / segmentSize;
-    if (segmentCount > maxCount)
-        segmentCount = maxCount;
-
-    nsresult rv = mBuffer.Init(segmentSize, segmentSize * segmentCount, segmentAlloc);
-    if (NS_FAILED(rv))
-        return rv;
-
-    mInput.SetNonBlocking(nonBlockingIn);
-    mOutput.SetNonBlocking(nonBlockingOut);
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsPipe::GetInputStream(nsIAsyncInputStream **aInputStream)
-{
-    NS_ADDREF(*aInputStream = &mInput);
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsPipe::GetOutputStream(nsIAsyncOutputStream **aOutputStream)
-{
-    NS_ADDREF(*aOutputStream = &mOutput);
-    return NS_OK;
-}
-
-void
-nsPipe::PeekSegment(PRUint32 index, char *&cursor, char *&limit)
-{
-    if (index == 0) {
-        NS_ASSERTION(!mReadCursor || mBuffer.GetSegmentCount(), "unexpected state");
-        cursor = mReadCursor;
-        limit = mReadLimit;
-    }
-    else {
-        PRUint32 numSegments = mBuffer.GetSegmentCount();
-        if (index >= numSegments)
-            cursor = limit = nsnull;
-        else {
-            cursor = mBuffer.GetSegment(index);
-            if (mWriteSegment == (PRInt32) index)
-                limit = mWriteCursor;
-            else
-                limit = cursor + mBuffer.GetSegmentSize();
-        }
-    }
-}
-
-nsresult
-nsPipe::GetReadSegment(const char *&segment, PRUint32 &segmentLen)
-{
-    nsAutoMonitor mon(mMonitor);
-
-    if (mReadCursor == mReadLimit)
-        return NS_FAILED(mStatus) ? mStatus : NS_BASE_STREAM_WOULD_BLOCK;
-
-    segment    = mReadCursor;
-    segmentLen = mReadLimit - mReadCursor;
-    return NS_OK;
-}
-
-void
-nsPipe::AdvanceReadCursor(PRUint32 bytesRead)
-{
-    NS_ASSERTION(bytesRead, "dont call if no bytes read");
-
-    nsPipeEvents events;
-    {
-        nsAutoMonitor mon(mMonitor);
-
-        LOG(("III advancing read cursor by %u\n", bytesRead));
-        NS_ASSERTION(bytesRead <= mBuffer.GetSegmentSize(), "read too much");
-
-        mReadCursor += bytesRead;
-        NS_ASSERTION(mReadCursor <= mReadLimit, "read cursor exceeds limit");
-
-        mInput.ReduceAvailable(bytesRead);
-
-        if (mReadCursor == mReadLimit) {
-            // we've reached the limit of how much we can read from this segment.
-            // if at the end of this segment, then we must discard this segment.
-
-            // if still writing in this segment then bail because we're not done
-            // with the segment and have to wait for now...
-            if (mWriteSegment == 0 && mWriteLimit > mWriteCursor) {
-                NS_ASSERTION(mReadLimit == mWriteCursor, "unexpected state");
-                return;
-            }
-
-            // shift write segment index (-1 indicates an empty buffer).
-            --mWriteSegment;
-
-            // done with this segment
-            mBuffer.DeleteFirstSegment();
-            LOG(("III deleting first segment\n"));
-
-            if (mWriteSegment == -1) {
-                // buffer is completely empty
-                mReadCursor = nsnull;
-                mReadLimit = nsnull;
-                mWriteCursor = nsnull;
-                mWriteLimit = nsnull;
-            }
-            else {
-                // advance read cursor and limit to next buffer segment
-                mReadCursor = mBuffer.GetSegment(0);
-                if (mWriteSegment == 0)
-                    mReadLimit = mWriteCursor;
-                else
-                    mReadLimit = mReadCursor + mBuffer.GetSegmentSize();
-            }
-
-            // we've free'd up a segment, so notify output stream that pipe has
-            // room for a new segment.
-            if (mOutput.OnOutputWritable(events))
-                mon.Notify();
-        }
-    }
-}
-
-nsresult
-nsPipe::GetWriteSegment(char *&segment, PRUint32 &segmentLen)
-{
-    nsAutoMonitor mon(mMonitor);
-
-    if (NS_FAILED(mStatus))
-        return mStatus;
-
-    // write cursor and limit may both be null indicating an empty buffer.
-    if (mWriteCursor == mWriteLimit) {
-        char *seg = mBuffer.AppendNewSegment();
-        // pipe is full
-        if (seg == nsnull)
-            return NS_BASE_STREAM_WOULD_BLOCK;
-        LOG(("OOO appended new segment\n"));
-        mWriteCursor = seg;
-        mWriteLimit = mWriteCursor + mBuffer.GetSegmentSize();
-        ++mWriteSegment;
-    }
-
-    // make sure read cursor is initialized
-    if (mReadCursor == nsnull) {
-        NS_ASSERTION(mWriteSegment == 0, "unexpected null read cursor");
-        mReadCursor = mReadLimit = mWriteCursor;
-    }
-
-    // check to see if we can roll-back our read and write cursors to the 
-    // beginning of the current/first segment.  this is purely an optimization.
-    if (mReadCursor == mWriteCursor && mWriteSegment == 0) {
-        char *head = mBuffer.GetSegment(0);
-        LOG(("OOO rolling back write cursor %u bytes\n", mWriteCursor - head));
-        mWriteCursor = mReadCursor = mReadLimit = head;
-    }
-
-    segment    = mWriteCursor;
-    segmentLen = mWriteLimit - mWriteCursor;
-    return NS_OK;
-}
-
-void
-nsPipe::AdvanceWriteCursor(PRUint32 bytesWritten)
-{
-    NS_ASSERTION(bytesWritten, "dont call if no bytes written");
-
-    nsPipeEvents events;
-    {
-        nsAutoMonitor mon(mMonitor);
-
-        LOG(("OOO advancing write cursor by %u\n", bytesWritten));
-
-        char *newWriteCursor = mWriteCursor + bytesWritten;
-        NS_ASSERTION(newWriteCursor <= mWriteLimit, "write cursor exceeds limit");
-
-        // update read limit if reading in the same segment
-        if (mWriteSegment == 0 && mReadLimit == mWriteCursor)
-            mReadLimit = newWriteCursor;
-
-        mWriteCursor = newWriteCursor;
-
-        NS_ASSERTION(mReadCursor != mWriteCursor, "read cursor is bad");
-
-        // update the writable flag on the output stream
-        if (mWriteCursor == mWriteLimit) {
-            if (mBuffer.GetSize() >= mBuffer.GetMaxSize())
-                mOutput.SetWritable(PR_FALSE);
-        }
-
-        // notify input stream that pipe now contains additional data
-        if (mInput.OnInputReadable(bytesWritten, events))
-            mon.Notify();
-    }
-}
-
-void
-nsPipe::OnPipeException(nsresult reason, PRBool outputOnly)
-{
-    LOG(("PPP nsPipe::OnPipeException [reason=%x output-only=%d]\n",
-        reason, outputOnly));
-
-    nsPipeEvents events;
-    {
-        nsAutoMonitor mon(mMonitor);
-
-        // if we've already hit an exception, then ignore this one.
-        if (NS_FAILED(mStatus))
-            return;
-
-        mStatus = reason;
-
-        // an output-only exception applies to the input end if the pipe has
-        // zero bytes available.
-        if (outputOnly && !mInput.Available())
-            outputOnly = PR_FALSE;
-
-        if (!outputOnly)
-            if (mInput.OnInputException(reason, events))
-                mon.Notify();
-
-        if (mOutput.OnOutputException(reason, events))
-            mon.Notify();
-    }
-}
-
-//-----------------------------------------------------------------------------
-// nsPipeEvents methods:
-//-----------------------------------------------------------------------------
-
-nsPipeEvents::~nsPipeEvents()
-{
-    // dispatch any pending events
-
-    if (mInputCallback) {
-        mInputCallback->OnInputStreamReady(mInputStream);
-        mInputCallback = 0;
-        mInputStream = 0;
-    }
-    if (mOutputCallback) {
-        mOutputCallback->OnOutputStreamReady(mOutputStream);
-        mOutputCallback = 0;
-        mOutputStream = 0;
-    }
-}
-
-//-----------------------------------------------------------------------------
-// nsPipeInputStream methods:
-//-----------------------------------------------------------------------------
-
-nsresult
-nsPipeInputStream::Wait()
-{
-    NS_ASSERTION(mBlocking, "wait on non-blocking pipe input stream");
-
-    nsAutoMonitor mon(mPipe->mMonitor);
-
-    while (NS_SUCCEEDED(mPipe->mStatus) && (mAvailable == 0)) {
-        LOG(("III pipe input: waiting for data\n"));
-
-        mBlocked = PR_TRUE;
-        mon.Wait();
-        mBlocked = PR_FALSE;
-
-        LOG(("III pipe input: woke up [pipe-status=%x available=%u]\n",
-            mPipe->mStatus, mAvailable));
-    }
-
-    return mPipe->mStatus == NS_BASE_STREAM_CLOSED ? NS_OK : mPipe->mStatus;
-}
-
-PRBool
-nsPipeInputStream::OnInputReadable(PRUint32 bytesWritten, nsPipeEvents &events)
-{
-    PRBool result = PR_FALSE;
-
-    mAvailable += bytesWritten;
-
-    if (mCallback && !(mCallbackFlags & WAIT_CLOSURE_ONLY)) {
-        events.NotifyInputReady(this, mCallback);
-        mCallback = 0;
-        mCallbackFlags = 0;
-    }
-    else if (mBlocked)
-        result = PR_TRUE;
-
-    return result;
-}
-
-PRBool
-nsPipeInputStream::OnInputException(nsresult reason, nsPipeEvents &events)
-{
-    LOG(("nsPipeInputStream::OnInputException [this=%x reason=%x]\n",
-        this, reason));
-
-    PRBool result = PR_FALSE;
-
-    NS_ASSERTION(NS_FAILED(reason), "huh? successful exception");
-
-    // force count of available bytes to zero.
-    mAvailable = 0;
-
-    if (mCallback) {
-        events.NotifyInputReady(this, mCallback);
-        mCallback = 0;
-        mCallbackFlags = 0;
-    }
-    else if (mBlocked)
-        result = PR_TRUE;
-
-    return result;
-}
-
-NS_IMETHODIMP_(nsrefcnt)
-nsPipeInputStream::AddRef(void)
-{
-    ++mReaderRefCnt;
-    return mPipe->AddRef();
-}
-
-NS_IMETHODIMP_(nsrefcnt)
-nsPipeInputStream::Release(void)
-{
-    if (--mReaderRefCnt == 0)
-        Close();
-    return mPipe->Release();
-}
-
-NS_IMPL_QUERY_INTERFACE4(nsPipeInputStream,
-                         nsIInputStream,
-                         nsIAsyncInputStream,
-                         nsISeekableStream,
-                         nsISearchableInputStream)
-
-NS_IMETHODIMP
-nsPipeInputStream::CloseWithStatus(nsresult reason)
-{
-    LOG(("III CloseWithStatus [this=%x reason=%x]\n", this, reason));
-
-    if (NS_SUCCEEDED(reason))
-        reason = NS_BASE_STREAM_CLOSED;
-
-    mPipe->OnPipeException(reason);
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsPipeInputStream::Close()
-{
-    return CloseWithStatus(NS_BASE_STREAM_CLOSED);
-}
-
-NS_IMETHODIMP
-nsPipeInputStream::Available(PRUint32 *result)
-{
-    nsAutoMonitor mon(mPipe->mMonitor);
-
-    // return error if pipe closed
-    if (!mAvailable && NS_FAILED(mPipe->mStatus))
-        return mPipe->mStatus;
-
-    *result = mAvailable;
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsPipeInputStream::ReadSegments(nsWriteSegmentFun writer, 
-                                void *closure,  
-                                PRUint32 count,
-                                PRUint32 *readCount)
-{
-    LOG(("III ReadSegments [this=%x count=%u]\n", this, count));
-
-    nsresult rv = NS_OK;
-
-    const char *segment;
-    PRUint32 segmentLen;
-
-    *readCount = 0;
-    while (count) {
-        rv = mPipe->GetReadSegment(segment, segmentLen);
-        if (NS_FAILED(rv)) {
-            // ignore this error if we've already read something.
-            if (*readCount > 0) {
-                rv = NS_OK;
-                break;
-            }
-            if (rv == NS_BASE_STREAM_WOULD_BLOCK) {
-                // pipe is empty
-                if (!mBlocking)
-                    break;
-                // wait for some data to be written to the pipe
-                rv = Wait();
-                if (NS_SUCCEEDED(rv))
-                    continue;
-            }
-            // ignore this error, just return.
-            if (rv == NS_BASE_STREAM_CLOSED) {
-                rv = NS_OK;
-                break;
-            }
-            mPipe->OnPipeException(rv);
-            break;
-        }
-
-        // read no more than count
-        if (segmentLen > count)
-            segmentLen = count;
-
-        PRUint32 writeCount, originalLen = segmentLen;
-        while (segmentLen) {
-            writeCount = 0;
-
-            rv = writer(this, closure, segment, *readCount, segmentLen, &writeCount);
-
-            if (NS_FAILED(rv) || writeCount == 0) {
-                count = 0;
-                // any errors returned from the writer end here: do not
-                // propogate to the caller of ReadSegments.
-                rv = NS_OK;
-                break;
-            }
-
-            NS_ASSERTION(writeCount <= segmentLen, "wrote more than expected");
-            segment += writeCount;
-            segmentLen -= writeCount;
-            count -= writeCount;
-            *readCount += writeCount;
-            mLogicalOffset += writeCount;
-        }
-
-        if (segmentLen < originalLen)
-            mPipe->AdvanceReadCursor(originalLen - segmentLen);
-    }
-
-    return rv;
-}
-
-static NS_METHOD
-nsWriteToRawBuffer(nsIInputStream* inStr,
-                   void *closure,
-                   const char *fromRawSegment,
-                   PRUint32 offset,
-                   PRUint32 count,
-                   PRUint32 *writeCount)
-{
-    char *toBuf = (char*)closure;
-    memcpy(&toBuf[offset], fromRawSegment, count);
-    *writeCount = count;
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsPipeInputStream::Read(char* toBuf, PRUint32 bufLen, PRUint32 *readCount)
-{
-    return ReadSegments(nsWriteToRawBuffer, toBuf, bufLen, readCount);
-}
-
-NS_IMETHODIMP
-nsPipeInputStream::IsNonBlocking(PRBool *aNonBlocking)
-{
-    *aNonBlocking = !mBlocking;
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsPipeInputStream::AsyncWait(nsIInputStreamCallback *callback,
-                             PRUint32 flags,
-                             PRUint32 requestedCount,
-                             nsIEventTarget *target)
-{
-    LOG(("III AsyncWait [this=%x]\n", this));
-
-    nsPipeEvents pipeEvents;
-    {
-        nsAutoMonitor mon(mPipe->mMonitor);
-
-        // replace a pending callback
-        mCallback = 0;
-        mCallbackFlags = 0;
-
-        nsCOMPtr<nsIInputStreamCallback> proxy;
-        if (target) {
-            nsresult rv = NS_NewInputStreamReadyEvent(getter_AddRefs(proxy),
-                                                      callback, target);
-            if (NS_FAILED(rv)) return rv;
-            callback = proxy;
-        }
-
-        if (NS_FAILED(mPipe->mStatus) ||
-                (mAvailable && !(flags & WAIT_CLOSURE_ONLY))) {
-            // stream is already closed or readable; post event.
-            pipeEvents.NotifyInputReady(this, callback);
-        }
-        else {
-            // queue up callback object to be notified when data becomes available
-            mCallback = callback;
-            mCallbackFlags = flags;
-        }
-    }
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsPipeInputStream::Seek(PRInt32 whence, PRInt64 offset)
-{
-    NS_NOTREACHED("nsPipeInputStream::Seek");
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP
-nsPipeInputStream::Tell(PRInt64 *offset)
-{
-    *offset = mLogicalOffset;
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsPipeInputStream::SetEOF()
-{
-    NS_NOTREACHED("nsPipeInputStream::SetEOF");
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-#define COMPARE(s1, s2, i)                                                 \
-    (ignoreCase                                                            \
-     ? nsCRT::strncasecmp((const char *)s1, (const char *)s2, (PRUint32)i) \
-     : nsCRT::strncmp((const char *)s1, (const char *)s2, (PRUint32)i))
-
-NS_IMETHODIMP
-nsPipeInputStream::Search(const char *forString, 
-                          PRBool ignoreCase,
-                          PRBool *found,
-                          PRUint32 *offsetSearchedTo)
-{
-    LOG(("III Search [for=%s ic=%u]\n", forString, ignoreCase));
-
-    nsAutoMonitor mon(mPipe->mMonitor);
-
-    char *cursor1, *limit1;
-    PRUint32 index = 0, offset = 0;
-    PRUint32 strLen = strlen(forString);
-
-    mPipe->PeekSegment(0, cursor1, limit1);
-    if (cursor1 == limit1) {
-        *found = PR_FALSE;
-        *offsetSearchedTo = 0;
-        LOG(("  result [found=%u offset=%u]\n", *found, *offsetSearchedTo));
-        return NS_OK;
-    }
-
-    while (PR_TRUE) {
-        PRUint32 i, len1 = limit1 - cursor1;
-
-        // check if the string is in the buffer segment
-        for (i = 0; i < len1 - strLen + 1; i++) {
-            if (COMPARE(&cursor1[i], forString, strLen) == 0) {
-                *found = PR_TRUE;
-                *offsetSearchedTo = offset + i;
-                LOG(("  result [found=%u offset=%u]\n", *found, *offsetSearchedTo));
-                return NS_OK;
-            }
-        }
-
-        // get the next segment
-        char *cursor2, *limit2;
-        PRUint32 len2;
-
-        index++;
-        offset += len1;
-
-        mPipe->PeekSegment(index, cursor2, limit2);
-        if (cursor2 == limit2) {
-            *found = PR_FALSE;
-            *offsetSearchedTo = offset - strLen + 1;
-            LOG(("  result [found=%u offset=%u]\n", *found, *offsetSearchedTo));
-            return NS_OK;
-        }
-        len2 = limit2 - cursor2;
-
-        // check if the string is straddling the next buffer segment
-        PRUint32 lim = PR_MIN(strLen, len2 + 1);
-        for (i = 0; i < lim; ++i) {
-            PRUint32 strPart1Len = strLen - i - 1;
-            PRUint32 strPart2Len = strLen - strPart1Len;
-            const char* strPart2 = &forString[strLen - strPart2Len];
-            PRUint32 bufSeg1Offset = len1 - strPart1Len;
-            if (COMPARE(&cursor1[bufSeg1Offset], forString, strPart1Len) == 0 &&
-                COMPARE(cursor2, strPart2, strPart2Len) == 0) {
-                *found = PR_TRUE;
-                *offsetSearchedTo = offset - strPart1Len;
-                LOG(("  result [found=%u offset=%u]\n", *found, *offsetSearchedTo));
-                return NS_OK;
-            }
-        }
-
-        // finally continue with the next buffer
-        cursor1 = cursor2;
-        limit1 = limit2;
-    }
-
-    NS_NOTREACHED("can't get here");
-    return NS_ERROR_UNEXPECTED;    // keep compiler happy
-}
-
-//-----------------------------------------------------------------------------
-// nsPipeOutputStream methods:
-//-----------------------------------------------------------------------------
-
-nsresult
-nsPipeOutputStream::Wait()
-{
-    NS_ASSERTION(mBlocking, "wait on non-blocking pipe output stream");
-
-    nsAutoMonitor mon(mPipe->mMonitor);
-
-    if (NS_SUCCEEDED(mPipe->mStatus) && !mWritable) {
-        LOG(("OOO pipe output: waiting for space\n"));
-        mBlocked = PR_TRUE;
-        mon.Wait();
-        mBlocked = PR_FALSE;
-        LOG(("OOO pipe output: woke up [pipe-status=%x writable=%u]\n",
-            mPipe->mStatus, mWritable == PR_TRUE));
-    }
-
-    return mPipe->mStatus == NS_BASE_STREAM_CLOSED ? NS_OK : mPipe->mStatus;
-}
-
-PRBool
-nsPipeOutputStream::OnOutputWritable(nsPipeEvents &events)
-{
-    PRBool result = PR_FALSE;
-
-    mWritable = PR_TRUE;
-
-    if (mCallback && !(mCallbackFlags & WAIT_CLOSURE_ONLY)) {
-        events.NotifyOutputReady(this, mCallback);
-        mCallback = 0;
-        mCallbackFlags = 0;
-    }
-    else if (mBlocked)
-        result = PR_TRUE;
-
-    return result;
-}
-
-PRBool
-nsPipeOutputStream::OnOutputException(nsresult reason, nsPipeEvents &events)
-{
-    LOG(("nsPipeOutputStream::OnOutputException [this=%x reason=%x]\n",
-        this, reason));
-
-    nsresult result = PR_FALSE;
-
-    NS_ASSERTION(NS_FAILED(reason), "huh? successful exception");
-    mWritable = PR_FALSE;
-
-    if (mCallback) {
-        events.NotifyOutputReady(this, mCallback);
-        mCallback = 0;
-        mCallbackFlags = 0;
-    }
-    else if (mBlocked)
-        result = PR_TRUE;
-
-    return result;
-}
-
-
-NS_IMETHODIMP_(nsrefcnt)
-nsPipeOutputStream::AddRef()
-{
-    mWriterRefCnt++;
-    return mPipe->AddRef();
-}
-
-NS_IMETHODIMP_(nsrefcnt)
-nsPipeOutputStream::Release()
-{
-    if (--mWriterRefCnt == 0)
-        Close();
-    return mPipe->Release();
-}
-
-NS_IMPL_QUERY_INTERFACE2(nsPipeOutputStream,
-                         nsIOutputStream,
-                         nsIAsyncOutputStream)
-
-NS_IMETHODIMP
-nsPipeOutputStream::CloseWithStatus(nsresult reason)
-{
-    LOG(("OOO CloseWithStatus [this=%x reason=%x]\n", this, reason));
-
-    if (NS_SUCCEEDED(reason))
-        reason = NS_BASE_STREAM_CLOSED;
-
-    // input stream may remain open
-    mPipe->OnPipeException(reason, PR_TRUE);
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsPipeOutputStream::Close()
-{
-    return CloseWithStatus(NS_BASE_STREAM_CLOSED);
-}
-
-NS_IMETHODIMP
-nsPipeOutputStream::WriteSegments(nsReadSegmentFun reader,
-                                  void* closure,
-                                  PRUint32 count,
-                                  PRUint32 *writeCount)
-{
-    LOG(("OOO WriteSegments [this=%x count=%u]\n", this, count));
-
-    nsresult rv = NS_OK;
-
-    char *segment;
-    PRUint32 segmentLen;
-
-    *writeCount = 0;
-    while (count) {
-        rv = mPipe->GetWriteSegment(segment, segmentLen);
-        if (NS_FAILED(rv)) {
-            if (rv == NS_BASE_STREAM_WOULD_BLOCK) {
-                // pipe is full
-                if (!mBlocking) {
-                    // ignore this error if we've already written something
-                    if (*writeCount > 0)
-                        rv = NS_OK;
-                    break;
-                }
-                // wait for the pipe to have an empty segment.
-                rv = Wait();
-                if (NS_SUCCEEDED(rv))
-                    continue;
-            }
-            mPipe->OnPipeException(rv);
-            break;
-        }
-
-        // write no more than count
-        if (segmentLen > count)
-            segmentLen = count;
-
-        PRUint32 readCount, originalLen = segmentLen;
-        while (segmentLen) {
-            readCount = 0;
-
-            rv = reader(this, closure, segment, *writeCount, segmentLen, &readCount);
-
-            if (NS_FAILED(rv) || readCount == 0) {
-                count = 0;
-                // any errors returned from the reader end here: do not
-                // propogate to the caller of WriteSegments.
-                rv = NS_OK;
-                break;
-            }
-
-            NS_ASSERTION(readCount <= segmentLen, "read more than expected");
-            segment += readCount;
-            segmentLen -= readCount;
-            count -= readCount;
-            *writeCount += readCount;
-            mLogicalOffset += readCount;
-        }
-
-        if (segmentLen < originalLen)
-            mPipe->AdvanceWriteCursor(originalLen - segmentLen);
-    }
-
-    return rv;
-}
-
-static NS_METHOD
-nsReadFromRawBuffer(nsIOutputStream* outStr,
-                    void* closure,
-                    char* toRawSegment,
-                    PRUint32 offset,
-                    PRUint32 count,
-                    PRUint32 *readCount)
-{
-    const char* fromBuf = (const char*)closure;
-    memcpy(toRawSegment, &fromBuf[offset], count);
-    *readCount = count;
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsPipeOutputStream::Write(const char* fromBuf,
-                          PRUint32 bufLen, 
-                          PRUint32 *writeCount)
-{
-    return WriteSegments(nsReadFromRawBuffer, (void*)fromBuf, bufLen, writeCount);
-}
-
-NS_IMETHODIMP
-nsPipeOutputStream::Flush(void)
-{
-    // nothing to do
-    return NS_OK;
-}
-
-static NS_METHOD
-nsReadFromInputStream(nsIOutputStream* outStr,
-                      void* closure,
-                      char* toRawSegment, 
-                      PRUint32 offset,
-                      PRUint32 count,
-                      PRUint32 *readCount)
-{
-    nsIInputStream* fromStream = (nsIInputStream*)closure;
-    return fromStream->Read(toRawSegment, count, readCount);
-}
-
-NS_IMETHODIMP
-nsPipeOutputStream::WriteFrom(nsIInputStream* fromStream,
-                              PRUint32 count,
-                              PRUint32 *writeCount)
-{
-    return WriteSegments(nsReadFromInputStream, fromStream, count, writeCount);
-}
-
-NS_IMETHODIMP
-nsPipeOutputStream::IsNonBlocking(PRBool *aNonBlocking)
-{
-    *aNonBlocking = !mBlocking;
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsPipeOutputStream::AsyncWait(nsIOutputStreamCallback *callback,
-                              PRUint32 flags,
-                              PRUint32 requestedCount,
-                              nsIEventTarget *target)
-{
-    LOG(("OOO AsyncWait [this=%x]\n", this));
-
-    nsPipeEvents pipeEvents;
-    {
-        nsAutoMonitor mon(mPipe->mMonitor);
-
-        // replace a pending callback
-        mCallback = 0;
-        mCallbackFlags = 0;
-
-        nsCOMPtr<nsIOutputStreamCallback> proxy;
-        if (target) {
-            nsresult rv = NS_NewOutputStreamReadyEvent(getter_AddRefs(proxy),
-                                                       callback, target);
-            if (NS_FAILED(rv)) return rv;
-            callback = proxy;
-        }
-
-        if (NS_FAILED(mPipe->mStatus) ||
-                (mWritable && !(flags & WAIT_CLOSURE_ONLY))) {
-            // stream is already closed or writable; post event.
-            pipeEvents.NotifyOutputReady(this, callback);
-        }
-        else {
-            // queue up callback object to be notified when data becomes available
-            mCallback = callback;
-            mCallbackFlags = flags;
-        }
-    }
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsPipeOutputStream::Seek(PRInt32 whence, PRInt64 offset)
-{
-    NS_NOTREACHED("nsPipeOutputStream::Seek");
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP
-nsPipeOutputStream::Tell(PRInt64 *offset)
-{
-    *offset = mLogicalOffset;
-    return NS_OK;
-}
-
-NS_IMETHODIMP
-nsPipeOutputStream::SetEOF()
-{
-    NS_NOTREACHED("nsPipeOutputStream::SetEOF");
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-NS_COM nsresult
-NS_NewPipe2(nsIAsyncInputStream **pipeIn,
-            nsIAsyncOutputStream **pipeOut,
-            PRBool nonBlockingInput,
-            PRBool nonBlockingOutput,
-            PRUint32 segmentSize,
-            PRUint32 segmentCount,
-            nsIMemory *segmentAlloc)
-{
-    nsresult rv;
-
-#if defined(PR_LOGGING)
-    if (!gPipeLog)
-        gPipeLog = PR_NewLogModule("nsPipe");
-#endif
-
-    nsPipe *pipe = new nsPipe();
-    if (!pipe)
-        return NS_ERROR_OUT_OF_MEMORY;
-
-    rv = pipe->Init(nonBlockingInput,
-                    nonBlockingOutput,
-                    segmentSize,
-                    segmentCount,
-                    segmentAlloc);
-    if (NS_FAILED(rv)) {
-        NS_ADDREF(pipe);
-        NS_RELEASE(pipe);
-        return rv;
-    }
-
-    pipe->GetInputStream(pipeIn);
-    pipe->GetOutputStream(pipeOut);
-    return NS_OK;
-}
-
-////////////////////////////////////////////////////////////////////////////////
Index: trunk/src/libs/xpcom18a4/xpcom/io/nsStreamUtils.cpp
===================================================================
--- trunk/src/libs/xpcom18a4/xpcom/io/nsStreamUtils.cpp	(revision 101808)
+++ 	(revision )
@@ -1,583 +1,0 @@
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Darin Fisher <darin@netscape.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include "nsStreamUtils.h"
-#include "nsCOMPtr.h"
-#include "nsIPipe.h"
-#include "nsIEventTarget.h"
-#include "nsAutoLock.h"
-
-//-----------------------------------------------------------------------------
-
-class nsInputStreamReadyEvent : public PLEvent
-                              , public nsIInputStreamCallback
-{
-public:
-    NS_DECL_ISUPPORTS
-
-    nsInputStreamReadyEvent(nsIInputStreamCallback *callback,
-                            nsIEventTarget *target)
-        : mCallback(callback)
-        , mTarget(target)
-    {
-    }
-
-private:
-    ~nsInputStreamReadyEvent()
-    {
-        if (mCallback) {
-            nsresult rv;
-            //
-            // whoa!!  looks like we never posted this event.  take care to
-            // release mCallback on the correct thread.  if mTarget lives on the
-            // calling thread, then we are ok.  otherwise, we have to try to 
-            // proxy the Release over the right thread.  if that thread is dead,
-            // then there's nothing we can do... better to leak than crash.
-            //
-            PRBool val;
-            rv = mTarget->IsOnCurrentThread(&val);
-            if (NS_FAILED(rv) || !val) {
-                nsCOMPtr<nsIInputStreamCallback> event;
-                NS_NewInputStreamReadyEvent(getter_AddRefs(event), mCallback, mTarget);
-                mCallback = 0;
-                if (event) {
-                    rv = event->OnInputStreamReady(nsnull);
-                    if (NS_FAILED(rv)) {
-                        NS_NOTREACHED("leaking stream event");
-                        nsISupports *sup = event;
-                        NS_ADDREF(sup);
-                    }
-                }
-            }
-        }
-    }
-
-public:
-    NS_IMETHOD OnInputStreamReady(nsIAsyncInputStream *stream)
-    {
-        mStream = stream;
-
-        // will be released when event is handled
-        NS_ADDREF_THIS();
-
-        PL_InitEvent(this, nsnull, EventHandler, EventCleanup);
-
-        if (NS_FAILED(mTarget->PostEvent(this))) {
-            NS_WARNING("PostEvent failed");
-            NS_RELEASE_THIS();
-            return NS_ERROR_FAILURE;
-        }
-
-        return NS_OK;
-    }
-
-private:
-    nsCOMPtr<nsIAsyncInputStream>    mStream;
-    nsCOMPtr<nsIInputStreamCallback> mCallback;
-    nsCOMPtr<nsIEventTarget>         mTarget;
-
-    PR_STATIC_CALLBACK(void *) EventHandler(PLEvent *plevent)
-    {
-        nsInputStreamReadyEvent *ev = (nsInputStreamReadyEvent *) plevent;
-        // bypass event delivery if this is a cleanup event...
-        if (ev->mCallback)
-            ev->mCallback->OnInputStreamReady(ev->mStream);
-        ev->mCallback = 0;
-        return NULL;
-    }
-
-    PR_STATIC_CALLBACK(void) EventCleanup(PLEvent *plevent)
-    {
-        nsInputStreamReadyEvent *ev = (nsInputStreamReadyEvent *) plevent;
-        NS_RELEASE(ev);
-    }
-};
-
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsInputStreamReadyEvent,
-                              nsIInputStreamCallback)
-
-//-----------------------------------------------------------------------------
-
-class nsOutputStreamReadyEvent : public PLEvent
-                               , public nsIOutputStreamCallback
-{
-public:
-    NS_DECL_ISUPPORTS
-
-    nsOutputStreamReadyEvent(nsIOutputStreamCallback *callback,
-                             nsIEventTarget *target)
-        : mCallback(callback)
-        , mTarget(target)
-    {
-    }
-
-private:
-    ~nsOutputStreamReadyEvent()
-    {
-        if (mCallback) {
-            nsresult rv;
-            //
-            // whoa!!  looks like we never posted this event.  take care to
-            // release mCallback on the correct thread.  if mTarget lives on the
-            // calling thread, then we are ok.  otherwise, we have to try to 
-            // proxy the Release over the right thread.  if that thread is dead,
-            // then there's nothing we can do... better to leak than crash.
-            //
-            PRBool val;
-            rv = mTarget->IsOnCurrentThread(&val);
-            if (NS_FAILED(rv) || !val) {
-                nsCOMPtr<nsIOutputStreamCallback> event;
-                NS_NewOutputStreamReadyEvent(getter_AddRefs(event), mCallback, mTarget);
-                mCallback = 0;
-                if (event) {
-                    rv = event->OnOutputStreamReady(nsnull);
-                    if (NS_FAILED(rv)) {
-                        NS_NOTREACHED("leaking stream event");
-                        nsISupports *sup = event;
-                        NS_ADDREF(sup);
-                    }
-                }
-            }
-        }
-    }
-
-public:
-    void Init(nsIOutputStreamCallback *callback, nsIEventTarget *target)
-    {
-        mCallback = callback;
-        mTarget = target;
-
-        PL_InitEvent(this, nsnull, EventHandler, EventCleanup);
-    }
-
-    NS_IMETHOD OnOutputStreamReady(nsIAsyncOutputStream *stream)
-    {
-        mStream = stream;
-
-        // this will be released when the event is handled
-        NS_ADDREF_THIS();
-
-        PL_InitEvent(this, nsnull, EventHandler, EventCleanup);
-
-        if (NS_FAILED(mTarget->PostEvent(this))) {
-            NS_WARNING("PostEvent failed");
-            NS_RELEASE_THIS();
-            return NS_ERROR_FAILURE;
-        }
-
-        return NS_OK;
-    }
-
-private:
-    nsCOMPtr<nsIAsyncOutputStream>    mStream;
-    nsCOMPtr<nsIOutputStreamCallback> mCallback;
-    nsCOMPtr<nsIEventTarget>          mTarget;
-
-    PR_STATIC_CALLBACK(void *) EventHandler(PLEvent *plevent)
-    {
-        nsOutputStreamReadyEvent *ev = (nsOutputStreamReadyEvent *) plevent;
-        if (ev->mCallback)
-            ev->mCallback->OnOutputStreamReady(ev->mStream);
-        ev->mCallback = 0;
-        return NULL;
-    }
-
-    PR_STATIC_CALLBACK(void) EventCleanup(PLEvent *ev)
-    {
-        nsOutputStreamReadyEvent *event = (nsOutputStreamReadyEvent *) ev;
-        NS_RELEASE(event);
-    }
-};
-
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsOutputStreamReadyEvent,
-                              nsIOutputStreamCallback)
-
-//-----------------------------------------------------------------------------
-
-NS_COM nsresult
-NS_NewInputStreamReadyEvent(nsIInputStreamCallback **event,
-                            nsIInputStreamCallback *callback,
-                            nsIEventTarget *target)
-{
-    nsInputStreamReadyEvent *ev = new nsInputStreamReadyEvent(callback, target);
-    if (!ev)
-        return NS_ERROR_OUT_OF_MEMORY;
-    NS_ADDREF(*event = ev);
-    return NS_OK;
-}
-
-NS_COM nsresult
-NS_NewOutputStreamReadyEvent(nsIOutputStreamCallback **event,
-                             nsIOutputStreamCallback *callback,
-                             nsIEventTarget *target)
-{
-    nsOutputStreamReadyEvent *ev = new nsOutputStreamReadyEvent(callback, target);
-    if (!ev)
-        return NS_ERROR_OUT_OF_MEMORY;
-    NS_ADDREF(*event = ev);
-    return NS_OK;
-}
-
-//-----------------------------------------------------------------------------
-// NS_AsyncCopy implementation
-
-// abstract stream copier...
-class nsAStreamCopier : public nsIInputStreamCallback
-                      , public nsIOutputStreamCallback
-{
-public:
-    NS_DECL_ISUPPORTS
-
-    nsAStreamCopier()
-        : mLock(nsnull)
-        , mCallback(nsnull)
-        , mClosure(nsnull)
-        , mChunkSize(0)
-        , mEventInProcess(PR_FALSE)
-        , mEventIsPending(PR_FALSE)
-    {
-    }
-
-    // virtual since subclasses call superclass Release()
-    virtual ~nsAStreamCopier()
-    {
-        if (mLock)
-            PR_DestroyLock(mLock);
-    }
-
-    // kick off the async copy...
-    nsresult Start(nsIInputStream *source,
-                   nsIOutputStream *sink,
-                   nsIEventTarget *target,
-                   nsAsyncCopyCallbackFun callback,
-                   void *closure,
-                   PRUint32 chunksize)
-    {
-        mSource = source;
-        mSink = sink;
-        mTarget = target;
-        mCallback = callback;
-        mClosure = closure;
-        mChunkSize = chunksize;
-
-        mLock = PR_NewLock();
-        if (!mLock)
-            return NS_ERROR_OUT_OF_MEMORY;
-
-        mAsyncSource = do_QueryInterface(mSource);
-        mAsyncSink = do_QueryInterface(mSink);
-
-        return PostContinuationEvent();
-    }
-
-    // implemented by subclasses, returns number of bytes copied and
-    // sets source and sink condition before returning.
-    virtual PRUint32 DoCopy(nsresult *sourceCondition, nsresult *sinkCondition) = 0;
-
-    void Process()
-    {
-        if (!mSource || !mSink)
-            return;
-
-        nsresult sourceCondition, sinkCondition;
-
-        // ok, copy data from source to sink.
-        for (;;) {
-            PRUint32 n = DoCopy(&sourceCondition, &sinkCondition);
-            if (NS_FAILED(sourceCondition) || NS_FAILED(sinkCondition) || n == 0) {
-                if (sourceCondition == NS_BASE_STREAM_WOULD_BLOCK && mAsyncSource) {
-                    // need to wait for more data from source.  while waiting for
-                    // more source data, be sure to observe failures on output end.
-                    mAsyncSource->AsyncWait(this, 0, 0, nsnull);
-
-                    if (mAsyncSink)
-                        mAsyncSink->AsyncWait(this,
-                                              nsIAsyncOutputStream::WAIT_CLOSURE_ONLY,
-                                              0, nsnull);
-                }
-                else if (sinkCondition == NS_BASE_STREAM_WOULD_BLOCK && mAsyncSink) {
-                    // need to wait for more room in the sink.  while waiting for
-                    // more room in the sink, be sure to observer failures on the
-                    // input end.
-                    mAsyncSink->AsyncWait(this, 0, 0, nsnull);
-
-                    if (mAsyncSource)
-                        mAsyncSource->AsyncWait(this,
-                                                nsIAsyncInputStream::WAIT_CLOSURE_ONLY,
-                                                0, nsnull);
-                }
-                else {
-                    // close source
-                    if (mAsyncSource)
-                        mAsyncSource->CloseWithStatus(sinkCondition);
-                    else
-                        mSource->Close();
-                    mAsyncSource = nsnull;
-                    mSource = nsnull;
-
-                    // close sink
-                    if (mAsyncSink)
-                        mAsyncSink->CloseWithStatus(sourceCondition);
-                    else
-                        mSink->Close();
-                    mAsyncSink = nsnull;
-                    mSink = nsnull;
-
-                    // notify state complete...
-                    if (mCallback) {
-                        nsresult status = sourceCondition;
-                        if (NS_SUCCEEDED(status))
-                            status = sinkCondition;
-                        if (status == NS_BASE_STREAM_CLOSED)
-                            status = NS_OK;
-                        mCallback(mClosure, status);
-                    }
-                }
-                break;
-            }
-        }
-    }
-
-    NS_IMETHOD OnInputStreamReady(nsIAsyncInputStream *source)
-    {
-        PostContinuationEvent();
-        return NS_OK;
-    }
-
-    NS_IMETHOD OnOutputStreamReady(nsIAsyncOutputStream *sink)
-    {
-        PostContinuationEvent();
-        return NS_OK;
-    }
-
-    PR_STATIC_CALLBACK(void*) HandleContinuationEvent(PLEvent *event)
-    {
-        nsAStreamCopier *self = (nsAStreamCopier *) event->owner;
-        self->Process();
-
-        // clear "in process" flag and post any pending continuation event
-        nsAutoLock lock(self->mLock);
-        self->mEventInProcess = PR_FALSE;
-        if (self->mEventIsPending) {
-            self->mEventIsPending = PR_FALSE;
-            self->PostContinuationEvent_Locked();
-        }
-        return nsnull;
-    }
-
-    PR_STATIC_CALLBACK(void) DestroyContinuationEvent(PLEvent *event)
-    {
-        nsAStreamCopier *self = (nsAStreamCopier *) event->owner;
-        NS_RELEASE(self);
-        delete event;
-    }
-
-    nsresult PostContinuationEvent()
-    {
-        // we cannot post a continuation event if there is currently
-        // an event in process.  doing so could result in Process being
-        // run simultaneously on multiple threads, so we mark the event
-        // as pending, and if an event is already in process then we 
-        // just let that existing event take care of posting the real
-        // continuation event.
-
-        nsAutoLock lock(mLock);
-        return PostContinuationEvent_Locked();
-    }
-
-    nsresult PostContinuationEvent_Locked()
-    {
-        nsresult rv = NS_OK;
-        if (mEventInProcess)
-            mEventIsPending = PR_TRUE;
-        else {
-            PLEvent *event = new PLEvent;
-            if (!event)
-                rv = NS_ERROR_OUT_OF_MEMORY;
-            else {
-                NS_ADDREF_THIS();
-                PL_InitEvent(event, this,
-                             HandleContinuationEvent,
-                             DestroyContinuationEvent);
-
-                rv = mTarget->PostEvent(event);
-                if (NS_SUCCEEDED(rv))
-                    mEventInProcess = PR_TRUE;
-                else {
-                    NS_ERROR("unable to post continuation event");
-                    PL_DestroyEvent(event);
-                }
-            }
-        }
-        return rv;
-    }
-
-protected:
-    nsCOMPtr<nsIInputStream>       mSource;
-    nsCOMPtr<nsIOutputStream>      mSink;
-    nsCOMPtr<nsIAsyncInputStream>  mAsyncSource;
-    nsCOMPtr<nsIAsyncOutputStream> mAsyncSink;
-    nsCOMPtr<nsIEventTarget>       mTarget;
-    PRLock                        *mLock;
-    nsAsyncCopyCallbackFun         mCallback;
-    void                          *mClosure;
-    PRUint32                       mChunkSize;
-    PRPackedBool                   mEventInProcess;
-    PRPackedBool                   mEventIsPending;
-};
-
-NS_IMPL_THREADSAFE_ISUPPORTS2(nsAStreamCopier,
-                              nsIInputStreamCallback,
-                              nsIOutputStreamCallback)
-
-class nsStreamCopierIB : public nsAStreamCopier
-{
-public:
-    nsStreamCopierIB() : nsAStreamCopier() {}
-    virtual ~nsStreamCopierIB() {}
-
-    struct ReadSegmentsState {
-        nsIOutputStream *mSink;
-        nsresult         mSinkCondition;
-    };
-
-    static NS_METHOD ConsumeInputBuffer(nsIInputStream *inStr,
-                                        void *closure,
-                                        const char *buffer,
-                                        PRUint32 offset,
-                                        PRUint32 count,
-                                        PRUint32 *countWritten)
-    {
-        ReadSegmentsState *state = (ReadSegmentsState *) closure;
-
-        nsresult rv = state->mSink->Write(buffer, count, countWritten);
-        if (NS_FAILED(rv))
-            state->mSinkCondition = rv;
-        else if (*countWritten == 0)
-            state->mSinkCondition = NS_BASE_STREAM_CLOSED;
-
-        return state->mSinkCondition;
-    }
-
-    PRUint32 DoCopy(nsresult *sourceCondition, nsresult *sinkCondition)
-    {
-        ReadSegmentsState state;
-        state.mSink = mSink;
-        state.mSinkCondition = NS_OK;
-
-        PRUint32 n;
-        *sourceCondition =
-            mSource->ReadSegments(ConsumeInputBuffer, &state, mChunkSize, &n);
-        *sinkCondition = state.mSinkCondition;
-        return n;
-    }
-};
-
-class nsStreamCopierOB : public nsAStreamCopier
-{
-public:
-    nsStreamCopierOB() : nsAStreamCopier() {}
-    virtual ~nsStreamCopierOB() {}
-
-    struct WriteSegmentsState {
-        nsIInputStream *mSource;
-        nsresult        mSourceCondition;
-    };
-
-    static NS_METHOD FillOutputBuffer(nsIOutputStream *outStr,
-                                      void *closure,
-                                      char *buffer,
-                                      PRUint32 offset,
-                                      PRUint32 count,
-                                      PRUint32 *countRead)
-    {
-        WriteSegmentsState *state = (WriteSegmentsState *) closure;
-
-        nsresult rv = state->mSource->Read(buffer, count, countRead);
-        if (NS_FAILED(rv))
-            state->mSourceCondition = rv;
-        else if (*countRead == 0)
-            state->mSourceCondition = NS_BASE_STREAM_CLOSED;
-
-        return state->mSourceCondition;
-    }
-
-    PRUint32 DoCopy(nsresult *sourceCondition, nsresult *sinkCondition)
-    {
-        WriteSegmentsState state;
-        state.mSource = mSource;
-        state.mSourceCondition = NS_OK;
-
-        PRUint32 n;
-        *sinkCondition =
-            mSink->WriteSegments(FillOutputBuffer, &state, mChunkSize, &n);
-        *sourceCondition = state.mSourceCondition;
-        return n;
-    }
-};
-
-//-----------------------------------------------------------------------------
-
-NS_COM nsresult
-NS_AsyncCopy(nsIInputStream         *source,
-             nsIOutputStream        *sink,
-             nsIEventTarget         *target,
-             nsAsyncCopyMode         mode,
-             PRUint32                chunkSize,
-             nsAsyncCopyCallbackFun  callback,
-             void                   *closure)
-{
-    NS_ASSERTION(target, "non-null target required");
-
-    nsresult rv;
-    nsAStreamCopier *copier;
-
-    if (mode == NS_ASYNCCOPY_VIA_READSEGMENTS)
-        copier = new nsStreamCopierIB();
-    else
-        copier = new nsStreamCopierOB();
-
-    if (!copier)
-        return NS_ERROR_OUT_OF_MEMORY;
-
-    // Start() takes an owning ref to the copier...
-    NS_ADDREF(copier);
-    rv = copier->Start(source, sink, target, callback, closure, chunkSize);
-    NS_RELEASE(copier);
-
-    return rv;
-}
Index: trunk/src/libs/xpcom18a4/xpcom/io/nsStreamUtils.h
===================================================================
--- trunk/src/libs/xpcom18a4/xpcom/io/nsStreamUtils.h	(revision 101808)
+++ 	(revision )
@@ -1,111 +1,0 @@
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is Mozilla.
- *
- * The Initial Developer of the Original Code is
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 2002
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Darin Fisher <darin@netscape.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#ifndef nsStreamUtils_h__
-#define nsStreamUtils_h__
-
-#include "nscore.h"
-
-class nsIInputStream;
-class nsIOutputStream;
-class nsIInputStreamCallback;
-class nsIOutputStreamCallback;
-class nsIEventTarget;
-
-/**
- * A "one-shot" proxy of the OnInputStreamReady callback.  The resulting
- * proxy object's OnInputStreamReady function may only be called once!  The
- * proxy object ensures that the real notify object will be free'd on the
- * thread corresponding to the given event target regardless of what thread
- * the proxy object is destroyed on.
- *
- * This function is designed to be used to implement AsyncWait when the
- * aEventTarget parameter is non-null.
- */
-extern NS_COM nsresult
-NS_NewInputStreamReadyEvent(nsIInputStreamCallback **aEvent,
-                            nsIInputStreamCallback  *aNotify,
-                            nsIEventTarget          *aEventTarget);
-
-/**
- * A "one-shot" proxy of the OnOutputStreamReady callback.  The resulting
- * proxy object's OnOutputStreamReady function may only be called once!  The
- * proxy object ensures that the real notify object will be free'd on the
- * thread corresponding to the given event target regardless of what thread 
- * the proxy object is destroyed on.
- *
- * This function is designed to be used to implement AsyncWait when the
- * aEventTarget parameter is non-null.
- */
-extern NS_COM nsresult
-NS_NewOutputStreamReadyEvent(nsIOutputStreamCallback **aEvent,
-                             nsIOutputStreamCallback  *aNotify,
-                             nsIEventTarget           *aEventTarget);
-
-/* ------------------------------------------------------------------------- */
-
-enum nsAsyncCopyMode {
-    NS_ASYNCCOPY_VIA_READSEGMENTS,
-    NS_ASYNCCOPY_VIA_WRITESEGMENTS
-};
-
-/**
- * This function is called when the async copy process completes.  The reported
- * status is NS_OK on success and some error code on failure.
- */
-typedef void (* nsAsyncCopyCallbackFun)(void *closure, nsresult status);
-
-/**
- * This function asynchronously copies data from the source to the sink. All
- * data transfer occurs on the thread corresponding to the given event target.
- * A null event target is not permitted.
- *
- * The copier handles blocking or non-blocking streams transparently.  If a
- * stream operation returns NS_BASE_STREAM_WOULD_BLOCK, then the stream will
- * be QI'd to nsIAsync{In,Out}putStream and its AsyncWait method will be used
- * to determine when to resume copying.
- */
-extern NS_COM nsresult
-NS_AsyncCopy(nsIInputStream         *aSource,
-             nsIOutputStream        *aSink,
-             nsIEventTarget         *aEventTarget,
-             nsAsyncCopyMode         aMode = NS_ASYNCCOPY_VIA_READSEGMENTS,
-             PRUint32                aChunkSize = 4096,
-             nsAsyncCopyCallbackFun  aCallbackFun = nsnull,
-             void                   *aCallbackClosure = nsnull);
-
-#endif // !nsStreamUtils_h__
