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

net/spdy/spdy_framer.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.
 
 // TODO(rtenhove) clean up frame buffer size calculations so that we aren't
 // constantly adding and subtracting header sizes; this is ugly and error-
 // prone.
 
 #include "net/spdy/spdy_framer.h"
 
@@ skipping 340 matching lines @@
 
 size_t SpdyFramer::ProcessCommonHeader(const char* data, size_t len) {
   // This should only be called when we're in the SPDY_READING_COMMON_HEADER
   // state.
   DCHECK_EQ(state_, SPDY_READING_COMMON_HEADER);
 
   size_t original_len = len;
   SpdyFrame current_frame(current_frame_buffer_, false);
 
   do {
-    if (current_frame_len_ < SpdyFrame::size()) {
-      size_t bytes_desired = SpdyFrame::size() - current_frame_len_;
+    if (current_frame_len_ < SpdyFrame::kHeaderSize) {
+      size_t bytes_desired = SpdyFrame::kHeaderSize - current_frame_len_;
       UpdateCurrentFrameBuffer(&data, &len, bytes_desired);
       // Check for an empty data frame.
-      if (current_frame_len_ == SpdyFrame::size() &&
+      if (current_frame_len_ == SpdyFrame::kHeaderSize &&
           !current_frame.is_control_frame() &&
           current_frame.length() == 0) {
         if (current_frame.flags() & CONTROL_FLAG_FIN) {
           SpdyDataFrame data_frame(current_frame_buffer_, false);
           visitor_->OnStreamFrameData(data_frame.stream_id(), NULL, 0);
         }
         CHANGE_STATE(SPDY_AUTO_RESET);
       }
       break;
     }
@@ skipping 10 matching lines @@
       CHANGE_STATE(SPDY_FORWARD_STREAM_FRAME);
     else
       CHANGE_STATE(SPDY_INTERPRET_CONTROL_FRAME_COMMON_HEADER);
   } while (false);
 
   return original_len - len;
 }
 
 void SpdyFramer::ProcessControlFrameHeader() {
   DCHECK_EQ(SPDY_NO_ERROR, error_code_);
-  DCHECK_LE(SpdyFrame::size(), current_frame_len_);
+  DCHECK_LE(static_cast<size_t>(SpdyFrame::kHeaderSize), current_frame_len_);
   SpdyControlFrame current_control_frame(current_frame_buffer_, false);
 
   // We check version before we check validity: version can never be 'invalid',
   // it can only be unsupported.
   if (current_control_frame.version() != spdy_version_) {
     set_error(SPDY_UNSUPPORTED_VERSION);
     return;
   }
 
   // Next up, check to see if we have valid data.  This should be after version
@@ skipping 19 matching lines @@
             SpdySynStreamControlFrame::size() - SpdyControlFrame::size())
           set_error(SPDY_INVALID_CONTROL_FRAME);
         break;
       case SYN_REPLY:
         if (current_control_frame.length() <
             SpdySynReplyControlFrame::size() - SpdyControlFrame::size())
           set_error(SPDY_INVALID_CONTROL_FRAME);
         break;
       case RST_STREAM:
         if (current_control_frame.length() !=
-            SpdyRstStreamControlFrame::size() - SpdyFrame::size())
+            SpdyRstStreamControlFrame::size() - SpdyFrame::kHeaderSize)
           set_error(SPDY_INVALID_CONTROL_FRAME);
         break;
       case SETTINGS:
         if (current_control_frame.length() <
             SpdySettingsControlFrame::size() - SpdyControlFrame::size())
           set_error(SPDY_INVALID_CONTROL_FRAME);
         break;
       case GOAWAY:
         if (current_control_frame.length() !=
-            SpdyGoAwayControlFrame::size() - SpdyFrame::size())
+            SpdyGoAwayControlFrame::size() - SpdyFrame::kHeaderSize)
           set_error(SPDY_INVALID_CONTROL_FRAME);
         break;
       case HEADERS:
         if (current_control_frame.length() <
             SpdyHeadersControlFrame::size() - SpdyControlFrame::size())
           set_error(SPDY_INVALID_CONTROL_FRAME);
         break;
       case WINDOW_UPDATE:
         if (current_control_frame.length() !=
             SpdyWindowUpdateControlFrame::size() - SpdyControlFrame::size())
