mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-04 11:26:09 +00:00
837f0af066
If class A is derived from class B, then an instance of class A can be converted to B via a static cast, so a slower QI is not needed. Differential Revision: https://phabricator.services.mozilla.com/D6861 --HG-- extra : moz-landing-system : lando
510 lines
14 KiB
C++
510 lines
14 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "FileReaderSync.h"
|
|
|
|
#include "jsfriendapi.h"
|
|
#include "mozilla/Unused.h"
|
|
#include "mozilla/Base64.h"
|
|
#include "mozilla/dom/File.h"
|
|
#include "mozilla/Encoding.h"
|
|
#include "mozilla/dom/FileReaderSyncBinding.h"
|
|
#include "nsCExternalHandlerService.h"
|
|
#include "nsComponentManagerUtils.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsError.h"
|
|
#include "nsIConverterInputStream.h"
|
|
#include "nsIInputStream.h"
|
|
#include "nsIMultiplexInputStream.h"
|
|
#include "nsStreamUtils.h"
|
|
#include "nsStringStream.h"
|
|
#include "nsISupportsImpl.h"
|
|
#include "nsNetUtil.h"
|
|
#include "nsServiceManagerUtils.h"
|
|
#include "nsIAsyncInputStream.h"
|
|
#include "mozilla/dom/WorkerPrivate.h"
|
|
#include "mozilla/dom/WorkerRunnable.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom;
|
|
using mozilla::dom::Optional;
|
|
using mozilla::dom::GlobalObject;
|
|
|
|
// static
|
|
already_AddRefed<FileReaderSync>
|
|
FileReaderSync::Constructor(const GlobalObject& aGlobal, ErrorResult& aRv)
|
|
{
|
|
RefPtr<FileReaderSync> frs = new FileReaderSync();
|
|
|
|
return frs.forget();
|
|
}
|
|
|
|
bool
|
|
FileReaderSync::WrapObject(JSContext* aCx,
|
|
JS::Handle<JSObject*> aGivenProto,
|
|
JS::MutableHandle<JSObject*> aReflector)
|
|
{
|
|
return FileReaderSync_Binding::Wrap(aCx, this, aGivenProto, aReflector);
|
|
}
|
|
|
|
void
|
|
FileReaderSync::ReadAsArrayBuffer(JSContext* aCx,
|
|
JS::Handle<JSObject*> aScopeObj,
|
|
Blob& aBlob,
|
|
JS::MutableHandle<JSObject*> aRetval,
|
|
ErrorResult& aRv)
|
|
{
|
|
uint64_t blobSize = aBlob.GetSize(aRv);
|
|
if (NS_WARN_IF(aRv.Failed())) {
|
|
return;
|
|
}
|
|
|
|
UniquePtr<char[], JS::FreePolicy> bufferData(
|
|
js_pod_arena_malloc<char>(js::ArrayBufferContentsArena, blobSize));
|
|
if (!bufferData) {
|
|
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIInputStream> stream;
|
|
aBlob.CreateInputStream(getter_AddRefs(stream), aRv);
|
|
if (NS_WARN_IF(aRv.Failed())) {
|
|
return;
|
|
}
|
|
|
|
uint32_t numRead;
|
|
aRv = SyncRead(stream, bufferData.get(), blobSize, &numRead);
|
|
if (NS_WARN_IF(aRv.Failed())) {
|
|
return;
|
|
}
|
|
|
|
// The file is changed in the meantime?
|
|
if (numRead != blobSize) {
|
|
aRv.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
JSObject* arrayBuffer = JS_NewArrayBufferWithContents(aCx, blobSize, bufferData.get());
|
|
if (!arrayBuffer) {
|
|
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
|
|
return;
|
|
}
|
|
// arrayBuffer takes the ownership when it is not null. Otherwise we
|
|
// need to release it explicitly.
|
|
mozilla::Unused << bufferData.release();
|
|
|
|
aRetval.set(arrayBuffer);
|
|
}
|
|
|
|
void
|
|
FileReaderSync::ReadAsBinaryString(Blob& aBlob,
|
|
nsAString& aResult,
|
|
ErrorResult& aRv)
|
|
{
|
|
nsCOMPtr<nsIInputStream> stream;
|
|
aBlob.CreateInputStream(getter_AddRefs(stream), aRv);
|
|
if (NS_WARN_IF(aRv.Failed())) {
|
|
return;
|
|
}
|
|
|
|
uint32_t numRead;
|
|
do {
|
|
char readBuf[4096];
|
|
aRv = SyncRead(stream, readBuf, sizeof(readBuf), &numRead);
|
|
if (NS_WARN_IF(aRv.Failed())) {
|
|
return;
|
|
}
|
|
|
|
uint32_t oldLength = aResult.Length();
|
|
AppendASCIItoUTF16(Substring(readBuf, readBuf + numRead), aResult);
|
|
if (aResult.Length() - oldLength != numRead) {
|
|
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
|
|
return;
|
|
}
|
|
} while (numRead > 0);
|
|
}
|
|
|
|
void
|
|
FileReaderSync::ReadAsText(Blob& aBlob,
|
|
const Optional<nsAString>& aEncoding,
|
|
nsAString& aResult,
|
|
ErrorResult& aRv)
|
|
{
|
|
nsCOMPtr<nsIInputStream> stream;
|
|
aBlob.CreateInputStream(getter_AddRefs(stream), aRv);
|
|
if (NS_WARN_IF(aRv.Failed())) {
|
|
return;
|
|
}
|
|
|
|
nsCString sniffBuf;
|
|
if (!sniffBuf.SetLength(3, fallible)) {
|
|
aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
|
|
return;
|
|
}
|
|
|
|
uint32_t numRead = 0;
|
|
aRv = SyncRead(stream, sniffBuf.BeginWriting(), sniffBuf.Length(), &numRead);
|
|
if (NS_WARN_IF(aRv.Failed())) {
|
|
return;
|
|
}
|
|
|
|
// No data, we don't need to continue.
|
|
if (numRead == 0) {
|
|
aResult.Truncate();
|
|
return;
|
|
}
|
|
|
|
// Try the API argument.
|
|
const Encoding* encoding = aEncoding.WasPassed() ?
|
|
Encoding::ForLabel(aEncoding.Value()) : nullptr;
|
|
if (!encoding) {
|
|
// API argument failed. Try the type property of the blob.
|
|
nsAutoString type16;
|
|
aBlob.GetType(type16);
|
|
NS_ConvertUTF16toUTF8 type(type16);
|
|
nsAutoCString specifiedCharset;
|
|
bool haveCharset;
|
|
int32_t charsetStart, charsetEnd;
|
|
NS_ExtractCharsetFromContentType(type,
|
|
specifiedCharset,
|
|
&haveCharset,
|
|
&charsetStart,
|
|
&charsetEnd);
|
|
encoding = Encoding::ForLabel(specifiedCharset);
|
|
if (!encoding) {
|
|
// Type property failed. Use UTF-8.
|
|
encoding = UTF_8_ENCODING;
|
|
}
|
|
}
|
|
|
|
if (numRead < sniffBuf.Length()) {
|
|
sniffBuf.Truncate(numRead);
|
|
}
|
|
|
|
// Let's recreate the full stream using a:
|
|
// multiplexStream(syncStream + original stream)
|
|
// In theory, we could try to see if the inputStream is a nsISeekableStream,
|
|
// but this doesn't work correctly for nsPipe3 - See bug 1349570.
|
|
|
|
nsCOMPtr<nsIMultiplexInputStream> multiplexStream =
|
|
do_CreateInstance("@mozilla.org/io/multiplex-input-stream;1");
|
|
if (NS_WARN_IF(!multiplexStream)) {
|
|
aRv.Throw(NS_ERROR_FAILURE);
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIInputStream> sniffStringStream;
|
|
aRv = NS_NewCStringInputStream(getter_AddRefs(sniffStringStream), sniffBuf);
|
|
if (NS_WARN_IF(aRv.Failed())) {
|
|
return;
|
|
}
|
|
|
|
aRv = multiplexStream->AppendStream(sniffStringStream);
|
|
if (NS_WARN_IF(aRv.Failed())) {
|
|
return;
|
|
}
|
|
|
|
uint64_t blobSize = aBlob.GetSize(aRv);
|
|
if (NS_WARN_IF(aRv.Failed())){
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIInputStream> syncStream;
|
|
aRv = ConvertAsyncToSyncStream(blobSize - sniffBuf.Length(), stream.forget(),
|
|
getter_AddRefs(syncStream));
|
|
if (NS_WARN_IF(aRv.Failed())) {
|
|
return;
|
|
}
|
|
|
|
// ConvertAsyncToSyncStream returns a null syncStream if the stream has been
|
|
// already closed or there is nothing to read.
|
|
if (syncStream) {
|
|
aRv = multiplexStream->AppendStream(syncStream);
|
|
if (NS_WARN_IF(aRv.Failed())) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
nsAutoCString charset;
|
|
encoding->Name(charset);
|
|
|
|
nsCOMPtr<nsIInputStream> multiplex(do_QueryInterface(multiplexStream));
|
|
aRv = ConvertStream(multiplex, charset.get(), aResult);
|
|
if (NS_WARN_IF(aRv.Failed())) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
void
|
|
FileReaderSync::ReadAsDataURL(Blob& aBlob, nsAString& aResult,
|
|
ErrorResult& aRv)
|
|
{
|
|
nsAutoString scratchResult;
|
|
scratchResult.AssignLiteral("data:");
|
|
|
|
nsString contentType;
|
|
aBlob.GetType(contentType);
|
|
|
|
if (contentType.IsEmpty()) {
|
|
scratchResult.AppendLiteral("application/octet-stream");
|
|
} else {
|
|
scratchResult.Append(contentType);
|
|
}
|
|
scratchResult.AppendLiteral(";base64,");
|
|
|
|
nsCOMPtr<nsIInputStream> stream;
|
|
aBlob.CreateInputStream(getter_AddRefs(stream), aRv);
|
|
if (NS_WARN_IF(aRv.Failed())){
|
|
return;
|
|
}
|
|
|
|
uint64_t blobSize = aBlob.GetSize(aRv);
|
|
if (NS_WARN_IF(aRv.Failed())){
|
|
return;
|
|
}
|
|
|
|
nsCOMPtr<nsIInputStream> syncStream;
|
|
aRv = ConvertAsyncToSyncStream(blobSize, stream.forget(),
|
|
getter_AddRefs(syncStream));
|
|
if (NS_WARN_IF(aRv.Failed())) {
|
|
return;
|
|
}
|
|
|
|
MOZ_ASSERT(syncStream);
|
|
|
|
uint64_t size;
|
|
aRv = syncStream->Available(&size);
|
|
if (NS_WARN_IF(aRv.Failed())) {
|
|
return;
|
|
}
|
|
|
|
// The file is changed in the meantime?
|
|
if (blobSize != size) {
|
|
return;
|
|
}
|
|
|
|
nsAutoString encodedData;
|
|
aRv = Base64EncodeInputStream(syncStream, encodedData, size);
|
|
if (NS_WARN_IF(aRv.Failed())){
|
|
return;
|
|
}
|
|
|
|
scratchResult.Append(encodedData);
|
|
|
|
aResult = scratchResult;
|
|
}
|
|
|
|
nsresult
|
|
FileReaderSync::ConvertStream(nsIInputStream *aStream,
|
|
const char *aCharset,
|
|
nsAString &aResult)
|
|
{
|
|
nsCOMPtr<nsIConverterInputStream> converterStream =
|
|
do_CreateInstance("@mozilla.org/intl/converter-input-stream;1");
|
|
NS_ENSURE_TRUE(converterStream, NS_ERROR_FAILURE);
|
|
|
|
nsresult rv = converterStream->Init(aStream, aCharset, 8192,
|
|
nsIConverterInputStream::DEFAULT_REPLACEMENT_CHARACTER);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
nsCOMPtr<nsIUnicharInputStream> unicharStream = converterStream;
|
|
NS_ENSURE_TRUE(unicharStream, NS_ERROR_FAILURE);
|
|
|
|
uint32_t numChars;
|
|
nsString result;
|
|
while (NS_SUCCEEDED(unicharStream->ReadString(8192, result, &numChars)) &&
|
|
numChars > 0) {
|
|
uint32_t oldLength = aResult.Length();
|
|
aResult.Append(result);
|
|
if (aResult.Length() - oldLength != result.Length()) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
namespace {
|
|
|
|
// This runnable is used to terminate the sync event loop.
|
|
class ReadReadyRunnable final : public WorkerSyncRunnable
|
|
{
|
|
public:
|
|
ReadReadyRunnable(WorkerPrivate* aWorkerPrivate,
|
|
nsIEventTarget* aSyncLoopTarget)
|
|
: WorkerSyncRunnable(aWorkerPrivate, aSyncLoopTarget)
|
|
{}
|
|
|
|
bool
|
|
WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate) override
|
|
{
|
|
aWorkerPrivate->AssertIsOnWorkerThread();
|
|
MOZ_ASSERT(mSyncLoopTarget);
|
|
|
|
nsCOMPtr<nsIEventTarget> syncLoopTarget;
|
|
mSyncLoopTarget.swap(syncLoopTarget);
|
|
|
|
aWorkerPrivate->StopSyncLoop(syncLoopTarget, true);
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
~ReadReadyRunnable()
|
|
{}
|
|
};
|
|
|
|
// This class implements nsIInputStreamCallback and it will be called when the
|
|
// stream is ready to be read.
|
|
class ReadCallback final : public nsIInputStreamCallback
|
|
{
|
|
public:
|
|
NS_DECL_THREADSAFE_ISUPPORTS
|
|
|
|
ReadCallback(WorkerPrivate* aWorkerPrivate, nsIEventTarget* aEventTarget)
|
|
: mWorkerPrivate(aWorkerPrivate)
|
|
, mEventTarget(aEventTarget)
|
|
{}
|
|
|
|
NS_IMETHOD
|
|
OnInputStreamReady(nsIAsyncInputStream* aStream) override
|
|
{
|
|
// I/O Thread. Now we need to block the sync event loop.
|
|
RefPtr<ReadReadyRunnable> runnable =
|
|
new ReadReadyRunnable(mWorkerPrivate, mEventTarget);
|
|
return mEventTarget->Dispatch(runnable.forget(), NS_DISPATCH_NORMAL);
|
|
}
|
|
|
|
private:
|
|
~ReadCallback()
|
|
{}
|
|
|
|
// The worker is kept alive because of the sync event loop.
|
|
WorkerPrivate* mWorkerPrivate;
|
|
nsCOMPtr<nsIEventTarget> mEventTarget;
|
|
};
|
|
|
|
NS_IMPL_ADDREF(ReadCallback);
|
|
NS_IMPL_RELEASE(ReadCallback);
|
|
|
|
NS_INTERFACE_MAP_BEGIN(ReadCallback)
|
|
NS_INTERFACE_MAP_ENTRY(nsIInputStreamCallback)
|
|
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIInputStreamCallback)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
} // anonymous
|
|
|
|
nsresult
|
|
FileReaderSync::SyncRead(nsIInputStream* aStream, char* aBuffer,
|
|
uint32_t aBufferSize, uint32_t* aRead)
|
|
{
|
|
MOZ_ASSERT(aStream);
|
|
MOZ_ASSERT(aBuffer);
|
|
MOZ_ASSERT(aRead);
|
|
|
|
// Let's try to read, directly.
|
|
nsresult rv = aStream->Read(aBuffer, aBufferSize, aRead);
|
|
|
|
// Nothing else to read.
|
|
if (rv == NS_BASE_STREAM_CLOSED ||
|
|
(NS_SUCCEEDED(rv) && *aRead == 0)) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// An error.
|
|
if (NS_FAILED(rv) && rv != NS_BASE_STREAM_WOULD_BLOCK) {
|
|
return rv;
|
|
}
|
|
|
|
// All good.
|
|
if (NS_SUCCEEDED(rv)) {
|
|
// Not enough data, let's read recursively.
|
|
if (*aRead != aBufferSize) {
|
|
uint32_t byteRead = 0;
|
|
rv = SyncRead(aStream, aBuffer + *aRead, aBufferSize - *aRead, &byteRead);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
*aRead += byteRead;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// We need to proceed async.
|
|
nsCOMPtr<nsIAsyncInputStream> asyncStream = do_QueryInterface(aStream);
|
|
if (!asyncStream) {
|
|
return rv;
|
|
}
|
|
|
|
WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
|
|
MOZ_ASSERT(workerPrivate);
|
|
|
|
AutoSyncLoopHolder syncLoop(workerPrivate, Canceling);
|
|
|
|
nsCOMPtr<nsIEventTarget> syncLoopTarget = syncLoop.GetEventTarget();
|
|
if (!syncLoopTarget) {
|
|
// SyncLoop creation can fail if the worker is shutting down.
|
|
return NS_ERROR_DOM_INVALID_STATE_ERR;
|
|
}
|
|
|
|
RefPtr<ReadCallback> callback =
|
|
new ReadCallback(workerPrivate, syncLoopTarget);
|
|
|
|
nsCOMPtr<nsIEventTarget> target =
|
|
do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
|
|
MOZ_ASSERT(target);
|
|
|
|
rv = asyncStream->AsyncWait(callback, 0, aBufferSize, target);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
if (!syncLoop.Run()) {
|
|
return NS_ERROR_DOM_INVALID_STATE_ERR;
|
|
}
|
|
|
|
// Now, we can try to read again.
|
|
return SyncRead(aStream, aBuffer, aBufferSize, aRead);
|
|
}
|
|
|
|
nsresult
|
|
FileReaderSync::ConvertAsyncToSyncStream(uint64_t aStreamSize,
|
|
already_AddRefed<nsIInputStream> aAsyncStream,
|
|
nsIInputStream** aSyncStream)
|
|
{
|
|
nsCOMPtr<nsIInputStream> asyncInputStream = std::move(aAsyncStream);
|
|
|
|
// If the stream is not async, we just need it to be bufferable.
|
|
nsCOMPtr<nsIAsyncInputStream> asyncStream = do_QueryInterface(asyncInputStream);
|
|
if (!asyncStream) {
|
|
return NS_NewBufferedInputStream(aSyncStream, asyncInputStream.forget(), 4096);
|
|
}
|
|
|
|
nsAutoCString buffer;
|
|
if (!buffer.SetLength(aStreamSize, fallible)) {
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
|
|
uint32_t read;
|
|
nsresult rv =
|
|
SyncRead(asyncInputStream, buffer.BeginWriting(), aStreamSize, &read);
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
if (read != aStreamSize) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
rv = NS_NewCStringInputStream(aSyncStream, std::move(buffer));
|
|
if (NS_WARN_IF(NS_FAILED(rv))) {
|
|
return rv;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|