Make SpdyFrame::size a constant instead of a static method so gcc can optimize the call away.

net/spdy/spdy_framer_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 <algorithm>
 #include <iostream>
 
 #include "base/memory/scoped_ptr.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_protocol.h"
@@ skipping 278 matching lines @@
  public:
   virtual void TearDown() {}
 
  protected:
   void CompareFrame(const std::string& description,
                     const SpdyFrame& actual_frame,
                     const unsigned char* expected,
                     const int expected_len) {
     const unsigned char* actual =
         reinterpret_cast<const unsigned char*>(actual_frame.data());
-    int actual_len = actual_frame.length() + SpdyFrame::size();
+    int actual_len = actual_frame.length() + SpdyFrame::kHeaderSize;
     CompareCharArraysWithHexError(
         description, actual, actual_len, expected, expected_len);
   }
 };
 
 
 TEST(SpdyFrameBuilderTest, WriteLimits) {
   SpdyFrameBuilder builder(kLengthMask + 4);
   // length field should fail.
   EXPECT_FALSE(builder.WriteBytes(reinterpret_cast<const void*>(0x1),
@@ skipping 82 matching lines @@
   frame.WriteUInt32(0);  // Associated stream id
   frame.WriteUInt16(0);  // Priority.
 
   frame.WriteUInt16(2);  // Number of headers.
   SpdyHeaderBlock::iterator it;
   frame.WriteString("gamma");
   frame.WriteString("gamma");
   frame.WriteString("alpha");
   frame.WriteString("alpha");
   // write the length
-  frame.WriteUInt32ToOffset(4, frame.length() - SpdyFrame::size());
+  frame.WriteUInt32ToOffset(4, frame.length() - SpdyFrame::kHeaderSize);
 
   SpdyHeaderBlock new_headers;
   scoped_ptr<SpdyFrame> control_frame(frame.take());
   SpdySynStreamControlFrame syn_frame(control_frame->data(), false);
   std::string serialized_headers(syn_frame.header_block(),
                                  syn_frame.header_block_len());
   SpdyFramer framer;
   framer.set_enable_compression(false);
   EXPECT_TRUE(framer.ParseHeaderBlock(control_frame.get(), &new_headers));
 }
 
 TEST_F(SpdyFramerTest, WrongNumberOfHeaders) {
   SpdyFrameBuilder frame1;
   SpdyFrameBuilder frame2;
 
   // a frame with smaller number of actual headers
   frame1.WriteUInt16(kControlFlagMask | 1);
   frame1.WriteUInt16(SYN_STREAM);
   frame1.WriteUInt32(0);  // Placeholder for the length.
   frame1.WriteUInt32(3);  // stream_id
   frame1.WriteUInt16(0);  // Priority.
 
   frame1.WriteUInt16(1);  // Wrong number of headers (underflow)
   frame1.WriteString("gamma");
   frame1.WriteString("gamma");
   frame1.WriteString("alpha");
   frame1.WriteString("alpha");
   // write the length
-  frame1.WriteUInt32ToOffset(4, frame1.length() - SpdyFrame::size());
+  frame1.WriteUInt32ToOffset(4, frame1.length() - SpdyFrame::kHeaderSize);
 
   // a frame with larger number of actual headers
   frame2.WriteUInt16(kControlFlagMask | 1);
   frame2.WriteUInt16(SYN_STREAM);
   frame2.WriteUInt32(0);  // Placeholder for the length.
   frame2.WriteUInt32(3);  // stream_id
   frame2.WriteUInt16(0);  // Priority.
 
   frame2.WriteUInt16(100);  // Wrong number of headers (overflow)
   frame2.WriteString("gamma");
   frame2.WriteString("gamma");
   frame2.WriteString("alpha");
   frame2.WriteString("alpha");
   // write the length
-  frame2.WriteUInt32ToOffset(4, frame2.length() - SpdyFrame::size());
+  frame2.WriteUInt32ToOffset(4, frame2.length() - SpdyFrame::kHeaderSize);
 
   SpdyHeaderBlock new_headers;
   scoped_ptr<SpdyFrame> syn_frame1(frame1.take());
   scoped_ptr<SpdyFrame> syn_frame2(frame2.take());
   SpdyFramer framer;
   framer.set_enable_compression(false);
   EXPECT_FALSE(framer.ParseHeaderBlock(syn_frame1.get(), &new_headers));
   EXPECT_FALSE(framer.ParseHeaderBlock(syn_frame2.get(), &new_headers));
 }
 
 TEST_F(SpdyFramerTest, DuplicateHeader) {
   // Frame builder with plentiful buffer size.
   SpdyFrameBuilder frame(1024);
 
   frame.WriteUInt16(kControlFlagMask | 1);
   frame.WriteUInt16(SYN_STREAM);
   frame.WriteUInt32(0);  // Placeholder for the length.
   frame.WriteUInt32(3);  // stream_id
   frame.WriteUInt32(0);  // associated stream id
   frame.WriteUInt16(0);  // Priority.
 
   frame.WriteUInt16(2);  // Number of headers.
   SpdyHeaderBlock::iterator it;
   frame.WriteString("name");
   frame.WriteString("value1");
   frame.WriteString("name");
   frame.WriteString("value2");
   // write the length
-  frame.WriteUInt32ToOffset(4, frame.length() - SpdyFrame::size());
+  frame.WriteUInt32ToOffset(4, frame.length() - SpdyFrame::kHeaderSize);
 
   SpdyHeaderBlock new_headers;
   scoped_ptr<SpdyFrame> control_frame(frame.take());
   SpdySynStreamControlFrame syn_frame(control_frame->data(), false);
   std::string serialized_headers(syn_frame.header_block(),
                                  syn_frame.header_block_len());
   SpdyFramer framer;
   framer.set_enable_compression(false);
   // This should fail because duplicate headers are verboten by the spec.
   EXPECT_FALSE(framer.ParseHeaderBlock(control_frame.get(), &new_headers));
 }
 
 TEST_F(SpdyFramerTest, MultiValueHeader) {
   // Frame builder with plentiful buffer size.
   SpdyFrameBuilder frame(1024);
 
   frame.WriteUInt16(kControlFlagMask | 1);
   frame.WriteUInt16(SYN_STREAM);
   frame.WriteUInt32(0);  // Placeholder for the length.
   frame.WriteUInt32(3);  // stream_id
   frame.WriteUInt32(0);  // associated stream id
   frame.WriteUInt16(0);  // Priority.
 
   frame.WriteUInt16(1);  // Number of headers.
   SpdyHeaderBlock::iterator it;
   frame.WriteString("name");
   std::string value("value1\0value2");
   frame.WriteString(value);
   // write the length
-  frame.WriteUInt32ToOffset(4, frame.length() - SpdyFrame::size());
+  frame.WriteUInt32ToOffset(4, frame.length() - SpdyFrame::kHeaderSize);
 
   SpdyHeaderBlock new_headers;
   scoped_ptr<SpdyFrame> control_frame(frame.take());
   SpdySynStreamControlFrame syn_frame(control_frame->data(), false);
   std::string serialized_headers(syn_frame.header_block(),
                                  syn_frame.header_block_len());
   SpdyFramer framer;
   framer.set_enable_compression(false);
   EXPECT_TRUE(framer.ParseHeaderBlock(control_frame.get(), &new_headers));
   EXPECT_TRUE(new_headers.find("name") != new_headers.end());
@@ skipping 51 matching lines @@
 
   // Decompress the first frame
   scoped_ptr<SpdyFrame> frame3(framer.DecompressFrame(*frame1.get()));
 
   // Decompress the second frame
   scoped_ptr<SpdyFrame> frame4(framer.DecompressFrame(*frame2.get()));
 
   // Expect frames 3 & 4 to be the same.
   EXPECT_EQ(0,
       memcmp(frame3->data(), frame4->data(),
-      SpdyFrame::size() + frame3->length()));
+      SpdyFrame::kHeaderSize + frame3->length()));
 
   // Expect frames 3 to be the same as a uncompressed frame created
   // from scratch.
   scoped_ptr<SpdySynStreamControlFrame>
       uncompressed_frame(framer.CreateSynStream(1, 0, 1, CONTROL_FLAG_NONE,
                                                 false, &headers));
   EXPECT_EQ(frame3->length(), uncompressed_frame->length());
   EXPECT_EQ(0,
       memcmp(frame3->data(), uncompressed_frame->data(),
-      SpdyFrame::size() + uncompressed_frame->length()));
+      SpdyFrame::kHeaderSize + uncompressed_frame->length()));
 }
 
 TEST_F(SpdyFramerTest, DecompressUncompressedFrame) {
   SpdyHeaderBlock headers;
   headers["server"] = "SpdyServer 1.0";
   headers["date"] = "Mon 12 Jan 2009 12:12:12 PST";
   headers["status"] = "200";
   headers["version"] = "HTTP/1.1";
   headers["content-type"] = "text/html";
   headers["content-length"] = "12";
@@ skipping 276 matching lines @@
       send_framer.CreateDataFrame(
           1, bytes, arraysize(bytes),
           DATA_FLAG_FIN));
   EXPECT_TRUE(send_frame.get() != NULL);
 
   // Run the inputs through the framer.
   TestSpdyVisitor visitor;
   visitor.use_compression_ = true;
   const unsigned char* data;
   data = reinterpret_cast<const unsigned char*>(syn_frame->data());
