The Tor Browser: netwerk/base/src/nsPreloadedStream.cpp@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

     2 /* This Source Code Form is subject to the terms of the Mozilla Public

     3  * License, v. 2.0. If a copy of the MPL was not distributed with this

     4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     6 #include "nsPreloadedStream.h"

     7 #include "nsIRunnable.h"

     9 #include "nsThreadUtils.h"

    10 #include <algorithm>

    12 namespace mozilla {

    13 namespace net {

    15 NS_IMPL_ISUPPORTS(nsPreloadedStream,

    16                   nsIInputStream,

    17                   nsIAsyncInputStream)

    19 nsPreloadedStream::nsPreloadedStream(nsIAsyncInputStream *aStream,

    20                                      const char *data, uint32_t datalen)

    21     : mStream(aStream),

    22       mOffset(0),

    23       mLen(datalen)

    24 {

    25     mBuf = (char *) moz_xmalloc(datalen);

    26     memcpy(mBuf, data, datalen);

    27 }

    29 nsPreloadedStream::~nsPreloadedStream()

    30 {

    31     moz_free(mBuf);

    32 }

    34 NS_IMETHODIMP

    35 nsPreloadedStream::Close()

    36 {

    37     mLen = 0;

    38     return mStream->Close();

    39 }

    42 NS_IMETHODIMP

    43 nsPreloadedStream::Available(uint64_t *_retval)

    44 {

    45     uint64_t avail = 0;

    47     nsresult rv = mStream->Available(&avail);

    48     if (NS_FAILED(rv))

    49         return rv;

    50     *_retval = avail + mLen;

    51     return NS_OK;

    52 }

    54 NS_IMETHODIMP

    55 nsPreloadedStream::Read(char *aBuf, uint32_t aCount,

    56                         uint32_t *_retval)

    57 {

    58     if (!mLen)

    59         return mStream->Read(aBuf, aCount, _retval);

    61     uint32_t toRead = std::min(mLen, aCount);

    62     memcpy(aBuf, mBuf + mOffset, toRead);

    63     mOffset += toRead;

    64     mLen -= toRead;

    65     *_retval = toRead;

    66     return NS_OK;

    67 }

    69 NS_IMETHODIMP

    70 nsPreloadedStream::ReadSegments(nsWriteSegmentFun aWriter,

    71                                 void *aClosure, uint32_t aCount,

    72                                 uint32_t *result)

    73 {

    74     if (!mLen)

    75         return mStream->ReadSegments(aWriter, aClosure, aCount, result);

    77     *result = 0;

    78     while (mLen > 0 && aCount > 0) {

    79         uint32_t toRead = std::min(mLen, aCount);

    80         uint32_t didRead = 0;

    81         nsresult rv;

    83         rv = aWriter(this, aClosure, mBuf + mOffset, *result, toRead, &didRead);

    85         if (NS_FAILED(rv))

    86             return NS_OK;

    88         *result += didRead;

    89         mOffset += didRead;

    90         mLen -= didRead;

    91         aCount -= didRead;

    92     }

    94     return NS_OK;

    95 }

    97 NS_IMETHODIMP

    98 nsPreloadedStream::IsNonBlocking(bool *_retval)

    99 {

   100     return mStream->IsNonBlocking(_retval);

   101 }

   103 NS_IMETHODIMP

   104 nsPreloadedStream::CloseWithStatus(nsresult aStatus)

   105 {

   106     mLen = 0;

   107     return mStream->CloseWithStatus(aStatus);

   108 }

   110 class RunOnThread : public nsRunnable

   111 {

   112 public:

   113     RunOnThread(nsIAsyncInputStream *aStream,

   114                 nsIInputStreamCallback *aCallback)

   115       : mStream(aStream),

   116         mCallback(aCallback) {}

   118     virtual ~RunOnThread() {}

   120     NS_IMETHOD Run()

   121     {

   122         mCallback->OnInputStreamReady(mStream);

   123         return NS_OK;

   124     }

   126 private:

   127     nsCOMPtr<nsIAsyncInputStream>    mStream;

   128     nsCOMPtr<nsIInputStreamCallback> mCallback;

   129 };

   131 NS_IMETHODIMP

   132 nsPreloadedStream::AsyncWait(nsIInputStreamCallback *aCallback,

   133                              uint32_t aFlags,

   134                              uint32_t aRequestedCount,

   135                              nsIEventTarget *aEventTarget)

   136 {

   137     if (!mLen)

   138         return mStream->AsyncWait(aCallback, aFlags, aRequestedCount,

   139                                   aEventTarget);

   141     if (!aCallback)

   142         return NS_OK;

   144     if (!aEventTarget)

   145         return aCallback->OnInputStreamReady(this);

   147     nsCOMPtr<nsIRunnable> event =

   148         new RunOnThread(this, aCallback);

   149     return aEventTarget->Dispatch(event, nsIEventTarget::DISPATCH_NORMAL);

   150 }

   152 } // namespace net

   153 } // namespace mozilla

The Tor Browser / file revision