Code cleanup of control frame size enforcement.

net/spdy/spdy_framer_test.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 <algorithm>
 #include <iostream>
 #include <limits>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 484 matching lines @@
     header_buffer_valid_ = true;
     DCHECK_NE(header_stream_id_, SpdyFramer::kInvalidStream);
   }
 
   // Override the default buffer size (16K). Call before using the framer!
   void set_header_buffer_size(size_t header_buffer_size) {
     header_buffer_size_ = header_buffer_size;
     header_buffer_.reset(new char[header_buffer_size]);
   }
 
+  // Largest control frame that the SPDY implementation sends, including the
+  // size of the header.
+  static size_t sent_control_frame_max_size() {
+    return SpdyFramer::kMaxControlFrameSize;
+  }
+
   static size_t header_data_chunk_max_size() {
     return SpdyFramer::kHeaderDataChunkMaxSize;
   }
 
   SpdyFramer framer_;
   bool use_compression_;
 
   // Counters from the visitor callbacks.
   int error_count_;
   int syn_frame_count_;
@@ skipping 2625 matching lines @@
   {
     // Test framing in a case such that a PUSH_PROMISE frame, with one byte of
     // padding, cannot hold all the data payload, which is overflowed to the
     // consecutive CONTINUATION frame.
     SpdyFramer framer(spdy_version_);
     framer.set_enable_compression(false);
     const char kDescription[] =
         "PUSH_PROMISE and CONTINUATION frames with one byte of padding";
 
     const unsigned char kPartialPushPromiseFrameData[] = {
-        0x00, 0x03, 0xf6, 0x05,  // PUSH_PROMISE
+        0x00, 0x03, 0xf7, 0x05,  // PUSH_PROMISE
         0x08, 0x00, 0x00, 0x00,  // PADDED
         0x2a, 0x00, 0x00, 0x00,  // Stream 42
         0x00, 0x39, 0x00, 0x03,  // Promised stream 57
         0x78, 0x78, 0x78, 0x7f,  // xxx.
-        0x80, 0x07, 0x78, 0x78,  // ..xx
+        0x81, 0x07, 0x78, 0x78,  // ..xx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
@@ skipping 16 matching lines @@
         0x2a, 0x78, 0x78, 0x78,  // Stream 42, xxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78,
     };
 
     SpdyPushPromiseIR push_promise(42, 57);
     push_promise.set_padding_len(1);
-    string big_value(framer.GetHeaderFragmentMaxSize(), 'x');
+    string big_value(TestSpdyVisitor::sent_control_frame_max_size(), 'x');
     push_promise.SetHeader("xxx", big_value);
     scoped_ptr<SpdySerializedFrame> frame(
         framer.SerializePushPromise(push_promise));
 
     // The entire frame should look like below:
     // Name                     Length in Byte
     // ------------------------------------------- Begin of PUSH_PROMISE frame
     // PUSH_PROMISE header      9
     // Pad length field         1
     // Promised stream          4
     // Length field of key      2
     // Content of key           3
     // Length field of value    3
     // Part of big_value        16361
     // ------------------------------------------- Begin of CONTINUATION frame
     // CONTINUATION header      9
     // Remaining of big_value   22
     // ------------------------------------------- End
 
     // Length of everything listed above except big_value.
     int len_non_data_payload = 31;
-    EXPECT_EQ(framer.GetHeaderFragmentMaxSize() + len_non_data_payload,
-              frame->size());
+    EXPECT_EQ(
+        TestSpdyVisitor::sent_control_frame_max_size() + len_non_data_payload,
+        frame->size());
 
     // Partially compare the PUSH_PROMISE frame against the template.
     const unsigned char* frame_data =
         reinterpret_cast<const unsigned char*>(frame->data());
     CompareCharArraysWithHexError(kDescription,
                                   frame_data,
                                   arraysize(kPartialPushPromiseFrameData),
                                   kPartialPushPromiseFrameData,
                                   arraysize(kPartialPushPromiseFrameData));
 
     // Compare the CONTINUATION frame against the template.
-    frame_data += framer.GetHeaderFragmentMaxSize();
+    frame_data += TestSpdyVisitor::sent_control_frame_max_size();
     CompareCharArraysWithHexError(kDescription,
                                   frame_data,
                                   arraysize(kContinuationFrameData),
                                   kContinuationFrameData,
                                   arraysize(kContinuationFrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, CreateAltSvc) {
   if (spdy_version_ <= SPDY3) {
@@ skipping 150 matching lines @@
   }
   // First find the size of the header value in order to just reach the control
   // frame max size.
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
   syn_stream.SetHeader("aa", "");
   scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
   const size_t kBigValueSize =
-      framer.GetControlFrameBufferMaxSize() - control_frame->size();
+      TestSpdyVisitor::sent_control_frame_max_size() - control_frame->size();
 
   // Create a frame at exactly that size.
   string big_value(kBigValueSize, 'x');
   syn_stream.SetHeader("aa", big_value);
   control_frame.reset(framer.SerializeSynStream(syn_stream));
   EXPECT_TRUE(control_frame.get() != NULL);
-  EXPECT_EQ(framer.GetControlFrameBufferMaxSize(), control_frame->size());
+  EXPECT_EQ(TestSpdyVisitor::sent_control_frame_max_size(),
+            control_frame->size());
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame->size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.syn_frame_count_);
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.zero_length_data_frame_count_);
   EXPECT_LT(kBigValueSize, visitor.header_buffer_length_);
 }
 
