AK: Remove Buffer<T> since it was only ever instantiated with T=byte.

Instead make a specialized AK::ByteBufferImpl class for the backing store
of AK::ByteBuffer. This reduces template bloat.

AK/Buffer.h

@@ -1,143 +0,0 @@
-#pragma once
-
-#include "Assertions.h"
-#include "Retainable.h"
-#include "RetainPtr.h"
-#include "StdLibExtras.h"
-#include "kmalloc.h"
-
-namespace AK {
-
-template<typename T>
-class Buffer : public Retainable<Buffer<T>> {
-public:
-    static Retained<Buffer> create_uninitialized(ssize_t count);
-    static Retained<Buffer> create_zeroed(ssize_t count);
-    static Retained<Buffer> copy(const T*, ssize_t count);
-    static Retained<Buffer> wrap(T*, ssize_t count);
-    static Retained<Buffer> adopt(T*, ssize_t count);
-
-    ~Buffer() { clear(); }
-
-    void clear()
-    {
-        if (!m_elements)
-            return;
-        if (m_owned)
-            kfree(m_elements);
-        m_elements = nullptr;
-    }
-
-    T& operator[](ssize_t i) { ASSERT(i < m_size); return m_elements[i]; }
-    const T& operator[](ssize_t i) const { ASSERT(i < m_size); return m_elements[i]; }
-    bool is_empty() const { return !m_size; }
-    ssize_t size() const { return m_size; }
-
-    T* pointer() { return m_elements; }
-    const T* pointer() const { return m_elements; }
-
-    T* offset_pointer(ssize_t offset) { return m_elements + offset; }
-    const T* offset_pointer(ssize_t offset) const { return m_elements + offset; }
-
-    const void* end_pointer() const { return m_elements + m_size; }
-
-    // NOTE: trim() does not reallocate.
-    void trim(ssize_t size)
-    {
-        ASSERT(size <= m_size);
-        m_size = size;
-    }
-
-    void grow(ssize_t size);
-
-private:
-    enum ConstructionMode { Uninitialized, Copy, Wrap, Adopt };
-    explicit Buffer(ssize_t); // For ConstructionMode=Uninitialized
-    Buffer(const T*, ssize_t, ConstructionMode); // For ConstructionMode=Copy
-    Buffer(T*, ssize_t, ConstructionMode); // For ConstructionMode=Wrap/Adopt
-    Buffer() { }
-
-    T* m_elements { nullptr };
-    ssize_t m_size { 0 };
-    bool m_owned { false };
-};
-
-template<typename T>
-inline Buffer<T>::Buffer(ssize_t size)
-    : m_size(size)
-{
-    m_elements = static_cast<T*>(kmalloc(size * sizeof(T)));
-    m_owned = true;
-}
-
-template<typename T>
-inline Buffer<T>::Buffer(const T* elements, ssize_t size, ConstructionMode mode)
-    : m_size(size)
-{
-    ASSERT(mode == Copy);
-    m_elements = static_cast<T*>(kmalloc(size * sizeof(T)));
-    memcpy(m_elements, elements, size * sizeof(T));
-    m_owned = true;
-}
-
-template<typename T>
-inline Buffer<T>::Buffer(T* elements, ssize_t size, ConstructionMode mode)
-    : m_elements(elements)
-    , m_size(size)
-{
-    if (mode == Adopt) {
-        m_owned = true;
-    } else if (mode == Wrap) {
-        m_owned = false;
-    }
-}
-
-template<typename T>
-inline void Buffer<T>::grow(ssize_t size)
-{
-    ASSERT(size > m_size);
-    ASSERT(m_owned);
-    T* new_elements = static_cast<T*>(kmalloc(size * sizeof(T)));
-    memcpy(new_elements, m_elements, m_size * sizeof(T));
-    T* old_elements = m_elements;
-    m_elements = new_elements;
-    m_size = size;
-    kfree(old_elements);
-}
-
-template<typename T>
-inline Retained<Buffer<T>> Buffer<T>::create_uninitialized(ssize_t size)
-{
-    return ::adopt(*new Buffer<T>(size));
-}
-
-template<typename T>
-inline Retained<Buffer<T>> Buffer<T>::create_zeroed(ssize_t size)
-{
-    auto buffer = ::adopt(*new Buffer<T>(size));
-    memset(buffer->pointer(), 0, size);
-    return buffer;
-}
-
-template<typename T>
-inline Retained<Buffer<T>> Buffer<T>::copy(const T* elements, ssize_t size)
-{
-    return ::adopt(*new Buffer<T>(elements, size, Copy));
-}
-
-template<typename T>
-inline Retained<Buffer<T>> Buffer<T>::wrap(T* elements, ssize_t size)
-{
-    return ::adopt(*new Buffer<T>(elements, size, Wrap));
-}
-
-template<typename T>
-inline Retained<Buffer<T>> Buffer<T>::adopt(T* elements, ssize_t size)
-{
-    return ::adopt(*new Buffer<T>(elements, size, Adopt));
-}
-
-}
-
-using AK::Buffer;
-

