Deprecate SpdyControlFrame::size in favor of SpdyControlFrame::kHeaderSize

net/spdy/spdy_protocol_test.cc

 // Copyright (c) 2011 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_protocol.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "net/spdy/spdy_bitmasks.h"
 #include "net/spdy/spdy_framer.h"
 #include "testing/platform_test.h"
@@ skipping 32 matching lines @@
 using spdy::kLengthMask;
 using spdy::kSpdyProtocolVersion;
 using spdy::kStreamIdMask;
 
 namespace {
 
 // Test our protocol constants
 TEST(SpdyProtocolTest, ProtocolConstants) {
   EXPECT_EQ(8u, SpdyFrame::kHeaderSize);
   EXPECT_EQ(8u, SpdyDataFrame::size());
-  EXPECT_EQ(8u, SpdyControlFrame::size());
+  EXPECT_EQ(8u, SpdyControlFrame::kHeaderSize);
   EXPECT_EQ(18u, SpdySynStreamControlFrame::size());
   EXPECT_EQ(14u, SpdySynReplyControlFrame::size());
   EXPECT_EQ(16u, SpdyRstStreamControlFrame::size());
   EXPECT_EQ(12u, SpdySettingsControlFrame::size());
   EXPECT_EQ(8u, SpdyNoOpControlFrame::size());
   EXPECT_EQ(12u, SpdyPingControlFrame::size());
   EXPECT_EQ(12u, SpdyGoAwayControlFrame::size());
   EXPECT_EQ(14u, SpdyHeadersControlFrame::size());
   EXPECT_EQ(16u, SpdyWindowUpdateControlFrame::size());
   EXPECT_EQ(4u, sizeof(FlagsAndLength));
@@ skipping 194 matching lines @@
       EXPECT_EQ(parsed.flags(), ids[pos].flags());
       EXPECT_EQ(parsed.id(), ids[pos].id());
       EXPECT_EQ(value, static_cast<uint32>(pos));
       ++it;
       ++pos;
     }
   }
 }
 
 TEST(SpdyProtocolTest, HasHeaderBlock) {
-  SpdyControlFrame frame(SpdyControlFrame::size());
+  SpdyControlFrame frame(SpdyControlFrame::kHeaderSize);
   for (SpdyControlType type = SYN_STREAM;
       type < NUM_CONTROL_FRAME_TYPES;
       type = static_cast<SpdyControlType>(type + 1)) {
     frame.set_type(type);
     if (type == SYN_STREAM || type == SYN_REPLY || type == HEADERS) {
       EXPECT_TRUE(frame.has_header_block());
     } else {
       EXPECT_FALSE(frame.has_header_block());
     }
   }
@@ skipping 22 matching lines @@
   EXPECT_DEBUG_DEATH(frame.set_length(~0), "");
 #else
   EXPECT_DEATH(frame.set_length(~0), "");
 #endif
 #endif
   EXPECT_EQ(0, frame.flags());
 }
 
 TEST(SpdyProtocolDeathTest, TestSpdyControlFrameStreamId) {
   SpdyControlFrame frame_store(SpdySynStreamControlFrame::size());
-  memset(frame_store.data(), '1', SpdyControlFrame::size());
+  memset(frame_store.data(), '1', SpdyControlFrame::kHeaderSize);
   SpdySynStreamControlFrame* frame =
       reinterpret_cast<SpdySynStreamControlFrame*>(&frame_store);
 
   // Set the stream ID to various values.
   frame->set_stream_id(0);
   EXPECT_EQ(0u, frame->stream_id());
   EXPECT_FALSE(frame->is_control_frame());
   frame->set_stream_id(kStreamIdMask);
   EXPECT_EQ(kStreamIdMask, frame->stream_id());
   EXPECT_FALSE(frame->is_control_frame());
 }
 
 TEST(SpdyProtocolDeathTest, TestSpdyControlFrameVersion) {
   const unsigned int kVersionMask = 0x7fff;
   SpdyControlFrame frame(SpdySynStreamControlFrame::size());
-  memset(frame.data(), '1', SpdyControlFrame::size());
+  memset(frame.data(), '1', SpdyControlFrame::kHeaderSize);
 
   // Set the version to various values, and make sure it does not affect the
   // type.
   frame.set_type(SYN_STREAM);
   frame.set_version(0);
   EXPECT_EQ(0, frame.version());
   EXPECT_TRUE(frame.is_control_frame());
   EXPECT_EQ(SYN_STREAM, frame.type());
 
   SpdySynStreamControlFrame* syn_stream =
       reinterpret_cast<SpdySynStreamControlFrame*>(&frame);
   syn_stream->set_stream_id(~0 & kVersionMask);
   EXPECT_EQ(~0 & kVersionMask, syn_stream->stream_id());
   EXPECT_TRUE(frame.is_control_frame());
   EXPECT_EQ(SYN_STREAM, frame.type());
 }
 
 TEST(SpdyProtocolDeathTest, TestSpdyControlFrameType) {
-  SpdyControlFrame frame(SpdyControlFrame::size());
-  memset(frame.data(), 255, SpdyControlFrame::size());
+  SpdyControlFrame frame(SpdyControlFrame::kHeaderSize);
+  memset(frame.data(), 255, SpdyControlFrame::kHeaderSize);
 
   // type() should be out of bounds.
   EXPECT_FALSE(frame.AppearsToBeAValidControlFrame());
 
   uint16 version = frame.version();
 
   for (int i = SYN_STREAM; i <= spdy::NOOP; ++i) {
     frame.set_type(static_cast<SpdyControlType>(i));
     EXPECT_EQ(i, static_cast<int>(frame.type()));
     EXPECT_TRUE(frame.AppearsToBeAValidControlFrame());
@@ skipping 15 matching lines @@
 
   rst_frame->set_status(
       static_cast<spdy::SpdyStatusCodes>(spdy::INVALID - 1));
   EXPECT_EQ(spdy::INVALID, rst_frame->status());
 
   rst_frame->set_status(spdy::NUM_STATUS_CODES);
   EXPECT_EQ(spdy::INVALID, rst_frame->status());
 }
 
 }  // namespace