AK: Remove `DuplexMemoryStream`

2 files changed, 0 insertions, 135 deletions

diff --git a/AK/Forward.h b/AK/Forward.h
index 0476716000..81a2a09f18 100644
--- a/AK/Forward.h
+++ b/AK/Forward.h
@@ -42,7 +42,6 @@ class Utf8CodePointIterator;
 class Utf8View;
 class InputStream;
 class InputMemoryStream;
-class DuplexMemoryStream;
 class OutputStream;
 class InputBitStream;
 class OutputBitStream;
@@ -160,7 +159,6 @@ using AK::CircularQueue;
 using AK::DeprecatedFlyString;
 using AK::DeprecatedString;
 using AK::DoublyLinkedList;
-using AK::DuplexMemoryStream;
 using AK::Error;
 using AK::ErrorOr;
 using AK::FixedArray;
diff --git a/AK/MemoryStream.h b/AK/MemoryStream.h
index 0bada40b8e..93a3c17566 100644
--- a/AK/MemoryStream.h
+++ b/AK/MemoryStream.h
@@ -138,142 +138,9 @@ private:
     Bytes m_bytes;
 };
 
-class DuplexMemoryStream final : public DuplexStream {
-public:
-    static constexpr size_t chunk_size = 4 * 1024;
-
-    bool unreliable_eof() const override { return eof(); }
-    bool eof() const { return m_write_offset == m_read_offset; }
-
-    bool discard_or_error(size_t count) override
-    {
-        if (m_write_offset - m_read_offset < count) {
-            set_recoverable_error();
-            return false;
-        }
-
-        m_read_offset += count;
-        try_discard_chunks();
-        return true;
-    }
-
-    Optional<size_t> offset_of(ReadonlyBytes value) const
-    {
-        // We can't directly pass m_chunks to memmem since we have a limited read/write range we want to search in.
-        Vector<ReadonlyBytes> spans;
-        auto chunk_index = (m_read_offset - m_base_offset) / chunk_size;
-        auto chunk_read_offset = (m_read_offset - m_base_offset) % chunk_size;
-        auto bytes_to_search = m_write_offset - m_read_offset;
-        for (; bytes_to_search > 0;) {
-            ReadonlyBytes span = m_chunks[chunk_index];
-            if (chunk_read_offset) {
-                span = span.slice(chunk_read_offset);
-                chunk_read_offset = 0;
-            }
-            if (bytes_to_search < span.size()) {
-                spans.append(span.slice(0, bytes_to_search));
-                break;
-            }
-            bytes_to_search -= span.size();
-            spans.append(move(span));
-            ++chunk_index;
-        }
-
-        return memmem(spans.begin(), spans.end(), value);
-    }
-
-    size_t read_without_consuming(Bytes bytes) const
-    {
-        size_t nread = 0;
-        while (bytes.size() - nread > 0 && m_write_offset - m_read_offset - nread > 0) {
-            auto const chunk_index = (m_read_offset - m_base_offset + nread) / chunk_size;
-            auto const chunk_bytes = m_chunks[chunk_index].bytes().slice((m_read_offset + nread) % chunk_size).trim(m_write_offset - m_read_offset - nread);
-            nread += chunk_bytes.copy_trimmed_to(bytes.slice(nread));
-        }
-
-        return nread;
-    }
-
-    size_t read(Bytes bytes) override
-    {
-        if (has_any_error())
-            return 0;
-
-        auto const nread = read_without_consuming(bytes);
-
-        m_read_offset += nread;
-        try_discard_chunks();
-
-        return nread;
-    }
-
-    bool read_or_error(Bytes bytes) override
-    {
-        if (m_write_offset - m_read_offset < bytes.size()) {
-            set_recoverable_error();
-            return false;
-        }
-
-        return read(bytes) == bytes.size();
-    }
-
-    size_t write(ReadonlyBytes bytes) override
-    {
-        // FIXME: This doesn't write around chunk borders correctly?
-
-        size_t nwritten = 0;
-        while (bytes.size() - nwritten > 0) {
-            if ((m_write_offset + nwritten) % chunk_size == 0)
-                m_chunks.append(ByteBuffer::create_uninitialized(chunk_size).release_value_but_fixme_should_propagate_errors()); // FIXME: Handle possible OOM situation.
-
-            nwritten += bytes.slice(nwritten).copy_trimmed_to(m_chunks.last().bytes().slice((m_write_offset + nwritten) % chunk_size));
-        }
-
-        m_write_offset += nwritten;
-        return nwritten;
-    }
-
-    bool write_or_error(ReadonlyBytes bytes) override
-    {
-        write(bytes);
-        return true;
-    }
-
-    ByteBuffer copy_into_contiguous_buffer() const
-    {
-        // FIXME: Handle possible OOM situation.
-        auto buffer = ByteBuffer::create_uninitialized(size()).release_value_but_fixme_should_propagate_errors();
-
-        auto const nread = read_without_consuming(buffer);
-        VERIFY(nread == buffer.size());
-
-        return buffer;
-    }
-
-    size_t roffset() const { return m_read_offset; }
-    size_t woffset() const { return m_write_offset; }
-
-    size_t size() const { return m_write_offset - m_read_offset; }
-
-private:
-    void try_discard_chunks()
-    {
-        while (m_read_offset - m_base_offset >= chunk_size) {
-            m_chunks.take_first();
-            m_base_offset += chunk_size;
-        }
-    }
-
-    Vector<ByteBuffer> m_chunks;
-    size_t m_write_offset { 0 };
-    size_t m_read_offset { 0 };
-    size_t m_base_offset { 0 };
-};
-
 }
 
 #if USING_AK_GLOBALLY
-using AK::DuplexMemoryStream;
 using AK::InputMemoryStream;
 using AK::InputStream;
 using AK::OutputMemoryStream;