SpdyFramer dead code removal.

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 2381 matching lines @@
     builder.WriteUInt8(MapPriorityToWeight(priority));
   }
   DCHECK_EQ(GetSynStreamMinimumSize(), builder.length());
   if (protocol_version() > SPDY3) {
     builder.WriteBytes(&hpack_encoding[0], hpack_encoding.size());
   } else {
     SerializeNameValueBlock(&builder, syn_stream);
   }
 
   if (debug_visitor_) {
-    const size_t payload_len = protocol_version() > SPDY3 ?
-        hpack_encoding.size() :
+    const size_t payload_len =
         GetSerializedLength(protocol_version(),
                             &(syn_stream.name_value_block()));
     // SPDY 4 reports this compression as a SYN_STREAM compression.
     debug_visitor_->OnSendCompressedFrame(syn_stream.stream_id(),
                                           SYN_STREAM,
                                           payload_len,
                                           builder.length());
   }
 
   return builder.take();
@@ skipping 302 matching lines @@
 SpdyFrame* SpdyFramer::SerializePushPromise(
     const SpdyPushPromiseIR& push_promise) {
   DCHECK_LT(SPDY3, protocol_version());
   uint8 flags = 0;
   // This will get overwritten if we overflow into a CONTINUATION frame.
   flags |= PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
   // The size of this frame, including variable-length name-value block.
   size_t size = GetPushPromiseMinimumSize();
 
   string hpack_encoding;
-  if (protocol_version() > SPDY3) {
-    if (enable_compression_) {
-      GetHpackEncoder()->EncodeHeaderSet(
-          push_promise.name_value_block(), &hpack_encoding);
-    } else {
-      GetHpackEncoder()->EncodeHeaderSetWithoutCompression(
-          push_promise.name_value_block(), &hpack_encoding);
-    }
-    size += hpack_encoding.size();
-    if (size > GetControlFrameBufferMaxSize()) {
-      size += GetNumberRequiredContinuationFrames(size) *
-              GetContinuationMinimumSize();
-      flags &= ~PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
-    }
+  if (enable_compression_) {
+    GetHpackEncoder()->EncodeHeaderSet(
+        push_promise.name_value_block(), &hpack_encoding);
   } else {
-    size += GetSerializedLength(push_promise.name_value_block());
+    GetHpackEncoder()->EncodeHeaderSetWithoutCompression(
+        push_promise.name_value_block(), &hpack_encoding);
+  }
+  size += hpack_encoding.size();
+  if (size > GetControlFrameBufferMaxSize()) {
+    size += GetNumberRequiredContinuationFrames(size) *
+            GetContinuationMinimumSize();
+    flags &= ~PUSH_PROMISE_FLAG_END_PUSH_PROMISE;
   }
 
   SpdyFrameBuilder builder(size, protocol_version());
   builder.BeginNewFrame(*this,
                         PUSH_PROMISE,
                         flags,
                         push_promise.stream_id());
   builder.WriteUInt32(push_promise.promised_stream_id());
   DCHECK_EQ(GetPushPromiseMinimumSize(), builder.length());
 
-  if (protocol_version() > SPDY3) {
-    WritePayloadWithContinuation(&builder,
-                                 hpack_encoding,
-                                 push_promise.stream_id(),
-                                 PUSH_PROMISE);
-  } else {
-    SerializeNameValueBlock(&builder, push_promise);
-  }
+  WritePayloadWithContinuation(&builder,
+                               hpack_encoding,
+                               push_promise.stream_id(),
+                               PUSH_PROMISE);
 
   if (debug_visitor_) {
-    const size_t payload_len = protocol_version() > SPDY3 ?
-        hpack_encoding.size() :
-        GetSerializedLength(protocol_version(),
-                            &(push_promise.name_value_block()));
     debug_visitor_->OnSendCompressedFrame(push_promise.stream_id(),
-        PUSH_PROMISE, payload_len, builder.length());
+        PUSH_PROMISE, hpack_encoding.size(), builder.length());
   }
 
   return builder.take();
 }
 
 // TODO(jgraettinger): This implementation is incorrect. The continuation
 // frame continues a previously-begun HPACK encoding; it doesn't begin a
 // new one. Figure out whether it makes sense to keep SerializeContinuation().
 SpdyFrame* SpdyFramer::SerializeContinuation(
     const SpdyContinuationIR& continuation) {
@@ skipping 460 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