Refactor default QuicheMemSliceImpl to not wrap around QuicheBuffer. Since the long-term hope is to make it the only implementation of QuicheMemSlice, it makes sense to make it as simple as possible. Also make QuicheMemSlice take `const char*` instead of `char*`, as some of the wrapped types use refcounted constant buffers. PiperOrigin-RevId: 597037612

diff --git a/quiche/common/platform/api/quiche_mem_slice.h b/quiche/common/platform/api/quiche_mem_slice.h
index c7d9fd7..23accb0 100644
--- a/quiche/common/platform/api/quiche_mem_slice.h
+++ b/quiche/common/platform/api/quiche_mem_slice.h

@@ -5,7 +5,9 @@
 #ifndef QUICHE_COMMON_PLATFORM_API_QUICHE_MEM_SLICE_H_
 #define QUICHE_COMMON_PLATFORM_API_QUICHE_MEM_SLICE_H_
 
+#include <cstddef>
 #include <memory>
+#include <utility>
 
 #include "quiche_platform_impl/quiche_mem_slice_impl.h"
 
@@ -33,7 +35,7 @@
   QuicheMemSlice(std::unique_ptr<char[]> buffer, size_t length)
       : impl_(std::move(buffer), length) {}
 
-  QuicheMemSlice(char buffer[], size_t length,
+  QuicheMemSlice(const char* buffer, size_t length,
                  quiche::SingleUseCallback<void(const char*)> done_callback)
       : impl_(buffer, length, std::move(done_callback)) {}
 

diff --git a/quiche/common/platform/default/quiche_platform_impl/quiche_mem_slice_impl.h b/quiche/common/platform/default/quiche_platform_impl/quiche_mem_slice_impl.h
index 177cc69..d20ebbe 100644
--- a/quiche/common/platform/default/quiche_platform_impl/quiche_mem_slice_impl.h
+++ b/quiche/common/platform/default/quiche_platform_impl/quiche_mem_slice_impl.h

@@ -1,14 +1,14 @@
 #ifndef QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_MEM_SLICE_IMPL_H_
 #define QUICHE_COMMON_PLATFORM_DEFAULT_QUICHE_PLATFORM_IMPL_QUICHE_MEM_SLICE_IMPL_H_
 
+#include <cstddef>
 #include <cstdlib>
-#include <optional>
+#include <memory>
 #include <utility>
 
 #include "quiche/common/platform/api/quiche_export.h"
 #include "quiche/common/quiche_buffer_allocator.h"
 #include "quiche/common/quiche_callbacks.h"
-#include "quiche/common/simple_buffer_allocator.h"
 
 namespace quiche {
 
@@ -17,66 +17,69 @@
   QuicheMemSliceImpl() = default;
 
   explicit QuicheMemSliceImpl(QuicheBuffer buffer)
-      : buffer_(std::move(buffer)) {}
+      : data_(buffer.data()), size_(buffer.size()) {
+    QuicheUniqueBufferPtr owned = buffer.Release();
+    QuicheBufferAllocator* allocator = owned.get_deleter().allocator();
+    owned.release();
+    done_callback_ = [allocator](const char* ptr) {
+      allocator->Delete(const_cast<char*>(ptr));
+    };
+  }
 
   QuicheMemSliceImpl(std::unique_ptr<char[]> buffer, size_t length)
-      : buffer_(
-            QuicheBuffer(QuicheUniqueBufferPtr(
-                             buffer.release(),
-                             QuicheBufferDeleter(SimpleBufferAllocator::Get())),
-                         length)) {}
+      : data_(buffer.release()),
+        size_(length),
+        done_callback_(+[](const char* ptr) { delete[] ptr; }) {}
 
-  QuicheMemSliceImpl(char buffer[], size_t length,
-                     quiche::SingleUseCallback<void(const char*)> done_callback)
-      : allocator_(std::in_place, std::move(done_callback)),
-        buffer_(QuicheBuffer(
-            QuicheUniqueBufferPtr(buffer, QuicheBufferDeleter(&*allocator_)),
-            length)) {}
+  QuicheMemSliceImpl(const char* buffer, size_t length,
+                     SingleUseCallback<void(const char*)> done_callback)
+      : data_(buffer),
+        size_(length),
+        done_callback_(std::move(done_callback)) {}
 
   QuicheMemSliceImpl(const QuicheMemSliceImpl& other) = delete;
   QuicheMemSliceImpl& operator=(const QuicheMemSliceImpl& other) = delete;
 
   // Move constructors. |other| will not hold a reference to the data buffer
   // after this call completes.
-  QuicheMemSliceImpl(QuicheMemSliceImpl&& other) = default;
-  QuicheMemSliceImpl& operator=(QuicheMemSliceImpl&& other) = default;
+  QuicheMemSliceImpl(QuicheMemSliceImpl&& other) {
+    data_ = other.data_;
+    size_ = other.size_;
+    done_callback_ = std::move(other.done_callback_);
+    other.data_ = nullptr;
+    other.size_ = 0;
+    other.done_callback_ = nullptr;
+  }
+  QuicheMemSliceImpl& operator=(QuicheMemSliceImpl&& other) {
+    Reset();
+    data_ = other.data_;
+    size_ = other.size_;
+    done_callback_ = std::move(other.done_callback_);
+    other.data_ = nullptr;
+    other.size_ = 0;
+    other.done_callback_ = nullptr;
+    return *this;
+  }
 
-  ~QuicheMemSliceImpl() = default;
+  ~QuicheMemSliceImpl() { Reset(); }
 
-  void Reset() { buffer_ = QuicheBuffer(); }
+  void Reset() {
+    if (done_callback_ && data_ != nullptr) {
+      std::move(done_callback_)(data_);
+    }
+    data_ = nullptr;
+    size_ = 0;
+    done_callback_ = nullptr;
+  }
 
-  const char* data() const { return buffer_.data(); }
-  size_t length() const { return buffer_.size(); }
-  bool empty() const { return buffer_.empty(); }
+  const char* data() const { return data_; }
+  size_t length() const { return size_; }
+  bool empty() const { return size_ == 0; }
 
  private:
-  // Allocator that is only used for a special `done` callback.
-  class LambdaAllocator : public QuicheBufferAllocator {
-   public:
-    LambdaAllocator(quiche::SingleUseCallback<void(const char*)> done_callback)
-        : done_callback_(std::move(done_callback)) {}
-
-    // Noncompliant. Will cause program termination.
-    char* New(size_t) override {
-      std::exit(-1);
-      return nullptr;
-    }
-    char* New(size_t, bool) override {
-      std::exit(-1);
-      return nullptr;
-    }
-
-    void Delete(char* buffer) override {
-      if (done_callback_ != nullptr) {
-        std::move(done_callback_)(buffer);
-      }
-    }
-
-   private:
-    quiche::SingleUseCallback<void(const char*)> done_callback_;
-  };
-  std::optional<LambdaAllocator> allocator_;
-  QuicheBuffer buffer_;
+  const char* data_;
+  size_t size_;
+  SingleUseCallback<void(const char*)> done_callback_;
 };
 
 }  // namespace quiche