diff options
Diffstat (limited to 'xpcom/io/nsStringStream.cpp')
| -rw-r--r-- | xpcom/io/nsStringStream.cpp | 452 |
1 files changed, 452 insertions, 0 deletions
diff --git a/xpcom/io/nsStringStream.cpp b/xpcom/io/nsStringStream.cpp new file mode 100644 index 000000000..b65242c14 --- /dev/null +++ b/xpcom/io/nsStringStream.cpp @@ -0,0 +1,452 @@ +/* -*- 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/. */ + +/** + * Based on original code from nsIStringStream.cpp + */ + +#include "ipc/IPCMessageUtils.h" + +#include "nsStringStream.h" +#include "nsStreamUtils.h" +#include "nsReadableUtils.h" +#include "nsICloneableInputStream.h" +#include "nsISeekableStream.h" +#include "nsISupportsPrimitives.h" +#include "nsCRT.h" +#include "prerror.h" +#include "plstr.h" +#include "nsIClassInfoImpl.h" +#include "mozilla/Attributes.h" +#include "mozilla/ipc/InputStreamUtils.h" +#include "nsIIPCSerializableInputStream.h" + +using namespace mozilla::ipc; +using mozilla::Maybe; +using mozilla::Some; + +//----------------------------------------------------------------------------- +// nsIStringInputStream implementation +//----------------------------------------------------------------------------- + +class nsStringInputStream final + : public nsIStringInputStream + , public nsISeekableStream + , public nsISupportsCString + , public nsIIPCSerializableInputStream + , public nsICloneableInputStream +{ +public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIINPUTSTREAM + NS_DECL_NSISTRINGINPUTSTREAM + NS_DECL_NSISEEKABLESTREAM + NS_DECL_NSISUPPORTSPRIMITIVE + NS_DECL_NSISUPPORTSCSTRING + NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM + NS_DECL_NSICLONEABLEINPUTSTREAM + + nsStringInputStream() + { + Clear(); + } + + explicit nsStringInputStream(const nsStringInputStream& aOther) + : mOffset(aOther.mOffset) + { + // Use Assign() here because we don't want the life of the clone to be + // dependent on the life of the original stream. + mData.Assign(aOther.mData); + } + +private: + ~nsStringInputStream() + { + } + + uint32_t Length() const + { + return mData.Length(); + } + + uint32_t LengthRemaining() const + { + return Length() - mOffset; + } + + void Clear() + { + mData.SetIsVoid(true); + } + + bool Closed() + { + return mData.IsVoid(); + } + + nsDependentCSubstring mData; + uint32_t mOffset; +}; + +// This class needs to support threadsafe refcounting since people often +// allocate a string stream, and then read it from a background thread. +NS_IMPL_ADDREF(nsStringInputStream) +NS_IMPL_RELEASE(nsStringInputStream) + +NS_IMPL_CLASSINFO(nsStringInputStream, nullptr, nsIClassInfo::THREADSAFE, + NS_STRINGINPUTSTREAM_CID) +NS_IMPL_QUERY_INTERFACE_CI(nsStringInputStream, + nsIStringInputStream, + nsIInputStream, + nsISupportsCString, + nsISeekableStream, + nsIIPCSerializableInputStream, + nsICloneableInputStream) +NS_IMPL_CI_INTERFACE_GETTER(nsStringInputStream, + nsIStringInputStream, + nsIInputStream, + nsISupportsCString, + nsISeekableStream, + nsICloneableInputStream) + +///////// +// nsISupportsCString implementation +///////// + +NS_IMETHODIMP +nsStringInputStream::GetType(uint16_t* aType) +{ + *aType = TYPE_CSTRING; + return NS_OK; +} + +NS_IMETHODIMP +nsStringInputStream::GetData(nsACString& data) +{ + // The stream doesn't have any data when it is closed. We could fake it + // and return an empty string here, but it seems better to keep this return + // value consistent with the behavior of the other 'getter' methods. + if (NS_WARN_IF(Closed())) { + return NS_BASE_STREAM_CLOSED; + } + + data.Assign(mData); + return NS_OK; +} + +NS_IMETHODIMP +nsStringInputStream::SetData(const nsACString& aData) +{ + mData.Assign(aData); + mOffset = 0; + return NS_OK; +} + +NS_IMETHODIMP +nsStringInputStream::ToString(char** aResult) +{ + // NOTE: This method may result in data loss, so we do not implement it. + return NS_ERROR_NOT_IMPLEMENTED; +} + +///////// +// nsIStringInputStream implementation +///////// + +NS_IMETHODIMP +nsStringInputStream::SetData(const char* aData, int32_t aDataLen) +{ + if (NS_WARN_IF(!aData)) { + return NS_ERROR_INVALID_ARG; + } + mData.Assign(aData, aDataLen); + mOffset = 0; + return NS_OK; +} + +NS_IMETHODIMP +nsStringInputStream::AdoptData(char* aData, int32_t aDataLen) +{ + if (NS_WARN_IF(!aData)) { + return NS_ERROR_INVALID_ARG; + } + mData.Adopt(aData, aDataLen); + mOffset = 0; + return NS_OK; +} + +NS_IMETHODIMP +nsStringInputStream::ShareData(const char* aData, int32_t aDataLen) +{ + if (NS_WARN_IF(!aData)) { + return NS_ERROR_INVALID_ARG; + } + + if (aDataLen < 0) { + aDataLen = strlen(aData); + } + + mData.Rebind(aData, aDataLen); + mOffset = 0; + return NS_OK; +} + +NS_IMETHODIMP_(size_t) +nsStringInputStream::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) +{ + size_t n = aMallocSizeOf(this); + n += mData.SizeOfExcludingThisIfUnshared(aMallocSizeOf); + return n; +} + +///////// +// nsIInputStream implementation +///////// + +NS_IMETHODIMP +nsStringInputStream::Close() +{ + Clear(); + return NS_OK; +} + +NS_IMETHODIMP +nsStringInputStream::Available(uint64_t* aLength) +{ + NS_ASSERTION(aLength, "null ptr"); + + if (Closed()) { + return NS_BASE_STREAM_CLOSED; + } + + *aLength = LengthRemaining(); + return NS_OK; +} + +NS_IMETHODIMP +nsStringInputStream::Read(char* aBuf, uint32_t aCount, uint32_t* aReadCount) +{ + NS_ASSERTION(aBuf, "null ptr"); + return ReadSegments(NS_CopySegmentToBuffer, aBuf, aCount, aReadCount); +} + +NS_IMETHODIMP +nsStringInputStream::ReadSegments(nsWriteSegmentFun aWriter, void* aClosure, + uint32_t aCount, uint32_t* aResult) +{ + NS_ASSERTION(aResult, "null ptr"); + NS_ASSERTION(Length() >= mOffset, "bad stream state"); + + if (Closed()) { + return NS_BASE_STREAM_CLOSED; + } + + // We may be at end-of-file + uint32_t maxCount = LengthRemaining(); + if (maxCount == 0) { + *aResult = 0; + return NS_OK; + } + + if (aCount > maxCount) { + aCount = maxCount; + } + nsresult rv = aWriter(this, aClosure, mData.BeginReading() + mOffset, 0, + aCount, aResult); + if (NS_SUCCEEDED(rv)) { + NS_ASSERTION(*aResult <= aCount, + "writer should not write more than we asked it to write"); + mOffset += *aResult; + } + + // errors returned from the writer end here! + return NS_OK; +} + +NS_IMETHODIMP +nsStringInputStream::IsNonBlocking(bool* aNonBlocking) +{ + *aNonBlocking = true; + return NS_OK; +} + +///////// +// nsISeekableStream implementation +///////// + +NS_IMETHODIMP +nsStringInputStream::Seek(int32_t aWhence, int64_t aOffset) +{ + if (Closed()) { + return NS_BASE_STREAM_CLOSED; + } + + // Compute new stream position. The given offset may be a negative value. + + int64_t newPos = aOffset; + switch (aWhence) { + case NS_SEEK_SET: + break; + case NS_SEEK_CUR: + newPos += mOffset; + break; + case NS_SEEK_END: + newPos += Length(); + break; + default: + NS_ERROR("invalid aWhence"); + return NS_ERROR_INVALID_ARG; + } + + if (NS_WARN_IF(newPos < 0) || NS_WARN_IF(newPos > Length())) { + return NS_ERROR_INVALID_ARG; + } + + mOffset = (uint32_t)newPos; + return NS_OK; +} + +NS_IMETHODIMP +nsStringInputStream::Tell(int64_t* aOutWhere) +{ + if (Closed()) { + return NS_BASE_STREAM_CLOSED; + } + + *aOutWhere = mOffset; + return NS_OK; +} + +NS_IMETHODIMP +nsStringInputStream::SetEOF() +{ + if (Closed()) { + return NS_BASE_STREAM_CLOSED; + } + + mOffset = Length(); + return NS_OK; +} + +///////// +// nsIIPCSerializableInputStream implementation +///////// + +void +nsStringInputStream::Serialize(InputStreamParams& aParams, + FileDescriptorArray& /* aFDs */) +{ + StringInputStreamParams params; + params.data() = PromiseFlatCString(mData); + aParams = params; +} + +bool +nsStringInputStream::Deserialize(const InputStreamParams& aParams, + const FileDescriptorArray& /* aFDs */) +{ + if (aParams.type() != InputStreamParams::TStringInputStreamParams) { + NS_ERROR("Received unknown parameters from the other process!"); + return false; + } + + const StringInputStreamParams& params = + aParams.get_StringInputStreamParams(); + + if (NS_FAILED(SetData(params.data()))) { + NS_WARNING("SetData failed!"); + return false; + } + + return true; +} + +Maybe<uint64_t> +nsStringInputStream::ExpectedSerializedLength() +{ + return Some(static_cast<uint64_t>(Length())); +} + +///////// +// nsICloneableInputStream implementation +///////// + +NS_IMETHODIMP +nsStringInputStream::GetCloneable(bool* aCloneableOut) +{ + *aCloneableOut = true; + return NS_OK; +} + +NS_IMETHODIMP +nsStringInputStream::Clone(nsIInputStream** aCloneOut) +{ + RefPtr<nsIInputStream> ref = new nsStringInputStream(*this); + ref.forget(aCloneOut); + return NS_OK; +} + +nsresult +NS_NewByteInputStream(nsIInputStream** aStreamResult, + const char* aStringToRead, int32_t aLength, + nsAssignmentType aAssignment) +{ + NS_PRECONDITION(aStreamResult, "null out ptr"); + + RefPtr<nsStringInputStream> stream = new nsStringInputStream(); + + nsresult rv; + switch (aAssignment) { + case NS_ASSIGNMENT_COPY: + rv = stream->SetData(aStringToRead, aLength); + break; + case NS_ASSIGNMENT_DEPEND: + rv = stream->ShareData(aStringToRead, aLength); + break; + case NS_ASSIGNMENT_ADOPT: + rv = stream->AdoptData(const_cast<char*>(aStringToRead), aLength); + break; + default: + NS_ERROR("invalid assignment type"); + rv = NS_ERROR_INVALID_ARG; + } + + if (NS_FAILED(rv)) { + return rv; + } + + stream.forget(aStreamResult); + return NS_OK; +} + +nsresult +NS_NewCStringInputStream(nsIInputStream** aStreamResult, + const nsACString& aStringToRead) +{ + NS_PRECONDITION(aStreamResult, "null out ptr"); + + RefPtr<nsStringInputStream> stream = new nsStringInputStream(); + + stream->SetData(aStringToRead); + + stream.forget(aStreamResult); + return NS_OK; +} + +// factory method for constructing a nsStringInputStream object +nsresult +nsStringInputStreamConstructor(nsISupports* aOuter, REFNSIID aIID, + void** aResult) +{ + *aResult = nullptr; + + if (NS_WARN_IF(aOuter)) { + return NS_ERROR_NO_AGGREGATION; + } + + RefPtr<nsStringInputStream> inst = new nsStringInputStream(); + return inst->QueryInterface(aIID, aResult); +} |