Add settings IDs to SpdyConstants.

net/spdy/spdy_framer.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.
 
 // 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 72 matching lines @@
 SettingsFlagsAndId SettingsFlagsAndId::FromWireFormat(int version,
                                                       uint32 wire) {
   if (version < 3) {
     ConvertFlagsAndIdForSpdy2(&wire);
   }
   return SettingsFlagsAndId(ntohl(wire) >> 24, ntohl(wire) & 0x00ffffff);
 }
 
 SettingsFlagsAndId::SettingsFlagsAndId(uint8 flags, uint32 id)
     : flags_(flags), id_(id & 0x00ffffff) {
-  LOG_IF(DFATAL, id > (1u << 24)) << "SPDY setting ID too large.";
+  LOG_IF(DFATAL, id > (1u << 24)) << "SPDY setting ID too large: " << id;
 }
 
 uint32 SettingsFlagsAndId::GetWireFormat(int version) const {
   uint32 wire = htonl(id_ & 0x00ffffff) | htonl(flags_ << 24);
   if (version < 3) {
     ConvertFlagsAndIdForSpdy2(&wire);
   }
   return wire;
 }
 
@@ skipping 1496 matching lines @@
       GetSerializedLength(protocol_version(), &block));
 
   SerializeNameValueBlockWithoutCompression(&builder, block);
   scoped_ptr<SpdyFrame> frame(builder.take());
 
   remaining_data_length_ = frame->size();
   ProcessControlFrameHeaderBlock(frame->data(), frame->size(), false);
 }
 
 bool SpdyFramer::ProcessSetting(const char* data) {
+  int id_field;
   SpdySettingsIds id;
   uint8 flags = 0;
   uint32 value;
 
   // Extract fields.
   // Maintain behavior of old SPDY 2 bug with byte ordering of flags/id.
   if (protocol_version() <= SPDY3) {
     const uint32 id_and_flags_wire = *(reinterpret_cast<const uint32*>(data));
     SettingsFlagsAndId id_and_flags =
       SettingsFlagsAndId::FromWireFormat(protocol_version(), id_and_flags_wire);
-    id = static_cast<SpdySettingsIds>(id_and_flags.id());
+    id_field = id_and_flags.id();
     flags = id_and_flags.flags();
     value = ntohl(*(reinterpret_cast<const uint32*>(data + 4)));
   } else {
-    id = static_cast<SpdySettingsIds>(*(reinterpret_cast<const uint8*>(data)));
+    id_field = *(reinterpret_cast<const uint8*>(data));
     value = ntohl(*(reinterpret_cast<const uint32*>(data + 1)));
   }
 
   // Validate id.
-  switch (id) {
-    case SETTINGS_UPLOAD_BANDWIDTH:
-    case SETTINGS_DOWNLOAD_BANDWIDTH:
-    case SETTINGS_ROUND_TRIP_TIME:
-    case SETTINGS_MAX_CONCURRENT_STREAMS:
-    case SETTINGS_CURRENT_CWND:
-    case SETTINGS_DOWNLOAD_RETRANS_RATE:
-    case SETTINGS_INITIAL_WINDOW_SIZE:
-      // Valid values.
-      break;
-    default:
-      DLOG(WARNING) << "Unknown SETTINGS ID: " << id;
-      return false;
+  if (!SpdyConstants::IsValidSettingId(protocol_version(), id_field)) {
+    DLOG(WARNING) << "Unknown SETTINGS ID: " << id_field;
+    return false;
   }
+  id = SpdyConstants::ParseSettingId(protocol_version(), id_field);
 
   if (protocol_version() <= SPDY3) {
     // Detect duplicates.
-    if (static_cast<uint32>(id) <= settings_scratch_.last_setting_id) {
+    if (id <= settings_scratch_.last_setting_id) {
       DLOG(WARNING) << "Duplicate entry or invalid ordering for id " << id
                     << " in " << display_protocol_ << " SETTINGS frame "
                     << "(last setting id was "
                     << settings_scratch_.last_setting_id << ").";
       return false;
     }
     settings_scratch_.last_setting_id = id;
 
     // Validate flags.
     uint8 kFlagsMask = SETTINGS_FLAG_PLEASE_PERSIST | SETTINGS_FLAG_PERSISTED;
@@ skipping 630 matching lines @@
        it != values->end();
        ++it) {
     if (protocol_version() <= SPDY3) {
       uint8 setting_flags = 0;
       if (it->second.persist_value) {
         setting_flags |= SETTINGS_FLAG_PLEASE_PERSIST;
       }
       if (it->second.persisted) {
         setting_flags |= SETTINGS_FLAG_PERSISTED;
       }
-      SettingsFlagsAndId flags_and_id(setting_flags, it->first);
+      SettingsFlagsAndId flags_and_id(
+          setting_flags,
+          SpdyConstants::SerializeSettingId(protocol_version(), it->first));
       uint32 id_and_flags_wire = flags_and_id.GetWireFormat(protocol_version());
       builder.WriteBytes(&id_and_flags_wire, 4);
     } else {
-      builder.WriteUInt8(static_cast<uint8>(it->first));
+      builder.WriteUInt8(SpdyConstants::SerializeSettingId(protocol_version(),
+                                                           it->first));
     }
     builder.WriteUInt32(it->second.value);
   }
   DCHECK_EQ(size, builder.length());
   return builder.take();
 }
 
 SpdyFrame* SpdyFramer::SerializeBlocked(const SpdyBlockedIR& blocked) const {
   DCHECK_LT(SPDY3, protocol_version());
   SpdyFrameBuilder builder(GetBlockedSize());
@@ skipping 534 matching lines @@
   builder->Seek(compressed_size);
   builder->RewriteLength(*this);
 
   pre_compress_bytes.Add(uncompressed_len);
   post_compress_bytes.Add(compressed_size);
 
   compressed_frames.Increment();
 }
 
 }  // namespace net