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

net/spdy/spdy_test_util.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_test_util.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 21 matching lines @@
     chunks[index] = MockWrite(true, ptr, chunk_size);
   }
   return chunks;
 }
 
 // Chop a SpdyFrame into an array of MockWrites.
 // |frame| is the frame to chop.
 // |num_chunks| is the number of chunks to create.
 MockWrite* ChopWriteFrame(const spdy::SpdyFrame& frame, int num_chunks) {
   return ChopWriteFrame(frame.data(),
-                        frame.length() + spdy::SpdyFrame::size(),
+                        frame.length() + spdy::SpdyFrame::kHeaderSize,
                         num_chunks);
 }
 
 // Chop a frame into an array of MockReads.
 // |data| is the frame to chop.
 // |length| is the length of the frame to chop.
 // |num_chunks| is the number of chunks to create.
 MockRead* ChopReadFrame(const char* data, int length, int num_chunks) {
   MockRead* chunks = new MockRead[num_chunks];
   int chunk_size = length / num_chunks;
   for (int index = 0; index < num_chunks; index++) {
     const char* ptr = data + (index * chunk_size);
     if (index == num_chunks - 1)
       chunk_size += length % chunk_size;  // The last chunk takes the remainder.
     chunks[index] = MockRead(true, ptr, chunk_size);
   }
   return chunks;
 }
 
 // Chop a SpdyFrame into an array of MockReads.
 // |frame| is the frame to chop.
 // |num_chunks| is the number of chunks to create.
 MockRead* ChopReadFrame(const spdy::SpdyFrame& frame, int num_chunks) {
   return ChopReadFrame(frame.data(),
-                       frame.length() + spdy::SpdyFrame::size(),
+                       frame.length() + spdy::SpdyFrame::kHeaderSize,
                        num_chunks);
 }
 
 // Adds headers and values to a map.
 // |extra_headers| is an array of { name, value } pairs, arranged as strings
 // where the even entries are the header names, and the odd entries are the
 // header values.
 // |headers| gets filled in from |extra_headers|.
 void AppendHeadersToSpdyFrame(const char* const extra_headers[],
                               int extra_header_count,
@@ skipping 673 matching lines @@
   spdy::SpdyFramer framer;
   return framer.CreateDataFrame(
       stream_id, data, len, fin ? spdy::DATA_FLAG_FIN : spdy::DATA_FLAG_NONE);
 }
 
 // Wraps |frame| in the payload of a data frame in stream |stream_id|.
 spdy::SpdyFrame* ConstructWrappedSpdyFrame(
     const scoped_ptr<spdy::SpdyFrame>& frame,
     int stream_id) {
   return ConstructSpdyBodyFrame(stream_id, frame->data(),
-                                frame->length() + spdy::SpdyFrame::size(),
+                                frame->length() + spdy::SpdyFrame::kHeaderSize,
                                 false);
 }
 
 // Construct an expected SPDY reply string.
 // |extra_headers| are the extra header-value pairs, which typically
 // will vary the most between calls.
 // |buffer| is the buffer we're filling in.
 // Returns the number of bytes written into |buffer|.
 int ConstructSpdyReplyString(const char* const extra_headers[],
                              int extra_header_count,
@@ skipping 62 matching lines @@
                                   strlen("\n"),
                                   &buffer_write,
                                   &buffer_left);
   }
   return packet_size;
 }
 
 // Create a MockWrite from the given SpdyFrame.
 MockWrite CreateMockWrite(const spdy::SpdyFrame& req) {
   return MockWrite(
-      true, req.data(), req.length() + spdy::SpdyFrame::size());
+      true, req.data(), req.length() + spdy::SpdyFrame::kHeaderSize);
 }
 
 // Create a MockWrite from the given SpdyFrame and sequence number.
 MockWrite CreateMockWrite(const spdy::SpdyFrame& req, int seq) {
   return CreateMockWrite(req, seq, true);
 }
 
 // Create a MockWrite from the given SpdyFrame and sequence number.
 MockWrite CreateMockWrite(const spdy::SpdyFrame& req, int seq, bool async) {
   return MockWrite(
-      async, req.data(), req.length() + spdy::SpdyFrame::size(), seq);
+      async, req.data(), req.length() + spdy::SpdyFrame::kHeaderSize, seq);
 }
 
 // Create a MockRead from the given SpdyFrame.
 MockRead CreateMockRead(const spdy::SpdyFrame& resp) {
   return MockRead(
-      true, resp.data(), resp.length() + spdy::SpdyFrame::size());
+      true, resp.data(), resp.length() + spdy::SpdyFrame::kHeaderSize);
 }
 
 // Create a MockRead from the given SpdyFrame and sequence number.
 MockRead CreateMockRead(const spdy::SpdyFrame& resp, int seq) {
   return CreateMockRead(resp, seq, true);
 }
 
 // Create a MockRead from the given SpdyFrame and sequence number.
 MockRead CreateMockRead(const spdy::SpdyFrame& resp, int seq, bool async) {
   return MockRead(
-      async, resp.data(), resp.length() + spdy::SpdyFrame::size(), seq);
+      async, resp.data(), resp.length() + spdy::SpdyFrame::kHeaderSize, seq);
 }
 
 // Combines the given SpdyFrames into the given char array and returns
 // the total length.
 int CombineFrames(const spdy::SpdyFrame** frames, int num_frames,
                   char* buff, int buff_len) {
   int total_len = 0;
   for (int i = 0; i < num_frames; ++i) {
-    total_len += frames[i]->length() + spdy::SpdyFrame::size();
+    total_len += frames[i]->length() + spdy::SpdyFrame::kHeaderSize;
   }
   DCHECK_LE(total_len, buff_len);
   char* ptr = buff;
   for (int i = 0; i < num_frames; ++i) {
-    int len = frames[i]->length() + spdy::SpdyFrame::size();
+    int len = frames[i]->length() + spdy::SpdyFrame::kHeaderSize;
     memcpy(ptr, frames[i]->data(), len);
     ptr += len;
   }
   return total_len;
 }
 
 SpdySessionDependencies::SpdySessionDependencies()
     : host_resolver(new MockCachingHostResolver),
       cert_verifier(new CertVerifier),
       proxy_service(ProxyService::CreateDirect()),
@@ skipping 91 matching lines @@
     spdy::CONTROL_FLAG_FIN,       // Control Flags
     false,                        // Compressed
     spdy::INVALID,                // Status
     NULL,                         // Data
     0,                            // Length
     spdy::DATA_FLAG_NONE          // Data Flags
   };
   return kHeader;
 }
 }  // namespace net