Make QuicSpdyStream::ParseHeaderStatusCode() inparam const.

net/quic/quic_spdy_stream.cc

 // Copyright 2013 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.
 
 #include "net/quic/quic_spdy_stream.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/quic_bug_tracker.h"
 #include "net/quic/quic_spdy_session.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/quic_write_blocked_list.h"
 #include "net/quic/spdy_utils.h"
 
+using base::IntToString;
 using base::StringPiece;
-using net::SpdyPriority;
 using std::min;
 using std::string;
 
 namespace net {
 
 #define ENDPOINT                                                               \
   (session()->perspective() == Perspective::IS_SERVER ? "Server: " : "Client:" \
                                                                      " ")
 
 QuicSpdyStream::QuicSpdyStream(QuicStreamId id, QuicSpdySession* spdy_session)
@@ skipping 67 matching lines @@
   if (fin_sent()) {
     QUIC_BUG << "Trailers cannot be sent after a FIN.";
     return 0;
   }
 
   // The header block must contain the final offset for this stream, as the
   // trailers may be processed out of order at the peer.
   DVLOG(1) << "Inserting trailer: (" << kFinalOffsetHeaderKey << ", "
            << stream_bytes_written() + queued_data_bytes() << ")";
   SpdyHeaderBlock trailer_block_with_offset(trailer_block);
-  trailer_block_with_offset.insert(std::make_pair(
-      kFinalOffsetHeaderKey,
-      base::IntToString(stream_bytes_written() + queued_data_bytes())));
+  trailer_block_with_offset.insert(
+      std::make_pair(kFinalOffsetHeaderKey,
+                     IntToString(stream_bytes_written() + queued_data_bytes())));
 
   // Write the trailing headers with a FIN, and close stream for writing:
   // trailers are the last thing to be sent on a stream.
   const bool kFin = true;
   size_t bytes_written = spdy_session_->WriteHeaders(
       id(), trailer_block_with_offset, kFin, priority_, ack_notifier_delegate);
   set_fin_sent(kFin);
 
   // Trailers are the last thing to be sent on a stream, but if there is still
   // queued data then CloseWriteSide() will cause it never to be sent.
@@ skipping 237 matching lines @@
     visitor_ = nullptr;
     visitor->OnClose(this);
   }
 }
 
 bool QuicSpdyStream::FinishedReadingHeaders() const {
   return headers_decompressed_ && decompressed_headers_.empty() &&
          header_list_.empty();
 }
 
-bool QuicSpdyStream::ParseHeaderStatusCode(SpdyHeaderBlock* header,
+bool QuicSpdyStream::ParseHeaderStatusCode(const SpdyHeaderBlock& header,
                                            int* status_code) const {
-  StringPiece status = (*header)[":status"];
+  SpdyHeaderBlock::const_iterator it = header.find(":status");
+  if (it == header.end()) {
+    return false;
+  }
+  const StringPiece status(it->second);
   if (status.size() != 3) {
     return false;
   }
   // First character must be an integer in range [1,5].
   if (status[0] < '1' || status[0] > '5') {
     return false;
   }
   // The remaining two characters must be integers.
   if (!isdigit(status[1]) || !isdigit(status[2])) {
     return false;
@@ skipping 15 matching lines @@
 
 SpdyPriority QuicSpdyStream::priority() const {
   return priority_;
 }
 
 void QuicSpdyStream::ClearSession() {
   spdy_session_ = nullptr;
 }
 
 }  // namespace net