AK/ByteBuffer.h

@@ -1,11 +1,66 @@
 #pragma once
 
-#include "Buffer.h"
 #include "Types.h"
 #include "StdLibExtras.h"
+#include <AK/Retainable.h>
+#include <AK/RetainPtr.h>
+#include <AK/kmalloc.h>
 
 namespace AK {
 
+class ByteBufferImpl : public Retainable<ByteBufferImpl> {
+public:
+    static Retained<ByteBufferImpl> create_uninitialized(int size);
+    static Retained<ByteBufferImpl> create_zeroed(int);
+    static Retained<ByteBufferImpl> copy(const void*, int);
+    static Retained<ByteBufferImpl> wrap(void*, int);
+    static Retained<ByteBufferImpl> adopt(void*, int);
+
+    ~ByteBufferImpl() { clear(); }
+
+    void clear()
+    {
+        if (!m_data)
+            return;
+        if (m_owned)
+            kfree(m_data);
+        m_data = nullptr;
+    }
+
+    byte& operator[](int i) { ASSERT(i < m_size); return m_data[i]; }
+    const byte& operator[](int i) const { ASSERT(i < m_size); return m_data[i]; }
+    bool is_empty() const { return !m_size; }
+    int size() const { return m_size; }
+
+    byte* pointer() { return m_data; }
+    const byte* pointer() const { return m_data; }
+
+    byte* offset_pointer(int offset) { return m_data + offset; }
+    const byte* offset_pointer(int offset) const { return m_data + offset; }
+
+    const void* end_pointer() const { return m_data + m_size; }
+
+    // NOTE: trim() does not reallocate.
+    void trim(int size)
+    {
+        ASSERT(size <= m_size);
+        m_size = size;
+    }
+
+    void grow(int size);
+
+private:
+    enum ConstructionMode { Uninitialized, Copy, Wrap, Adopt };
+    explicit ByteBufferImpl(int); // For ConstructionMode=Uninitialized
+    ByteBufferImpl(const void*, int, ConstructionMode); // For ConstructionMode=Copy
+    ByteBufferImpl(void*, int, ConstructionMode); // For ConstructionMode=Wrap/Adopt
+    ByteBufferImpl() { }
+
+    byte* m_data { nullptr };
+    int m_size { 0 };
+    bool m_owned { false };
+};
+
 class ByteBuffer {
 public:
     ByteBuffer() { }
@@ -30,11 +85,11 @@ public:
         return *this;
     }
 
-    static ByteBuffer create_uninitialized(ssize_t size) { return ByteBuffer(Buffer<byte>::create_uninitialized(size)); }
-    static ByteBuffer create_zeroed(ssize_t size) { return ByteBuffer(Buffer<byte>::create_zeroed(size)); }
-    static ByteBuffer copy(const byte* data, ssize_t size) { return ByteBuffer(Buffer<byte>::copy(data, size)); }
-    static ByteBuffer wrap(byte* data, ssize_t size) { return ByteBuffer(Buffer<byte>::wrap(data, size)); }
-    static ByteBuffer adopt(byte* data, ssize_t size) { return ByteBuffer(Buffer<byte>::adopt(data, size)); }
+    static ByteBuffer create_uninitialized(ssize_t size) { return ByteBuffer(ByteBufferImpl::create_uninitialized(size)); }
+    static ByteBuffer create_zeroed(ssize_t size) { return ByteBuffer(ByteBufferImpl::create_zeroed(size)); }
+    static ByteBuffer copy(const byte* data, ssize_t size) { return ByteBuffer(ByteBufferImpl::copy(data, size)); }
+    static ByteBuffer wrap(byte* data, ssize_t size) { return ByteBuffer(ByteBufferImpl::wrap(data, size)); }
+    static ByteBuffer adopt(byte* data, ssize_t size) { return ByteBuffer(ByteBufferImpl::adopt(data, size)); }
 
     ~ByteBuffer() { clear(); }
     void clear() { m_impl = nullptr; }
@@ -77,20 +132,86 @@ public:
     void grow(ssize_t size)
     {
         if (!m_impl)
-            m_impl = Buffer<byte>::create_uninitialized(size);
+            m_impl = ByteBufferImpl::create_uninitialized(size);
         else
             m_impl->grow(size);
     }
 
 private:
-    explicit ByteBuffer(RetainPtr<Buffer<byte>>&& impl)
+    explicit ByteBuffer(RetainPtr<ByteBufferImpl>&& impl)
         : m_impl(move(impl))
     {
     }
 
-    RetainPtr<Buffer<byte>> m_impl;
+    RetainPtr<ByteBufferImpl> m_impl;
 };
 
