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 "js/ArrayBuffer.h"  // JS::{GetArrayBuffer{ByteLength,Data},IsArrayBufferObject}
  10 #include "js/RootingAPI.h"  // JS::{Handle,Rooted}
  11 #include "js/Value.h"       // JS::Value
  12 #include "mozilla/Span.h"
  13 #include "mozilla/UniquePtrExtensions.h"
  14 #include "mozilla/dom/ScriptSettings.h"
  15
  16 using mozilla::dom::RootingCx;
  17
  18 NS_IMPL_ISUPPORTS(ArrayBufferInputStream, nsIArrayBufferInputStream,
  19                   nsIInputStream);
  20
  21 NS_IMETHODIMP
  22 ArrayBufferInputStream::SetDataFromJS(JS::Handle<JS::Value> aBuffer,
  23                                       uint64_t aByteOffset, uint64_t aLength) {
  24   NS_ASSERT_OWNINGTHREAD(ArrayBufferInputStream);
  25
  26   if (!aBuffer.isObject()) {
  27     return NS_ERROR_FAILURE;
  28   }
  29   JS::Rooted<JSObject*> arrayBuffer(RootingCx(), &aBuffer.toObject());
  30   if (!JS::IsArrayBufferObject(arrayBuffer)) {
  31     return NS_ERROR_FAILURE;
  32   }
  33
  34   uint64_t buflen = JS::GetArrayBufferByteLength(arrayBuffer);
  35   uint64_t offset = std::min(buflen, aByteOffset);
  36   uint64_t bufferLength = std::min(buflen - offset, aLength);
  37
  38   // Prevent truncation.
  39   if (bufferLength > UINT32_MAX) {
  40     return NS_ERROR_INVALID_ARG;
  41   }
  42
  43   mArrayBuffer = mozilla::MakeUniqueFallible<uint8_t[]>(bufferLength);
  44   if (!mArrayBuffer) {
  45     return NS_ERROR_OUT_OF_MEMORY;
  46   }
  47
  48   mBufferLength = bufferLength;
  49
  50   JS::AutoCheckCannotGC nogc;
  51   bool isShared;
  52   uint8_t* src = JS::GetArrayBufferData(arrayBuffer, &isShared, nogc) + offset;
  53   memcpy(&mArrayBuffer[0], src, mBufferLength);
  54   return NS_OK;
  55 }
  56
  57 nsresult ArrayBufferInputStream::SetData(mozilla::UniquePtr<uint8_t[]> aBytes,
  58                                          uint64_t aByteLen) {
  59   mArrayBuffer = std::move(aBytes);
  60   mBufferLength = aByteLen;
  61   return NS_OK;
  62 }
  63
  64 NS_IMETHODIMP
  65 ArrayBufferInputStream::Close() {
  66   mClosed = true;
  67   return NS_OK;
  68 }
  69
  70 NS_IMETHODIMP
  71 ArrayBufferInputStream::Available(uint64_t* aCount) {
  72   if (mClosed) {
  73     return NS_BASE_STREAM_CLOSED;
  74   }
  75   if (mArrayBuffer) {
  76     *aCount = mBufferLength ? mBufferLength - mPos : 0;
  77   } else {
  78     *aCount = 0;
  79   }
  80   return NS_OK;
  81 }
  82
  83 NS_IMETHODIMP
  84 ArrayBufferInputStream::StreamStatus() {
  85   return mClosed ? NS_BASE_STREAM_CLOSED : NS_OK;
  86 }
  87
  88 NS_IMETHODIMP
  89 ArrayBufferInputStream::Read(char* aBuf, uint32_t aCount,
  90                              uint32_t* aReadCount) {
  91   return ReadSegments(NS_CopySegmentToBuffer, aBuf, aCount, aReadCount);
  92 }
  93
  94 NS_IMETHODIMP
  95 ArrayBufferInputStream::ReadSegments(nsWriteSegmentFun writer, void* closure,
  96                                      uint32_t aCount, uint32_t* result) {
  97   NS_ASSERTION(result, "null ptr");
  98   NS_ASSERTION(mBufferLength >= mPos, "bad stream state");
  99
 100   if (mClosed) {
 101     return NS_BASE_STREAM_CLOSED;
 102   }
 103
 104   MOZ_ASSERT(mArrayBuffer || (mPos == mBufferLength),
 105              "stream inited incorrectly");
 106
 107   *result = 0;
 108   while (mPos < mBufferLength) {
 109     uint32_t remaining = mBufferLength - mPos;
 110     MOZ_ASSERT(mArrayBuffer);
 111
 112     uint32_t count = std::min(aCount, remaining);
 113     if (count == 0) {
 114       break;
 115     }
 116
 117     uint32_t written;
 118     nsresult rv = writer(this, closure, (char*)&mArrayBuffer[0] + mPos, *result,
 119                          count, &written);
 120     if (NS_FAILED(rv)) {
 121       // InputStreams do not propagate errors to caller.
 122       return NS_OK;
 123     }
 124
 125     NS_ASSERTION(written <= count,
 126                  "writer should not write more than we asked it to write");
 127     mPos += written;
 128     *result += written;
 129     aCount -= written;
 130   }
 131
 132   return NS_OK;
 133 }
 134
 135 NS_IMETHODIMP
 136 ArrayBufferInputStream::IsNonBlocking(bool* aNonBlocking) {
 137   *aNonBlocking = true;
 138   return NS_OK;
 139 }