mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
91 lines
3.3 KiB
C++
91 lines
3.3 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/. */
|
|
|
|
#ifndef mozilla_SnappyUncompressInputStream_h__
|
|
#define mozilla_SnappyUncompressInputStream_h__
|
|
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/UniquePtr.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsIInputStream.h"
|
|
#include "nsISupportsImpl.h"
|
|
#include "SnappyFrameUtils.h"
|
|
|
|
namespace mozilla {
|
|
|
|
class SnappyUncompressInputStream MOZ_FINAL : public nsIInputStream
|
|
, protected detail::SnappyFrameUtils
|
|
{
|
|
public:
|
|
// Construct a new blocking stream to uncompress the given base stream. The
|
|
// base stream must also be blocking. The base stream does not have to be
|
|
// buffered.
|
|
explicit SnappyUncompressInputStream(nsIInputStream* aBaseStream);
|
|
|
|
private:
|
|
virtual ~SnappyUncompressInputStream();
|
|
|
|
// Parse the next chunk of data. This may populate mBuffer and set
|
|
// mBufferFillSize. This should not be called when mBuffer already
|
|
// contains data.
|
|
nsresult ParseNextChunk(uint32_t* aBytesReadOut);
|
|
|
|
// Convenience routine to Read() from the base stream until we get
|
|
// the given number of bytes or reach EOF.
|
|
//
|
|
// aBuf - The buffer to write the bytes into.
|
|
// aCount - Max number of bytes to read. If the stream closes
|
|
// fewer bytes my be read.
|
|
// aMinValidCount - A minimum expected number of bytes. If we find
|
|
// fewer than this many bytes, then return
|
|
// NS_ERROR_CORRUPTED_CONTENT. If nothing was read due
|
|
// due to EOF (aBytesReadOut == 0), then NS_OK is returned.
|
|
// aBytesReadOut - An out parameter indicating how many bytes were read.
|
|
nsresult ReadAll(char* aBuf, uint32_t aCount, uint32_t aMinValidCount,
|
|
uint32_t* aBytesReadOut);
|
|
|
|
// Convenience routine to determine how many bytes of uncompressed data
|
|
// we currently have in our buffer.
|
|
size_t UncompressedLength() const;
|
|
|
|
nsCOMPtr<nsIInputStream> mBaseStream;
|
|
|
|
// Buffer to hold compressed data. Must copy here since we need a large
|
|
// flat buffer to run the uncompress process on. Always the same length
|
|
// of SnappyFrameUtils::MaxCompressedBufferLength(snappy::kBlockSize)
|
|
// bytes long.
|
|
mozilla::UniquePtr<char[]> mCompressedBuffer;
|
|
|
|
// Buffer storing the resulting uncompressed data. Exactly snappy::kBlockSize
|
|
// bytes long.
|
|
mozilla::UniquePtr<char[]> mUncompressedBuffer;
|
|
|
|
// Number of bytes of uncompressed data in mBuffer.
|
|
size_t mUncompressedBytes;
|
|
|
|
// Next byte of mBuffer to return in ReadSegments(). Must be less than
|
|
// mBufferFillSize
|
|
size_t mNextByte;
|
|
|
|
// Next chunk in the stream that has been parsed during read-ahead.
|
|
ChunkType mNextChunkType;
|
|
|
|
// Length of next chunk's length that has been determined during read-ahead.
|
|
size_t mNextChunkDataLength;
|
|
|
|
// The stream must begin with a StreamIdentifier chunk. Are we still
|
|
// expecting it?
|
|
bool mNeedFirstStreamIdentifier;
|
|
|
|
public:
|
|
NS_DECL_THREADSAFE_ISUPPORTS
|
|
NS_DECL_NSIINPUTSTREAM
|
|
};
|
|
|
|
} // namespace mozilla
|
|
|
|
#endif // mozilla_SnappyUncompressInputStream_h__
|