Make ChainedByteRange a private subclass of ChainedByteRangeHead

Summary: We never instantiate a `ChainedByteRange` outside of the `ChainedByteRangeHead`, so I'm making it a private subclass.

Reviewed By: hanidamlaj

Differential Revision: D59402909

fbshipit-source-id: a819f3de5dcc68b370c46aa4e5fe3357f17b798f

Author: Aman Sharma

quic/common/BufUtil.cpp

@@ -175,7 +175,7 @@ void BufWriter::insert(const ChainedByteRangeHead* data) {
 }
 
 void BufWriter::insert(const ChainedByteRangeHead* data, size_t limit) {
-  copy(data->getHead(), limit);
+  copy(data, limit);
 }
 
 void BufWriter::append(size_t len) {
@@ -205,13 +205,13 @@ void BufWriter::copy(const folly::IOBuf* data, size_t limit) {
   CHECK_GE(limit, totalInserted);
 }
 
-void BufWriter::copy(const ChainedByteRange* data, size_t limit) {
+void BufWriter::copy(const ChainedByteRangeHead* data, size_t limit) {
   if (!limit) {
     return;
   }
   sizeCheck(limit);
   size_t totalInserted = 0;
-  const ChainedByteRange* curBuf = data;
+  const auto* curBuf = data->getHead();
   auto remaining = limit;
   do {
     auto lenToCopy = std::min(curBuf->length(), remaining);

quic/common/BufUtil.h

@@ -140,7 +140,7 @@ class BufWriter {
   }
 
   void copy(const folly::IOBuf* data, size_t limit);
-  void copy(const ChainedByteRange* data, size_t limit);
+  void copy(const ChainedByteRangeHead* data, size_t limit);
 
  private:
   folly::IOBuf& iobuf_;

quic/common/ChainedByteRange.h

@@ -11,48 +11,6 @@
 
 namespace quic {
 
-/*
- * The ChainedByteRange depicts one block of contiguous
- * memory, and has a next_ pointer. It has APIs
- * that can be used to trim the start or end of this specific
- * contiguous memory block.
- */
-class ChainedByteRange {
- public:
-  ChainedByteRange() : next_(nullptr) {}
-
-  explicit ChainedByteRange(folly::ByteRange range)
-      : range_(range), next_(nullptr) {}
-
-  /**
-   * Returns the length only of this ChainedByteRange
-   */
-  [[nodiscard]] size_t length() const {
-    return range_.size();
-  }
-
-  /**
-   * Trim the start of this specific contiguous memory block
-   */
-  void trimStart(size_t n) {
-    n = std::min(n, range_.size());
-    range_.advance(n);
-  }
-
-  [[nodiscard]] folly::ByteRange getRange() const {
-    return range_;
-  }
-
-  [[nodiscard]] ChainedByteRange* getNext() const {
-    return next_;
-  }
-
- private:
-  folly::ByteRange range_;
-  ChainedByteRange* next_{nullptr};
-  friend class ChainedByteRangeHead;
-};
-
 /*
  * The ChainedByteRangeHead depicts the head of a chain of ChainedByteRanges.
  * It caches the length of the total chain, which is useful in many cases
@@ -61,6 +19,48 @@ class ChainedByteRange {
  * with the splitAtMost and trimStartAtMost APIs.
  */
 class ChainedByteRangeHead {
+ private:
+  /*
+   * The ChainedByteRange depicts one block of contiguous
+   * memory, and has a next_ pointer. It has APIs
+   * that can be used to trim the start or end of this specific
+   * contiguous memory block.
+   */
+  class ChainedByteRange {
+   public:
+    ChainedByteRange() = default;
+
+    explicit ChainedByteRange(folly::ByteRange range) : range_(range) {}
+
+    /**
+     * Returns the length only of this ChainedByteRange
+     */
+    [[nodiscard]] size_t length() const {
+      return range_.size();
+    }
+
+    /**
+     * Trim the start of this specific contiguous memory block
+     */
+    void trimStart(size_t n) {
+      n = std::min(n, range_.size());
+      range_.advance(n);
+    }
+
+    [[nodiscard]] folly::ByteRange getRange() const {
+      return range_;
+    }
+
+    [[nodiscard]] ChainedByteRange* getNext() const {
+      return next_;
+    }
+
+   private:
+    folly::ByteRange range_;
+    ChainedByteRange* next_{nullptr};
+    friend class ChainedByteRangeHead;
+  };
+
  public:
   explicit ChainedByteRangeHead(const Buf& buf);
 

quic/common/test/ChainedByteRangeTest.cpp

@@ -225,13 +225,6 @@ TEST(ChainedByteRangeHead, FromIobufEmpty) {
   EXPECT_TRUE(chainedByteRangeHead.empty());
 }
 
-TEST(ChainedByteRangeHead, TrimStart) {
-  auto cbr = std::make_unique<ChainedByteRange>(
-      folly::ByteRange(kHello->data(), kHello->length()));
-  cbr->trimStart(3);
-  EXPECT_EQ(cbr->getRange().toString(), "lo");
-}
-
 TEST(ChainedByteRangeHead, SplitHeadFromChainOfOne) {
   ChainedByteRangeHead queue;
   queue.append(kHello);