Misc. cleanup, primarily removing unused locals.

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.
 
 #include "net/spdy/spdy_framer.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/stats_counters.h"
 #include "base/third_party/valgrind/memcheck.h"
@@ skipping 657 matching lines @@
     // Not enough information to do anything meaningful.
     return original_len - len;
   }
 
   // Using a scoped_ptr here since we may need to create a new SpdyFrameReader
   // when processing DATA frames below.
   scoped_ptr<SpdyFrameReader> reader(
       new SpdyFrameReader(current_frame_buffer_.get(),
                           current_frame_buffer_length_));
 
-  uint16 version = 0;
   bool is_control_frame = false;
 
   uint16 control_frame_type_field =
-    SpdyConstants::DataFrameType(protocol_version());
+      SpdyConstants::DataFrameType(protocol_version());
   // ProcessControlFrameHeader() will set current_frame_type_ to the
   // correct value if this is a valid control frame.
   current_frame_type_ = DATA;
   if (protocol_version() <= SPDY3) {
+    uint16 version = 0;
     bool successful_read = reader->ReadUInt16(&version);
     DCHECK(successful_read);
     is_control_frame = (version & kControlFlagMask) != 0;
     version &= ~kControlFlagMask;  // Only valid for control frames.
     if (is_control_frame) {
       // We check version before we check validity: version can never be
       // 'invalid', it can only be unsupported.
       if (version < SpdyConstants::SerializeMajorVersion(SPDY_MIN_VERSION) ||
           version > SpdyConstants::SerializeMajorVersion(SPDY_MAX_VERSION) ||
           SpdyConstants::ParseMajorVersion(version) != protocol_version()) {
         // Version does not match the version the framer was initialized with.
         DVLOG(1) << "Unsupported SPDY version "
                  << version
                  << " (expected " << protocol_version() << ")";
         set_error(SPDY_UNSUPPORTED_VERSION);
         return 0;
-      } else {
-        // Convert version from wire format to SpdyMajorVersion.
-        version = SpdyConstants::ParseMajorVersion(version);
       }
       // We check control_frame_type_field's validity in
       // ProcessControlFrameHeader().
       successful_read = reader->ReadUInt16(&control_frame_type_field);
     } else {
       reader->Rewind();
       successful_read = reader->ReadUInt31(&current_frame_stream_id_);
     }
     DCHECK(successful_read);
 
     successful_read = reader->ReadUInt8(&current_frame_flags_);
     DCHECK(successful_read);
 
     uint32 length_field = 0;
     successful_read = reader->ReadUInt24(&length_field);
     DCHECK(successful_read);
     remaining_data_length_ = length_field;
     current_frame_length_ = remaining_data_length_ + reader->GetBytesConsumed();
   } else {
-    version = protocol_version();
     uint32 length_field = 0;
     bool successful_read = reader->ReadUInt24(&length_field);
     DCHECK(successful_read);
 
     uint8 control_frame_type_field_uint8 =
       SpdyConstants::DataFrameType(protocol_version());
     successful_read = reader->ReadUInt8(&control_frame_type_field_uint8);
     DCHECK(successful_read);
     // We check control_frame_type_field's validity in
     // ProcessControlFrameHeader().
@@ skipping 430 matching lines @@
     total_length += length_of_name_size + it->first.size() +
                     length_of_value_size + it->second.size();
   }
   return total_length;
 }
 
 void SpdyFramer::WriteHeaderBlock(SpdyFrameBuilder* frame,
                                   const SpdyMajorVersion spdy_version,
                                   const SpdyHeaderBlock* headers) {
   if (spdy_version < SPDY3) {
-    frame->WriteUInt16(headers->size());  // Number of headers.
+    frame->WriteUInt16(headers->size());
   } else {
-    frame->WriteUInt32(headers->size());  // Number of headers.
+    frame->WriteUInt32(headers->size());
   }
   SpdyHeaderBlock::const_iterator it;
   for (it = headers->begin(); it != headers->end(); ++it) {
     if (spdy_version < SPDY3) {
       frame->WriteString(it->first);
       frame->WriteString(it->second);
     } else {
       frame->WriteStringPiece32(it->first);
       frame->WriteStringPiece32(it->second);
     }
@@ skipping 2058 matching lines @@
   builder->Seek(compressed_size);
   builder->RewriteLength(*this);
 
   pre_compress_bytes.Add(uncompressed_len);
   post_compress_bytes.Add(compressed_size);
 
   compressed_frames.Increment();
 }
 
 }  // namespace net