Update version parameter format in SpdyAltSvcWireFormat.

net/spdy/spdy_alt_svc_wire_format.cc

 // Copyright (c) 2015 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_alt_svc_wire_format.h"
 
 #include <limits>
 #include <string>
 
 #include "base/logging.h"
@@ skipping 22 matching lines @@
 }
 
 }  // namespace
 
 SpdyAltSvcWireFormat::AlternativeService::AlternativeService() {}
 
 SpdyAltSvcWireFormat::AlternativeService::AlternativeService(
     const std::string& protocol_id,
     const std::string& host,
     uint16 port,
-    uint16 version,
     uint32 max_age,
-    double probability)
+    double probability,
+    VersionVector version)
     : protocol_id(protocol_id),
       host(host),
       port(port),
-      version(version),
       max_age(max_age),
-      probability(probability) {}
+      probability(probability),
+      version(version) {}
+
+SpdyAltSvcWireFormat::AlternativeService::~AlternativeService() {}
 
 // static
 bool SpdyAltSvcWireFormat::ParseHeaderFieldValue(
     StringPiece value,
     AlternativeServiceVector* altsvc_vector) {
   // Empty value is invalid according to the specification.
   if (value.empty()) {
     return false;
   }
   altsvc_vector->clear();
@@ skipping 36 matching lines @@
       return false;
     }
     DCHECK_EQ('"', *c);
     std::string host;
     uint16 port;
     if (!ParseAltAuthority(alt_authority_begin, c, &host, &port)) {
       return false;
     }
     ++c;
     // Parse parameters.
-    uint16 version = 0;
     uint32 max_age = 86400;
     double probability = 1.0;
+    VersionVector version;
     StringPiece::const_iterator parameters_end = std::find(c, value.end(), ',');
     while (c != parameters_end) {
       SkipWhiteSpace(&c, parameters_end);
       if (c == parameters_end) {
         break;
       }
       if (*c != ';') {
         return false;
       }
       ++c;
@@ skipping 10 matching lines @@
         return false;
       }
       ++c;
       SkipWhiteSpace(&c, parameters_end);
       StringPiece::const_iterator parameter_value_begin = c;
       for (; c != parameters_end && *c != ';' && *c != ' ' && *c != '\t'; ++c) {
       }
       if (c == parameter_value_begin) {
         return false;
       }
-      if (parameter_name.compare("v") == 0) {
-        if (!ParsePositiveInteger16(parameter_value_begin, c, &version)) {
-          return false;
-        }
-      } else if (parameter_name.compare("ma") == 0) {
+      if (parameter_name.compare("ma") == 0) {
         if (!ParsePositiveInteger32(parameter_value_begin, c, &max_age)) {
           return false;
         }
       } else if (parameter_name.compare("p") == 0) {
         // Probability value is enclosed in quotation marks.
         if (*parameter_value_begin != '"' || *(c - 1) != '"') {
           return false;
         }
         if (!ParseProbability(parameter_value_begin + 1, c - 1, &probability)) {
           return false;
         }
+      } else if (parameter_name.compare("v") == 0) {
+        // Version is a comma separated list of positive integers enclosed in
+        // quotation marks.  Since it can contain commas, which are not
+        // delineating alternative service entries, |parameters_end| and |c| can
+        // be invalid.
+        if (*parameter_value_begin != '"') {
+          return false;
+        }
+        c = std::find(parameter_value_begin + 1, value.end(), '"');
+        if (c == value.end()) {
+          return false;
+        }
+        ++c;
+        parameters_end = std::find(c, value.end(), ',');
+        StringPiece::const_iterator v_begin = parameter_value_begin + 1;
+        while (v_begin < c) {
+          StringPiece::const_iterator v_end = v_begin;
+          while (v_end < c - 1 && *v_end != ',') {
+            ++v_end;
+          }
+          uint16 v;
+          if (!ParsePositiveInteger16(v_begin, v_end, &v)) {
+            return false;
+          }
+          version.push_back(v);
+          v_begin = v_end + 1;
+          if (v_begin == c - 1) {
+            // List ends in comma.
+            return false;
+          }
+        }
       }
     }
     altsvc_vector->push_back(AlternativeService(protocol_id, host, port,
-                                                version, max_age, probability));
+                                                max_age, probability, version));
     for (; c != value.end() && (*c == ' ' || *c == '\t' || *c == ','); ++c) {
     }
   }
   return true;
 }
 
 // static
 std::string SpdyAltSvcWireFormat::SerializeHeaderFieldValue(
     const AlternativeServiceVector& altsvc_vector) {
   if (altsvc_vector.empty()) {
@@ skipping 39 matching lines @@
     }
     value.push_back('=');
     value.push_back('"');
     for (char c : altsvc.host) {
       if (c == '"' || c == '\\') {
         value.push_back('\\');
       }
       value.push_back(c);
     }
     base::StringAppendF(&value, ":%d\"", altsvc.port);
-    if (altsvc.version != 0) {
-      base::StringAppendF(&value, "; v=%d", altsvc.version);
-    }
     if (altsvc.max_age != 86400) {
       base::StringAppendF(&value, "; ma=%d", altsvc.max_age);
     }
     if (altsvc.probability != 1.0) {
       base::StringAppendF(&value, "; p=\"%.2f\"", altsvc.probability);
     }
+    if (!altsvc.version.empty()) {
+      value.append("; v=\"");
+      for (VersionVector::const_iterator it = altsvc.version.begin();
+           it != altsvc.version.end(); ++it) {
+        if (it != altsvc.version.begin()) {
+          value.append(",");
+        }
+        base::StringAppendF(&value, "%d", *it);
+      }
+      value.append("\"");
+    }
   }
   return value;
 }
 
 // static
 void SpdyAltSvcWireFormat::SkipWhiteSpace(StringPiece::const_iterator* c,
                                           StringPiece::const_iterator end) {
   for (; *c != end && (**c == ' ' || **c == '\t'); ++*c) {
   }
 }
@@ skipping 108 matching lines @@
   ++c;
   double place_value = 0.1;
   for (; c != end && isdigit(*c); ++c) {
     *probability += place_value * (*c - '0');
     place_value *= 0.1;
   }
   return (c == end && *probability <= 1.0);
 }
 
 }  // namespace net