@@ skipping 247 matching lines @@
       visitor_->OnStreamFrameData(current_data_frame.stream_id(), NULL, 0);
       CleanupDecompressorForStream(current_data_frame.stream_id());
     }
   } else {
     CHANGE_STATE(SPDY_AUTO_RESET);
   }
   return original_len - len;
 }
 
 void SpdyFramer::ExpandControlFrameBuffer(size_t size) {
-  size_t alloc_size = size + SpdyFrame::size();
+  size_t alloc_size = size + SpdyFrame::kHeaderSize;
   DCHECK_LE(alloc_size, kControlFrameBufferMaxSize);
   if (alloc_size <= current_frame_capacity_)
     return;
   char* new_buffer = new char[alloc_size];
   memcpy(new_buffer, current_frame_buffer_, current_frame_len_);
   delete [] current_frame_buffer_;
   current_frame_capacity_ = alloc_size;
   current_frame_buffer_ = new_buffer;
 }
 
@@ skipping 115 matching lines @@
   DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
   DCHECK_EQ(0u, associated_stream_id & ~kStreamIdMask);
 
   // Find our length.
   size_t expected_frame_size = SpdySynStreamControlFrame::size() +
                                GetSerializedLength(headers);
 
   // Create our FlagsAndLength.
   FlagsAndLength flags_length = CreateFlagsAndLength(
       flags,
-      expected_frame_size - SpdyFrame::size());
+      expected_frame_size - SpdyFrame::kHeaderSize);
 
   SpdyFrameBuilder frame(expected_frame_size);
   frame.WriteUInt16(kControlFlagMask | spdy_version_);
   frame.WriteUInt16(SYN_STREAM);
   frame.WriteBytes(&flags_length, sizeof(flags_length));
   frame.WriteUInt32(stream_id);
   frame.WriteUInt32(associated_stream_id);
   frame.WriteUInt16(ntohs(priority) << 6);  // Priority.
   WriteHeaderBlock(&frame, headers);
 
