netwerk/base/ArrayBufferInputStream.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   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/. */
   5
   6 #include <algorithm>
   7 #include "ArrayBufferInputStream.h"
   8 #include "nsStreamUtils.h"
   9 #include "jsapi.h"
  10 #include "jsfriendapi.h"
  11 #include "mozilla/UniquePtrExtensions.h"
  12 #include "mozilla/dom/ScriptSettings.h"
  13
  14 using mozilla::dom::RootingCx;
  15
  16 NS_IMPL_ISUPPORTS(ArrayBufferInputStream, nsIArrayBufferInputStream,
  17                   nsIInputStream);
  18
  19 ArrayBufferInputStream::ArrayBufferInputStream()
  20     : mBufferLength(0), mPos(0), mClosed(false) {}
  21
  22 NS_IMETHODIMP
  23 ArrayBufferInputStream::SetData(JS::Handle<JS::Value> aBuffer,
  24                                 uint32_t aByteOffset, uint32_t aLength) {
  25   NS_ASSERT_OWNINGTHREAD(ArrayBufferInputStream);
  26
  27   if (!aBuffer.isObject()) {
  28     return NS_ERROR_FAILURE;
  29   }
  30   JS::RootedObject arrayBuffer(RootingCx(), &aBuffer.toObject());
  31   if (!JS_IsArrayBufferObject(arrayBuffer)) {
  32     return NS_ERROR_FAILURE;
  33   }
  34
  35   uint32_t buflen = JS_GetArrayBufferByteLength(arrayBuffer);
  36   uint32_t offset = std::min(buflen, aByteOffset);
  37   uint32_t bufferLength = std::min(buflen - offset, aLength);
  38
  39   mArrayBuffer = mozilla::MakeUniqueFallible<char[]>(bufferLength);
  40   if (!mArrayBuffer) {
  41     return NS_ERROR_OUT_OF_MEMORY;
  42   }
  43
  44   mBufferLength = bufferLength;
  45
  46   JS::AutoCheckCannotGC nogc;
  47   bool isShared;
  48   char *src =
  49       (char *)JS_GetArrayBufferData(arrayBuffer, &isShared, nogc) + offset;
  50   memcpy(&mArrayBuffer[0], src, mBufferLength);
  51   return NS_OK;
  52 }
  53
  54 NS_IMETHODIMP
  55 ArrayBufferInputStream::Close() {
  56   mClosed = true;
  57   return NS_OK;
  58 }
  59
  60 NS_IMETHODIMP
  61 ArrayBufferInputStream::Available(uint64_t *aCount) {
  62   if (mClosed) {
  63     return NS_BASE_STREAM_CLOSED;
  64   }
  65   if (mArrayBuffer) {
  66     *aCount = mBufferLength ? mBufferLength - mPos : 0;
  67   } else {
  68     *aCount = 0;
  69   }
  70   return NS_OK;
  71 }
  72
  73 NS_IMETHODIMP
  74 ArrayBufferInputStream::Read(char *aBuf, uint32_t aCount,
  75                              uint32_t *aReadCount) {
  76   return ReadSegments(NS_CopySegmentToBuffer, aBuf, aCount, aReadCount);
  77 }
  78
  79 NS_IMETHODIMP
  80 ArrayBufferInputStream::ReadSegments(nsWriteSegmentFun writer, void *closure,
  81                                      uint32_t aCount, uint32_t *result) {
  82   NS_ASSERTION(result, "null ptr");
  83   NS_ASSERTION(mBufferLength >= mPos, "bad stream state");
  84
  85   if (mClosed) {
  86     return NS_BASE_STREAM_CLOSED;
  87   }
  88
  89   MOZ_ASSERT(mArrayBuffer || (mPos == mBufferLength),
  90              "stream inited incorrectly");
  91
  92   *result = 0;
  93   while (mPos < mBufferLength) {
  94     uint32_t remaining = mBufferLength - mPos;
  95     MOZ_ASSERT(mArrayBuffer);
  96
  97     uint32_t count = std::min(aCount, remaining);
  98     if (count == 0) {
  99       break;
 100     }
 101
 102     uint32_t written;
 103     nsresult rv = writer(this, closure, &mArrayBuffer[0] + mPos, *result, count,
 104                          &written);
 105     if (NS_FAILED(rv)) {
 106       // InputStreams do not propagate errors to caller.
 107       return NS_OK;
 108     }
 109
 110     NS_ASSERTION(written <= count,
 111                  "writer should not write more than we asked it to write");
 112     mPos += written;
 113     *result += written;
 114     aCount -= written;
 115   }
 116
 117   return NS_OK;
 118 }
 119
 120 NS_IMETHODIMP
 121 ArrayBufferInputStream::IsNonBlocking(bool *aNonBlocking) {
 122   *aNonBlocking = true;
 123   return NS_OK;
 124 }