blob: 03e71d637b4ded3d2833f0ab055616c99dd55326 [file] [log] [blame]
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <memory>
#include <utility>
#include <vector>
#include "base/containers/circular_deque.h"
#include "base/macros.h"
#include "base/memory/scoped_refptr.h"
#include "net/base/net_export.h"
#include "starboard/types.h"
extern "C" struct z_stream_s;
namespace net {
class IOBufferWithSize;
// WebSocketInflater uncompresses data compressed by DEFLATE algorithm.
class NET_EXPORT_PRIVATE WebSocketInflater {
// |input_queue_capacity| is a capacity for each contiguous block in the
// input queue. The input queue can grow without limit.
WebSocketInflater(size_t input_queue_capacity, size_t output_buffer_capacity);
// Returns true if there is no error.
// |window_bits| must be between 8 and 15 (both inclusive).
// This function must be called exactly once before calling any of the
// following functions.
bool Initialize(int window_bits);
// Adds bytes to |stream_|.
// Returns true if there is no error.
// If the size of the output data reaches the capacity of the output buffer,
// the following input data will be "choked", i.e. stored in the input queue,
// staying compressed.
bool AddBytes(const char* data, size_t size);
// Flushes the input.
// Returns true if there is no error.
bool Finish();
// Returns up to |size| bytes of the decompressed output.
// Returns null if there is an inflation error.
// The returned bytes will be dropped from the current output and never be
// returned again.
// If some input data is choked, calling this function may restart the
// inflation process.
// This means that even if you call |Finish()| and call |GetOutput()| with
// size = |CurrentOutputSize()|, the inflater may have some remaining data.
// To confirm the inflater emptiness, you should check whether
// |CurrentOutputSize()| is zero.
scoped_refptr<IOBufferWithSize> GetOutput(size_t size);
// Returns the size of the current inflated output.
size_t CurrentOutputSize() const { return output_buffer_.Size(); }
static const size_t kDefaultBufferCapacity = 512;
static const size_t kDefaultInputIOBufferCapacity = 512;
// Ring buffer with fixed capacity.
class NET_EXPORT_PRIVATE OutputBuffer {
explicit OutputBuffer(size_t capacity);
size_t Size() const;
// Returns (tail pointer, availabe size).
// A user can push data to the queue by writing the data to
// the area returned by this function and calling AdvanceTail.
std::pair<char*, size_t> GetTail();
void Read(char* dest, size_t size);
void AdvanceTail(size_t advance);
void AdvanceHead(size_t advance);
const size_t capacity_;
std::vector<char> buffer_;
size_t head_;
size_t tail_;
class InputQueue {
// |capacity| is used for the capacity of each IOBuffer in this queue.
// this queue itself can grow without limit.
explicit InputQueue(size_t capacity);
// Returns (data pointer, size), the first component of unconsumed data.
// The type of data pointer is non-const because |inflate| function
// requires so.
std::pair<char*, size_t> Top();
bool IsEmpty() const { return buffers_.empty(); }
void Push(const char* data, size_t size);
// Consumes the topmost |size| bytes.
// |size| must be less than or equal to the first buffer size.
void Consume(size_t size);
size_t PushToLastBuffer(const char* data, size_t size);
const size_t capacity_;
size_t head_of_first_buffer_;
size_t tail_of_last_buffer_;
base::circular_deque<scoped_refptr<IOBufferWithSize>> buffers_;
int InflateWithFlush(const char* next_in, size_t avail_in);
int Inflate(const char* next_in, size_t avail_in, int flush);
int InflateChokedInput();
std::unique_ptr<z_stream_s> stream_;
InputQueue input_queue_;
OutputBuffer output_buffer_;
} // namespace net