+inline ByteBufferImpl::ByteBufferImpl(int size)
+    : m_size(size)
+{
+    m_data = static_cast<byte*>(kmalloc(size));
+    m_owned = true;
+}
+
+inline ByteBufferImpl::ByteBufferImpl(const void* data, int size, ConstructionMode mode)
+    : m_size(size)
+{
+    ASSERT(mode == Copy);
+    m_data = static_cast<byte*>(kmalloc(size));
+    memcpy(m_data, data, size);
+    m_owned = true;
+}
+
+inline ByteBufferImpl::ByteBufferImpl(void* data, ssize_t size, ConstructionMode mode)
+    : m_data(static_cast<byte*>(data))
+    , m_size(size)
+{
+    if (mode == Adopt) {
+        m_owned = true;
+    } else if (mode == Wrap) {
+        m_owned = false;
+    }
+}
+
+inline void ByteBufferImpl::grow(ssize_t size)
+{
+    ASSERT(size > m_size);
+    ASSERT(m_owned);
+    byte* new_data = static_cast<byte*>(kmalloc(size));
+    memcpy(new_data, m_data, m_size);
+    byte* old_data = m_data;
+    m_data = new_data;
+    m_size = size;
+    kfree(old_data);
+}
+
+inline Retained<ByteBufferImpl> ByteBufferImpl::create_uninitialized(int size)
+{
+    return ::adopt(*new ByteBufferImpl(size));
+}
+
+inline Retained<ByteBufferImpl> ByteBufferImpl::create_zeroed(int size)
+{
+    auto buffer = ::adopt(*new ByteBufferImpl(size));
+    memset(buffer->pointer(), 0, size);
+    return buffer;
+}
+
+inline Retained<ByteBufferImpl> ByteBufferImpl::copy(const void* data, int size)
+{
+    return ::adopt(*new ByteBufferImpl(data, size, Copy));
+}
+
+inline Retained<ByteBufferImpl> ByteBufferImpl::wrap(void* data, int size)
+{
+    return ::adopt(*new ByteBufferImpl(data, size, Wrap));
+}
+
+inline Retained<ByteBufferImpl> ByteBufferImpl::adopt(void* data, int size)
+{
+    return ::adopt(*new ByteBufferImpl(data, size, Adopt));
+}
+
 }
 
 using AK::ByteBuffer;

Kernel/Ext2FileSystem.h

@@ -2,7 +2,6 @@
 
 #include "DiskBackedFileSystem.h"
 #include "UnixTypes.h"
-#include <AK/Buffer.h>
 #include <AK/OwnPtr.h>
 #include "ext2_fs.h"