Use uint64_t instead of size_t in QuicIntervalDeque Given that we use QuicStreamOffset and QuicByteCount elsewhere, which are both uint64_t, using a potentially 32-bit value in the interval deque would generally not work for large values and lead to issues on 32-bit platforms (we do build on 32-bit Android). No-op on 64-bit platforms. Fixes Android 32-bit in Chrome that started failing after we enabled inlining send buffer: https://ci.chromium.org/ui/p/chromium/builders/try/android-x86-rel/766883/overview PiperOrigin-RevId: 793634540
diff --git a/quiche/quic/core/quic_interval_deque.h b/quiche/quic/core/quic_interval_deque.h index f4de048..9324b06 100644 --- a/quiche/quic/core/quic_interval_deque.h +++ b/quiche/quic/core/quic_interval_deque.h
@@ -64,8 +64,8 @@ // // An example class to be stored inside the Interval Deque. // struct IntervalVal { // const int32_t val; -// const size_t interval_begin, interval_end; -// QuicInterval<size_t> interval(); +// const uint64_t interval_begin, interval_end; +// QuicInterval<uint64_t> interval(); // }; // typedef IntervalVal IV; // QuicIntervialDeque<IntervalValue> deque; @@ -155,13 +155,13 @@ // at |deque_.size()| and any attempt to increment above that will be // ignored. Once an iterator has iterated all elements the |cached_index_| // will be reset. - Iterator(std::size_t index, QuicIntervalDeque* deque) + Iterator(uint64_t index, QuicIntervalDeque* deque) : index_(index), deque_(deque) {} // Only the ++ operator attempts to update the cached index. Other operators // are used by |lower_bound| to binary search. Iterator& operator++() { // Don't increment when we are at the end. - const std::size_t container_size = deque_->container_.size(); + const uint64_t container_size = deque_->container_.size(); if (index_ >= container_size) { QUIC_BUG(QuicIntervalDeque_operator_plus_plus_iterator_out_of_bounds) << "Iterator out of bounds."; @@ -169,7 +169,7 @@ } index_++; if (deque_->cached_index_.has_value()) { - const std::size_t cached_index = *deque_->cached_index_; + const uint64_t cached_index = *deque_->cached_index_; // If all items are iterated then reset the |cached_index_| if (index_ == container_size) { deque_->cached_index_.reset(); @@ -223,7 +223,7 @@ private: // |index_| is the index of the item in |*deque_|. - std::size_t index_; + uint64_t index_; // |deque_| is a pointer to the container the iterator came from. QuicIntervalDeque* deque_; @@ -246,16 +246,16 @@ Iterator DataEnd(); // Returns an iterator pointing to the item in |interval_begin|. The iterator // will move the |cached_index_| as the iterator moves. - Iterator DataAt(const std::size_t interval_begin); + Iterator DataAt(const uint64_t interval_begin); // Returns the number of items contained inside the structure. - std::size_t Size() const; + uint64_t Size() const; // Returns whether the structure is empty. bool Empty() const; private: struct QUICHE_NO_EXPORT IntervalCompare { - bool operator()(const T& item, std::size_t interval_begin) const { + bool operator()(const T& item, uint64_t interval_begin) const { return item.interval().max() <= interval_begin; } }; @@ -263,14 +263,14 @@ template <class U> void PushBackUniversal(U&& item); - Iterator Search(const std::size_t interval_begin, - const std::size_t begin_index, const std::size_t end_index); + Iterator Search(const uint64_t interval_begin, const uint64_t begin_index, + const uint64_t end_index); // For accessing the |cached_index_| friend class test::QuicIntervalDequePeer; C container_; - std::optional<std::size_t> cached_index_; + std::optional<uint64_t> cached_index_; }; template <class T, class C> @@ -315,16 +315,16 @@ template <class T, class C> typename QuicIntervalDeque<T, C>::Iterator QuicIntervalDeque<T, C>::DataAt( - const std::size_t interval_begin) { + const uint64_t interval_begin) { // No |cached_index_| value means all items can be searched. if (!cached_index_.has_value()) { return Search(interval_begin, 0, container_.size()); } - const std::size_t cached_index = *cached_index_; + const uint64_t cached_index = *cached_index_; QUICHE_DCHECK(cached_index < container_.size()); - const QuicInterval<size_t> cached_interval = + const QuicInterval<uint64_t> cached_interval = container_[cached_index].interval(); // Does our cached index point directly to what we want? if (cached_interval.Contains(interval_begin)) { @@ -332,7 +332,7 @@ } // Are we off-by-one? - const std::size_t next_index = cached_index + 1; + const uint64_t next_index = cached_index + 1; if (next_index < container_.size()) { if (container_[next_index].interval().Contains(interval_begin)) { cached_index_ = next_index; @@ -342,10 +342,10 @@ // Small optimization: // Determine if we should binary search above or below the cached interval. - const std::size_t cached_begin = cached_interval.min(); + const uint64_t cached_begin = cached_interval.min(); bool looking_below = interval_begin < cached_begin; - const std::size_t lower = looking_below ? 0 : cached_index + 1; - const std::size_t upper = looking_below ? cached_index : container_.size(); + const uint64_t lower = looking_below ? 0 : cached_index + 1; + const uint64_t upper = looking_below ? cached_index : container_.size(); Iterator ret = Search(interval_begin, lower, upper); if (ret == DataEnd()) { return ret; @@ -358,7 +358,7 @@ } template <class T, class C> -std::size_t QuicIntervalDeque<T, C>::Size() const { +uint64_t QuicIntervalDeque<T, C>::Size() const { return container_.size(); } @@ -370,7 +370,7 @@ template <class T, class C> template <class U> void QuicIntervalDeque<T, C>::PushBackUniversal(U&& item) { - QuicInterval<std::size_t> interval = item.interval(); + QuicInterval<uint64_t> interval = item.interval(); // Adding an empty interval is a bug. if (interval.Empty()) { QUIC_BUG(QuicIntervalDeque_PushBackUniversal_empty) @@ -385,8 +385,8 @@ template <class T, class C> typename QuicIntervalDeque<T, C>::Iterator QuicIntervalDeque<T, C>::Search( - const std::size_t interval_begin, const std::size_t begin_index, - const std::size_t end_index) { + const uint64_t interval_begin, const uint64_t begin_index, + const uint64_t end_index) { auto begin = container_.begin() + begin_index; auto end = container_.begin() + end_index; auto res = std::lower_bound(begin, end, interval_begin, IntervalCompare());
diff --git a/quiche/quic/core/quic_stream_send_buffer.cc b/quiche/quic/core/quic_stream_send_buffer.cc index ad78782..a1b9779 100644 --- a/quiche/quic/core/quic_stream_send_buffer.cc +++ b/quiche/quic/core/quic_stream_send_buffer.cc
@@ -44,9 +44,9 @@ BufferedSlice::~BufferedSlice() {} -QuicInterval<std::size_t> BufferedSlice::interval() const { - const std::size_t length = slice.length(); - return QuicInterval<std::size_t>(offset, offset + length); +QuicInterval<uint64_t> BufferedSlice::interval() const { + const uint64_t length = slice.length(); + return QuicInterval<uint64_t>(offset, offset + length); } QuicStreamSendBuffer::QuicStreamSendBuffer(
diff --git a/quiche/quic/core/quic_stream_send_buffer.h b/quiche/quic/core/quic_stream_send_buffer.h index d9b25c3..85caec6 100644 --- a/quiche/quic/core/quic_stream_send_buffer.h +++ b/quiche/quic/core/quic_stream_send_buffer.h
@@ -40,7 +40,7 @@ ~BufferedSlice(); // Return an interval representing the offset and length. - QuicInterval<std::size_t> interval() const; + QuicInterval<uint64_t> interval() const; // Stream data of this data slice. quiche::QuicheMemSlice slice;
diff --git a/quiche/quic/core/quic_stream_send_buffer_inlining.cc b/quiche/quic/core/quic_stream_send_buffer_inlining.cc index bd4924e..0889dd2 100644 --- a/quiche/quic/core/quic_stream_send_buffer_inlining.cc +++ b/quiche/quic/core/quic_stream_send_buffer_inlining.cc
@@ -51,9 +51,9 @@ BufferedSliceInlining::~BufferedSliceInlining() {} -QuicInterval<std::size_t> BufferedSliceInlining::interval() const { - const std::size_t length = slice.size(); - return QuicInterval<std::size_t>(offset, offset + length); +QuicInterval<uint64_t> BufferedSliceInlining::interval() const { + const uint64_t length = slice.size(); + return QuicInterval<uint64_t>(offset, offset + length); } QuicStreamSendBufferInlining::QuicStreamSendBufferInlining(
diff --git a/quiche/quic/core/quic_stream_send_buffer_inlining.h b/quiche/quic/core/quic_stream_send_buffer_inlining.h index 6cb0f95..c3a61e9 100644 --- a/quiche/quic/core/quic_stream_send_buffer_inlining.h +++ b/quiche/quic/core/quic_stream_send_buffer_inlining.h
@@ -46,7 +46,7 @@ ~BufferedSliceInlining(); // Return an interval representing the offset and length. - QuicInterval<std::size_t> interval() const; + QuicInterval<uint64_t> interval() const; // Stream data of this data slice. QuicInlinedStringView<kSendBufferMaxInlinedSize + 1> slice;