-  visitor.SimulateInFramer(data, syn_frame->length() + SpdyFrame::size());
+  visitor.SimulateInFramer(data, syn_frame->length() + SpdyFrame::kHeaderSize);
   data = reinterpret_cast<const unsigned char*>(send_frame->data());
-  visitor.SimulateInFramer(data, send_frame->length() + SpdyFrame::size());
+  visitor.SimulateInFramer(data, send_frame->length() + SpdyFrame::kHeaderSize);
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.syn_frame_count_);
   EXPECT_EQ(0, visitor.syn_reply_frame_count_);
   EXPECT_EQ(0, visitor.headers_frame_count_);
   EXPECT_EQ(arraysize(bytes), static_cast<unsigned>(visitor.data_bytes_));
   EXPECT_EQ(0, visitor.fin_frame_count_);
   EXPECT_EQ(0, visitor.fin_flag_count_);
   EXPECT_EQ(1, visitor.zero_length_data_frame_count_);
   // EXPECT_EQ(1, visitor.data_frame_count_);
@@ skipping 889 matching lines @@
     // to make sure we don't crash.
     if (frame.get() != NULL) {
       // Now that same header block should decompress just fine.
       SpdyHeaderBlock new_headers;
       decompress_framer.ParseHeaderBlock(frame.get(), &new_headers);
     }
   }
 }
 
 }  // namespace