@@ skipping 11 matching lines @@
   DCHECK_GT(stream_id, 0u);
   DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
 
   // Find our length.
   size_t expected_frame_size = SpdySynReplyControlFrame::size() +
                                GetSerializedLength(headers);
 
   // Create our FlagsAndLength.
   FlagsAndLength flags_length = CreateFlagsAndLength(
       flags,
-      expected_frame_size - SpdyFrame::size());
+      expected_frame_size - SpdyFrame::kHeaderSize);
 
   SpdyFrameBuilder frame(expected_frame_size);
   frame.WriteUInt16(kControlFlagMask | spdy_version_);
   frame.WriteUInt16(SYN_REPLY);
   frame.WriteBytes(&flags_length, sizeof(flags_length));
   frame.WriteUInt32(stream_id);
   frame.WriteUInt16(0);  // Unused
   WriteHeaderBlock(&frame, headers);
 
   scoped_ptr<SpdySynReplyControlFrame> reply_frame(
@@ skipping 21 matching lines @@
   frame.WriteUInt32(status);
   return reinterpret_cast<SpdyRstStreamControlFrame*>(frame.take());
 }
 
 /* static */
 SpdySettingsControlFrame* SpdyFramer::CreateSettings(
     const SpdySettings& values) {
   SpdyFrameBuilder frame(SpdySettingsControlFrame::size() + 8 * values.size());
   frame.WriteUInt16(kControlFlagMask | spdy_version_);
   frame.WriteUInt16(SETTINGS);
-  size_t settings_size = SpdySettingsControlFrame::size() - SpdyFrame::size() +
+  size_t settings_size =
+      SpdySettingsControlFrame::size() - SpdyFrame::kHeaderSize +
       8 * values.size();
   frame.WriteUInt32(settings_size);
   frame.WriteUInt32(values.size());
   SpdySettings::const_iterator it = values.begin();
   while (it != values.end()) {
     frame.WriteUInt32(it->first.id_);
     frame.WriteUInt32(it->second);
     ++it;
   }
   return reinterpret_cast<SpdySettingsControlFrame*>(frame.take());
 }
 
 /* static */
 SpdyNoOpControlFrame* SpdyFramer::CreateNopFrame() {
   SpdyFrameBuilder frame(SpdyNoOpControlFrame::size());
   frame.WriteUInt16(kControlFlagMask | spdy_version_);
   frame.WriteUInt16(NOOP);
   frame.WriteUInt32(0);
   return reinterpret_cast<SpdyNoOpControlFrame*>(frame.take());
 }
 
 /* static */
 SpdyPingControlFrame* SpdyFramer::CreatePingFrame(uint32 unique_id) {
   SpdyFrameBuilder frame(SpdyPingControlFrame::size());
   frame.WriteUInt16(kControlFlagMask | spdy_version_);
   frame.WriteUInt16(PING);
-  size_t ping_size = SpdyPingControlFrame::size() - SpdyFrame::size();
+  size_t ping_size = SpdyPingControlFrame::size() - SpdyFrame::kHeaderSize;
   frame.WriteUInt32(ping_size);
   frame.WriteUInt32(unique_id);
   return reinterpret_cast<SpdyPingControlFrame*>(frame.take());
 }
 
 /* static */
 SpdyGoAwayControlFrame* SpdyFramer::CreateGoAway(
     SpdyStreamId last_accepted_stream_id) {
   DCHECK_EQ(0u, last_accepted_stream_id & ~kStreamIdMask);
 
   SpdyFrameBuilder frame(SpdyGoAwayControlFrame::size());
   frame.WriteUInt16(kControlFlagMask | spdy_version_);
   frame.WriteUInt16(GOAWAY);
-  size_t go_away_size = SpdyGoAwayControlFrame::size() - SpdyFrame::size();
+  size_t go_away_size = SpdyGoAwayControlFrame::size() - SpdyFrame::kHeaderSize;
   frame.WriteUInt32(go_away_size);
   frame.WriteUInt32(last_accepted_stream_id);
   return reinterpret_cast<SpdyGoAwayControlFrame*>(frame.take());
 }
 
 SpdyHeadersControlFrame* SpdyFramer::CreateHeaders(SpdyStreamId stream_id,
     SpdyControlFlags flags, bool compressed, const SpdyHeaderBlock* headers) {
   // Basically the same as CreateSynReply().
   DCHECK_GT(stream_id, 0u);
   DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
 
   // Find our length.
   size_t expected_frame_size = SpdyHeadersControlFrame::size() +
                                GetSerializedLength(headers);
 
   // Create our FlagsAndLength.
   FlagsAndLength flags_length = CreateFlagsAndLength(
       flags,
-      expected_frame_size - SpdyFrame::size());
+      expected_frame_size - SpdyFrame::kHeaderSize);
 
   SpdyFrameBuilder frame(expected_frame_size);
   frame.WriteUInt16(kControlFlagMask | spdy_version_);
   frame.WriteUInt16(HEADERS);
   frame.WriteBytes(&flags_length, sizeof(flags_length));
   frame.WriteUInt32(stream_id);
   frame.WriteUInt16(0);  // Unused
   WriteHeaderBlock(&frame, headers);
   DCHECK_EQ(static_cast<size_t>(frame.length()), expected_frame_size);
 
