Change the signature of SpdyFramer::SerializeNameValueBlockWithoutCompression

net/spdy/spdy_framer.cc

 // Copyright (c) 2012 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.
 
 // TODO(rtenhove) clean up frame buffer size calculations so that we aren't
 // constantly adding and subtracting header sizes; this is ugly and error-
 // prone.
 
 #include "net/spdy/spdy_framer.h"
 
@@ skipping 1947 matching lines @@
       // Assume that the problem was the header block was too large for the
       // visitor.
       set_error(SPDY_CONTROL_PAYLOAD_TOO_LARGE);
     }
   }
   return read_successfully;
 }
 
 void SpdyFramer::SerializeNameValueBlockWithoutCompression(
     SpdyFrameBuilder* builder,
-    const SpdyFrameWithNameValueBlockIR& frame) const {
-  const SpdyNameValueBlock* name_value_block = &(frame.name_value_block());
-
+    const SpdyNameValueBlock& name_value_block) const {
   // Serialize number of headers.
   if (protocol_version() < 3) {
-    builder->WriteUInt16(name_value_block->size());
+    builder->WriteUInt16(name_value_block.size());
   } else {
-    builder->WriteUInt32(name_value_block->size());
+    builder->WriteUInt32(name_value_block.size());
   }
 
   // Serialize each header.
-  for (SpdyHeaderBlock::const_iterator it = name_value_block->begin();
-       it != name_value_block->end();
+  for (SpdyHeaderBlock::const_iterator it = name_value_block.begin();
+       it != name_value_block.end();
        ++it) {
     if (protocol_version() < 3) {
       builder->WriteString(it->first);
       builder->WriteString(it->second);
     } else {
       builder->WriteStringPiece32(it->first);
       builder->WriteStringPiece32(it->second);
     }
   }
 }
 
 void SpdyFramer::SerializeNameValueBlock(
     SpdyFrameBuilder* builder,
     const SpdyFrameWithNameValueBlockIR& frame) {
   if (!enable_compression_) {
-    return SerializeNameValueBlockWithoutCompression(builder, frame);
+    return SerializeNameValueBlockWithoutCompression(builder,
+                                                     frame.name_value_block());
   }
 
   // First build an uncompressed version to be fed into the compressor.
   const size_t uncompressed_len = GetSerializedLength(
       protocol_version(), &(frame.name_value_block()));
   SpdyFrameBuilder uncompressed_builder(uncompressed_len);
-  SerializeNameValueBlockWithoutCompression(&uncompressed_builder, frame);
+  SerializeNameValueBlockWithoutCompression(&uncompressed_builder,
+                                            frame.name_value_block());
   scoped_ptr<SpdyFrame> uncompressed_payload(uncompressed_builder.take());
 
   z_stream* compressor = GetHeaderCompressor();
   if (!compressor) {
     LOG(DFATAL) << "Could not obtain compressor.";
     return;
   }
 
   base::StatsCounter compressed_frames("spdy.CompressedFrames");
   base::StatsCounter pre_compress_bytes("spdy.PreCompressSize");
@@ skipping 40 matching lines @@
   post_compress_bytes.Add(compressed_size);
 
   compressed_frames.Increment();
 
   if (debug_visitor_ != NULL) {
     debug_visitor_->OnCompressedHeaderBlock(uncompressed_len, compressed_size);
   }
 }
 
 }  // namespace net