-TEST_P(SpdyFramerTest, ControlFrameTooLarge) {
+// This test is disabled because Chromium is willing to accept control frames up
+// to the maximum size allowed by the specification, and SpdyFrameBuilder is not
+// capable of building larger frames.
+TEST_P(SpdyFramerTest, DISABLED_ControlFrameTooLarge) {
   if (spdy_version_ > SPDY3) {
     // TODO(jgraettinger): This test setup doesn't work with HPACK.
     return;
   }
   // First find the size of the header value in order to just reach the control
   // frame max size.
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   SpdySynStreamIR syn_stream(1);
   syn_stream.SetHeader("aa", "");
   syn_stream.set_priority(1);
   scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
   const size_t kBigValueSize =
-      framer.GetControlFrameBufferMaxSize() - control_frame->size() + 1;
+      SpdyConstants::GetFrameMaximumSize(spdy_version_) -
+      control_frame->size() + 1;
 
   // Create a frame at exatly that size.
   string big_value(kBigValueSize, 'x');
   syn_stream.SetHeader("aa", big_value);
   // Upstream branches here and wraps SPDY4 with EXPECT_DEBUG_DFATAL. We
   // neither support that in Chromium, nor do we use the same DFATAL (see
   // SpdyFrameBuilder::WriteFramePrefix()).
   control_frame.reset(framer.SerializeSynStream(syn_stream));
 
   EXPECT_TRUE(control_frame.get() != NULL);
-  EXPECT_EQ(framer.GetControlFrameBufferMaxSize() + 1,
+  EXPECT_EQ(SpdyConstants::GetFrameMaximumSize(spdy_version_) + 1,
             control_frame->size());
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame->size());
   EXPECT_FALSE(visitor.header_buffer_valid_);
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_CONTROL_PAYLOAD_TOO_LARGE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
   EXPECT_EQ(0, visitor.syn_frame_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
 }
 
 TEST_P(SpdyFramerTest, TooLargeHeadersFrameUsesContinuation) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   SpdyHeadersIR headers(1);
   headers.set_padding_len(256);
 
   // Exact payload length will change with HPACK, but this should be long
   // enough to cause an overflow.
-  const size_t kBigValueSize = framer.GetControlFrameBufferMaxSize();
+  const size_t kBigValueSize = kControlFrameSizeLimit;
   string big_value(kBigValueSize, 'x');
   headers.SetHeader("aa", big_value);
   scoped_ptr<SpdyFrame> control_frame(framer.SerializeHeaders(headers));
   EXPECT_TRUE(control_frame.get() != NULL);
-  EXPECT_GT(control_frame->size(), framer.GetControlFrameBufferMaxSize());
+  EXPECT_GT(control_frame->size(),
+            TestSpdyVisitor::sent_control_frame_max_size());
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame->size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(16, visitor.continuation_count_);
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
 }
 
 TEST_P(SpdyFramerTest, TooLargePushPromiseFrameUsesContinuation) {
   if (spdy_version_ <= SPDY3) {
     return;
   }
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   SpdyPushPromiseIR push_promise(1, 2);
   push_promise.set_padding_len(256);
 
   // Exact payload length will change with HPACK, but this should be long
   // enough to cause an overflow.
-  const size_t kBigValueSize = framer.GetControlFrameBufferMaxSize();
+  const size_t kBigValueSize = kControlFrameSizeLimit;
   string big_value(kBigValueSize, 'x');
   push_promise.SetHeader("aa", big_value);
   scoped_ptr<SpdyFrame> control_frame(
       framer.SerializePushPromise(push_promise));
   EXPECT_TRUE(control_frame.get() != NULL);
-  EXPECT_GT(control_frame->size(), framer.GetControlFrameBufferMaxSize());
+  EXPECT_GT(control_frame->size(),
+            TestSpdyVisitor::sent_control_frame_max_size());
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame->data()),
       control_frame->size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.push_promise_frame_count_);
   EXPECT_EQ(16, visitor.continuation_count_);
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
@@ skipping 2225 matching lines @@
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 }  // namespace net