Provide a const version of PacketNumberIndexedQueue<T>::GetEntry().

net/quic/core/packet_number_indexed_queue.h

 // Copyright (c) 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef NET_QUIC_CORE_PACKET_NUMBER_INDEXED_QUEUE_H_
 #define NET_QUIC_CORE_PACKET_NUMBER_INDEXED_QUEUE_H_
 
 #include <deque>
 
 #include "base/logging.h"
@@ skipping 24 matching lines @@
 // as one.
 template <typename T>
 class PacketNumberIndexedQueue {
  public:
   PacketNumberIndexedQueue()
       : number_of_present_entries_(0), first_packet_(0) {}
 
   // Retrieve the entry associated with the packet number.  Returns the pointer
   // to the entry in case of success, or nullptr if the entry does not exist.
   T* GetEntry(QuicPacketNumber packet_number);
+  const T* GetEntry(QuicPacketNumber packet_number) const;
 
   // Inserts data associated |packet_number| into (or past) the end of the
   // queue, filling up the missing intermediate entries as necessary.  Returns
   // true if the element has been inserted successfully, false if it was already
   // in the queue or inserted out of order.
   template <typename... Args>
   bool Emplace(QuicPacketNumber packet_number, Args&&... args);
 
   // Removes data associated with |packet_number| and frees the slots in the
   // queue as necessary.
@@ skipping 32 matching lines @@
     EntryWrapper() : data(), present(false) {}
 
     template <typename... Args>
     explicit EntryWrapper(Args&&... args)
         : data(std::forward<Args>(args)...), present(true) {}
   };
 
   // Cleans up unused slots in the front after removing an element.
   void Cleanup();
 
-  EntryWrapper* GetEntryWrapper(QuicPacketNumber offset);
+  const EntryWrapper* GetEntryWrapper(QuicPacketNumber offset) const;
+  EntryWrapper* GetEntryWrapper(QuicPacketNumber offset) {
+    const auto* const_this = this;
+    return const_cast<EntryWrapper*>(const_this->GetEntryWrapper(offset));
+  }
 
   std::deque<EntryWrapper> entries_;
   size_t number_of_present_entries_;
   QuicPacketNumber first_packet_;
 };
 
 template <typename T>
 T* PacketNumberIndexedQueue<T>::GetEntry(QuicPacketNumber packet_number) {
   EntryWrapper* entry = GetEntryWrapper(packet_number);
   if (entry == nullptr) {
     return nullptr;
   }
   return &entry->data;
 }
 
 template <typename T>
+const T* PacketNumberIndexedQueue<T>::GetEntry(
+    QuicPacketNumber packet_number) const {
+  const EntryWrapper* entry = GetEntryWrapper(packet_number);
+  if (entry == nullptr) {
+    return nullptr;
+  }
+  return &entry->data;
+}
+
+template <typename T>
 template <typename... Args>
 bool PacketNumberIndexedQueue<T>::Emplace(QuicPacketNumber packet_number,
                                           Args&&... args) {
   if (IsEmpty()) {
     DCHECK(entries_.empty());
     DCHECK_EQ(0u, first_packet_);
 
     entries_.emplace_back(std::forward<Args>(args)...);
     number_of_present_entries_ = 1;
     first_packet_ = packet_number;
@@ skipping 37 matching lines @@
   while (!entries_.empty() && !entries_.front().present) {
     entries_.pop_front();
     first_packet_++;
   }
   if (entries_.empty()) {
     first_packet_ = 0;
   }
 }
 
 template <typename T>
-auto PacketNumberIndexedQueue<T>::GetEntryWrapper(QuicPacketNumber offset)
-    -> EntryWrapper* {
+auto PacketNumberIndexedQueue<T>::GetEntryWrapper(QuicPacketNumber offset) const
+    -> const EntryWrapper* {
   if (offset < first_packet_) {
     return nullptr;
   }
 
   offset -= first_packet_;
   if (offset >= entries_.size()) {
     return nullptr;
   }
 
-  EntryWrapper* entry = &entries_[offset];
+  const EntryWrapper* entry = &entries_[offset];
   if (!entry->present) {
     return nullptr;
   }
 
   return entry;
 }
 
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_PACKET_NUMBER_INDEXED_QUEUE_H_