@@ skipping 12 matching lines @@
     uint32 delta_window_size) {
   DCHECK_GT(stream_id, 0u);
   DCHECK_EQ(0u, stream_id & ~kStreamIdMask);
   DCHECK_GT(delta_window_size, 0u);
   DCHECK_LE(delta_window_size, spdy::kSpdyStreamMaximumWindowSize);
 
   SpdyFrameBuilder frame(SpdyWindowUpdateControlFrame::size());
   frame.WriteUInt16(kControlFlagMask | spdy_version_);
   frame.WriteUInt16(WINDOW_UPDATE);
   size_t window_update_size = SpdyWindowUpdateControlFrame::size() -
-      SpdyFrame::size();
+      SpdyFrame::kHeaderSize;
   frame.WriteUInt32(window_update_size);
   frame.WriteUInt32(stream_id);
   frame.WriteUInt32(delta_window_size);
   return reinterpret_cast<SpdyWindowUpdateControlFrame*>(frame.take());
 }
 
 SpdyDataFrame* SpdyFramer::CreateDataFrame(SpdyStreamId stream_id,
                                            const char* data,
                                            uint32 len, SpdyDataFlags flags) {
   DCHECK_GT(stream_id, 0u);
@@ skipping 199 matching lines @@
           *payload_length = headers_frame.header_block_len();
           *header_length = frame_size;
           *payload = frame.data() + *header_length;
         }
         break;
       default:
         // TODO(mbelshe): set an error?
         return false;  // We can't compress this frame!
     }
   } else {
-    frame_size = SpdyFrame::size();
+    frame_size = SpdyFrame::kHeaderSize;
     *header_length = frame_size;
     *payload_length = frame.length();
-    *payload = frame.data() + SpdyFrame::size();
+    *payload = frame.data() + SpdyFrame::kHeaderSize;
   }
   return true;
 }
 
 SpdyControlFrame* SpdyFramer::CompressControlFrame(
     const SpdyControlFrame& frame) {
   z_stream* compressor = GetHeaderCompressor();
   if (!compressor)
     return NULL;
   return reinterpret_cast<SpdyControlFrame*>(
@@ skipping 38 matching lines @@
   if (!enable_compression_)
     return DuplicateFrame(frame);
 
   if (!GetFrameBoundaries(frame, &payload_length, &header_length, &payload))
     return NULL;
 
   // Create an output frame.
   int compressed_max_size = deflateBound(compressor, payload_length);
   int new_frame_size = header_length + compressed_max_size;
   scoped_ptr<SpdyFrame> new_frame(new SpdyFrame(new_frame_size));
-  memcpy(new_frame->data(), frame.data(), frame.length() + SpdyFrame::size());
+  memcpy(new_frame->data(), frame.data(),
+         frame.length() + SpdyFrame::kHeaderSize);
 
   compressor->next_in = reinterpret_cast<Bytef*>(const_cast<char*>(payload));
   compressor->avail_in = payload_length;
   compressor->next_out = reinterpret_cast<Bytef*>(new_frame->data()) +
                           header_length;
   compressor->avail_out = compressed_max_size;
 
   // Data packets have a 'compressed' flag.
   if (!new_frame->is_control_frame()) {
     SpdyDataFrame* data_frame =
@@ skipping 13 matching lines @@
     return NULL;
   }
 
   int compressed_size = compressed_max_size - compressor->avail_out;
 
   // We trust zlib. Also, we can't do anything about it.
   // See http://www.zlib.net/zlib_faq.html#faq36
   (void)VALGRIND_MAKE_MEM_DEFINED(new_frame->data() + header_length,
                                   compressed_size);
 
-  new_frame->set_length(header_length + compressed_size - SpdyFrame::size());
+  new_frame->set_length(
+      header_length + compressed_size - SpdyFrame::kHeaderSize);
 
   pre_compress_bytes.Add(payload_length);
   post_compress_bytes.Add(new_frame->length());
 
   compressed_frames.Increment();
 
   return new_frame.release();
 }
 
 SpdyFrame* SpdyFramer::DecompressFrameWithZStream(const SpdyFrame& frame,
@@ skipping 19 matching lines @@
       return DuplicateFrame(frame);
   }
 
   // Create an output frame.  Assume it does not need to be longer than
   // the input data.
   size_t decompressed_max_size = kControlFrameBufferInitialSize;
   int new_frame_size = header_length + decompressed_max_size;
   if (frame.length() > decompressed_max_size)
     return NULL;
   scoped_ptr<SpdyFrame> new_frame(new SpdyFrame(new_frame_size));
-  memcpy(new_frame->data(), frame.data(), frame.length() + SpdyFrame::size());
+  memcpy(new_frame->data(), frame.data(),
+         frame.length() + SpdyFrame::kHeaderSize);
 
   decompressor->next_in = reinterpret_cast<Bytef*>(const_cast<char*>(payload));
   decompressor->avail_in = payload_length;
   decompressor->next_out = reinterpret_cast<Bytef*>(new_frame->data()) +
       header_length;
   decompressor->avail_out = decompressed_max_size;
 
   int rv = inflate(decompressor, Z_SYNC_FLUSH);
   if (rv == Z_NEED_DICT) {
     // Need to try again with the right dictionary.
@@ skipping 11 matching lines @@
   }
 
   // Unset the compressed flag for data frames.
   if (!new_frame->is_control_frame()) {
     SpdyDataFrame* data_frame =
         reinterpret_cast<SpdyDataFrame*>(new_frame.get());
     data_frame->set_flags(data_frame->flags() & ~DATA_FLAG_COMPRESSED);
   }
 
   int decompressed_size = decompressed_max_size - decompressor->avail_out;
-  new_frame->set_length(header_length + decompressed_size - SpdyFrame::size());
+  new_frame->set_length(
+      header_length + decompressed_size - SpdyFrame::kHeaderSize);
 
   // If there is data left, then the frame didn't fully decompress.  This
   // means that there is stranded data at the end of this frame buffer which
   // will be ignored.
   DCHECK_EQ(decompressor->avail_in, 0u);
 
   pre_decompress_bytes.Add(frame.length());
   post_decompress_bytes.Add(new_frame->length());
 
   decompressed_frames.Increment();
@@ skipping 153 matching lines @@
   while (it != stream_decompressors_.end()) {
     z_stream* decompressor = it->second;
     inflateEnd(decompressor);
     delete decompressor;
     ++it;
   }
   stream_decompressors_.clear();
 }
 
 SpdyFrame* SpdyFramer::DuplicateFrame(const SpdyFrame& frame) {
-  int size = SpdyFrame::size() + frame.length();
+  int size = SpdyFrame::kHeaderSize + frame.length();
   SpdyFrame* new_frame = new SpdyFrame(size);
   memcpy(new_frame->data(), frame.data(), size);
   return new_frame;
 }
 
 size_t SpdyFramer::GetMinimumControlFrameSize(SpdyControlType type) {
   switch (type) {
     case SYN_STREAM:
       return SpdySynStreamControlFrame::size();
     case SYN_REPLY:
@@ skipping 61 matching lines @@
 }
 
 size_t SpdyFramer::BytesSafeToRead() const {
   switch (state_) {
     case SPDY_ERROR:
     case SPDY_DONE:
     case SPDY_AUTO_RESET:
     case SPDY_RESET:
       return 0;
     case SPDY_READING_COMMON_HEADER:
-      DCHECK_LT(current_frame_len_, SpdyFrame::size());
-      return SpdyFrame::size() - current_frame_len_;
+      DCHECK_LT(current_frame_len_,
+                static_cast<size_t>(SpdyFrame::kHeaderSize));
+      return SpdyFrame::kHeaderSize - current_frame_len_;
     case SPDY_INTERPRET_CONTROL_FRAME_COMMON_HEADER:
       return 0;
     // TODO(rtenneti): Add support for SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK
     // and SPDY_CONTROL_FRAME_HEADER_BLOCK.
     case SPDY_CONTROL_FRAME_BEFORE_HEADER_BLOCK:
     case SPDY_CONTROL_FRAME_HEADER_BLOCK:
       return 0;
     case SPDY_CONTROL_FRAME_PAYLOAD:
     case SPDY_IGNORE_REMAINING_PAYLOAD:
     case SPDY_FORWARD_STREAM_FRAME:
       return remaining_data_;
   }
   // We should never get to here.
   return 0;
 }
 
 void SpdyFramer::set_enable_compression(bool value) {
   enable_compression_ = value;
 }
 
 void SpdyFramer::set_enable_compression_default(bool value) {
   compression_default_ = value;
 }
 
 void SpdyFramer::set_validate_control_frame_sizes(bool value) {
   validate_control_frame_sizes_ = value;
 }
 
 }  // namespace spdy