class InStreamPeeker

in_stream_to_wrap - the underlying source of data, typically not capable

of peeking, to wrap such that peeking is possible.

max_peek_bytes - the maximum peek distance in bytes. Some usages will need

a peek distance that's as large as an AU, such as when searching for

pattern-based start codes. Others may not need much peek distance at

all, such as when headers at the start of each AU indicate the length

of the AU.

This InStreamPeeker takes ownership of in_stream_to_wrap and does not

provide any direct access to in_stream_to_wrap, since the read-ahead

performed by this instance would only confuse any direct use of

in_stream_to_wrap.

The in_stream_to_wrap is only called during ReadBytes() or PeekBytes(),

using the same thread as those calls are made on.

The first three parameters to this constructor are for consistency in

threading across all InStream types. We want the InStream base class to

be able to assert that methods are being called on the correct thread, etc.

Unlike ReadBytes, PeekBytes() does not advance cursor_position().

Unlike ReadBytes, PeekBytes() provides a memory address at which the caller

can observe peeked data. The *peek_buffer_out pointer remains valid to

read up to *peek_bytes_out from until the next call to any non-const method

or destructor of this instance.

If the timeout is exceeded, ZX_ERR_TIMED_OUT is returned, and

*peek_buffer_out is set to nullptr.

The *peek_bytes_out may be less than desired_bytes_to_peek only if the end

of input data is reached and has offset

<

cursor_position() +

desired_bytes_to_peek.

Discard previously-peeked and not-yet-read/not-yet-tossed bytes.

This will assert in debug that bytes_to_toss is consistent with having

previously been peeked, but /may/ not catch all cases where this is called

incorrectly without a previous peek of all these bytes.

The caller must only call this for bytes which were previously peeked.