Update version parameter format in SpdyAltSvcWireFormat.

net/spdy/spdy_alt_svc_wire_format_test.cc

Index: net/spdy/spdy_alt_svc_wire_format_test.cc
diff --git a/net/spdy/spdy_alt_svc_wire_format_test.cc b/net/spdy/spdy_alt_svc_wire_format_test.cc
index b32f0de270a120e67b9d8a5a5531926f480af012..d69e4d6bffd3c29fcd9fa0d1701c2afe5b15a5e2 100644
--- a/net/spdy/spdy_alt_svc_wire_format_test.cc
+++ b/net/spdy/spdy_alt_svc_wire_format_test.cc
@@ -94,16 +94,16 @@ void FuzzHeaderFieldValue(
   }
   if (i & 1 << 6) {
     expected_altsvc->probability = 0.0;
-    expected_altsvc->version = 24;
-    header_field_value->append("; p=\"0\";v=24");
+    expected_altsvc->version.push_back(24);
+    header_field_value->append("; p=\"0\";v=\"24\"");
   }
   if (i & 1 << 7) {
     expected_altsvc->max_age = 999999999;
     header_field_value->append("; Ma=999999999");
   }
   if (i & 1 << 8) {
-    expected_altsvc->probability = 0.0;
-    header_field_value->append("; P=\"0.\"");
+    expected_altsvc->probability = 0.1;
+    header_field_value->append("; P=\"0.1\"");
   }
   if (i & 1 << 9) {
     header_field_value->append(";");
@@ -136,17 +136,18 @@ void FuzzAlternativeService(int i,
   }
   expected_header_field_value->append(":42\"");
   if (i & 1 << 1) {
-    altsvc->version = 24;
-    expected_header_field_value->append("; v=24");
-  }
-  if (i & 1 << 2) {
     altsvc->max_age = 1111;
     expected_header_field_value->append("; ma=1111");
   }
-  if (i & 1 << 3) {
+  if (i & 1 << 2) {
     altsvc->probability = 0.33;
     expected_header_field_value->append("; p=\"0.33\"");
   }
+  if (i & 1 << 3) {
+    altsvc->version.push_back(24);
+    altsvc->version.push_back(25);
+    expected_header_field_value->append("; v=\"24,25\"");
+  }
 }
 
 class SpdyAltSvcWireFormatTest : public ::testing::Test {};
@@ -158,9 +159,9 @@ TEST(SpdyAltSvcWireFormatTest, DefaultValues) {
   EXPECT_EQ("", altsvc.protocol_id);
   EXPECT_EQ("", altsvc.host);
   EXPECT_EQ(0u, altsvc.port);
-  EXPECT_EQ(0u, altsvc.version);
   EXPECT_EQ(86400u, altsvc.max_age);
   EXPECT_DOUBLE_EQ(1.0, altsvc.probability);
+  EXPECT_TRUE(altsvc.version.empty());
 }
 
 TEST(SpdyAltSvcWireFormatTest, ParseInvalidEmptyHeaderFieldValue) {
@@ -190,9 +191,9 @@ TEST(SpdyAltSvcWireFormatTest, ParseHeaderFieldValue) {
     EXPECT_EQ(expected_altsvc.protocol_id, altsvc_vector[0].protocol_id);
     EXPECT_EQ(expected_altsvc.host, altsvc_vector[0].host);
     EXPECT_EQ(expected_altsvc.port, altsvc_vector[0].port);
-    EXPECT_EQ(expected_altsvc.version, altsvc_vector[0].version);
     EXPECT_EQ(expected_altsvc.max_age, altsvc_vector[0].max_age);
     EXPECT_DOUBLE_EQ(expected_altsvc.probability, altsvc_vector[0].probability);
+    EXPECT_EQ(expected_altsvc.version, altsvc_vector[0].version);
 
     // Roundtrip test starting with |altsvc_vector|.
     std::string reserialized_header_field_value =
@@ -205,10 +206,10 @@ TEST(SpdyAltSvcWireFormatTest, ParseHeaderFieldValue) {
               roundtrip_altsvc_vector[0].protocol_id);
     EXPECT_EQ(expected_altsvc.host, roundtrip_altsvc_vector[0].host);
     EXPECT_EQ(expected_altsvc.port, roundtrip_altsvc_vector[0].port);
-    EXPECT_EQ(expected_altsvc.version, roundtrip_altsvc_vector[0].version);
     EXPECT_EQ(expected_altsvc.max_age, roundtrip_altsvc_vector[0].max_age);
     EXPECT_DOUBLE_EQ(expected_altsvc.probability,
                      roundtrip_altsvc_vector[0].probability);
+    EXPECT_EQ(expected_altsvc.version, roundtrip_altsvc_vector[0].version);
   }
 }
 
@@ -237,10 +238,10 @@ TEST(SpdyAltSvcWireFormatTest, ParseHeaderFieldValueMultiple) {
                 altsvc_vector[j].protocol_id);
       EXPECT_EQ(expected_altsvc_vector[j].host, altsvc_vector[j].host);
       EXPECT_EQ(expected_altsvc_vector[j].port, altsvc_vector[j].port);
-      EXPECT_EQ(expected_altsvc_vector[j].version, altsvc_vector[j].version);
       EXPECT_EQ(expected_altsvc_vector[j].max_age, altsvc_vector[j].max_age);
       EXPECT_DOUBLE_EQ(expected_altsvc_vector[j].probability,
                        altsvc_vector[j].probability);
+      EXPECT_EQ(expected_altsvc_vector[j].version, altsvc_vector[j].version);
     }
 
     // Roundtrip test starting with |altsvc_vector|.
@@ -257,12 +258,12 @@ TEST(SpdyAltSvcWireFormatTest, ParseHeaderFieldValueMultiple) {
                 roundtrip_altsvc_vector[j].host);
       EXPECT_EQ(expected_altsvc_vector[j].port,
                 roundtrip_altsvc_vector[j].port);
-      EXPECT_EQ(expected_altsvc_vector[j].version,
-                roundtrip_altsvc_vector[j].version);
       EXPECT_EQ(expected_altsvc_vector[j].max_age,
                 roundtrip_altsvc_vector[j].max_age);
       EXPECT_DOUBLE_EQ(expected_altsvc_vector[j].probability,
                        roundtrip_altsvc_vector[j].probability);
+      EXPECT_EQ(expected_altsvc_vector[j].version,
+                roundtrip_altsvc_vector[j].version);
     }
   }
 }
@@ -291,9 +292,9 @@ TEST(SpdyAltSvcWireFormatTest, RoundTrip) {
     EXPECT_EQ(altsvc.protocol_id, parsed_altsvc_vector[0].protocol_id);
     EXPECT_EQ(altsvc.host, parsed_altsvc_vector[0].host);
     EXPECT_EQ(altsvc.port, parsed_altsvc_vector[0].port);
-    EXPECT_EQ(altsvc.version, parsed_altsvc_vector[0].version);
     EXPECT_EQ(altsvc.max_age, parsed_altsvc_vector[0].max_age);
     EXPECT_DOUBLE_EQ(altsvc.probability, parsed_altsvc_vector[0].probability);
+    EXPECT_EQ(altsvc.version, parsed_altsvc_vector[0].version);
 
     // Test SerializeHeaderFieldValue().
     SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
@@ -329,9 +330,9 @@ TEST(SpdyAltSvcWireFormatTest, RoundTripMultiple) {
     EXPECT_EQ(expected_it->protocol_id, parsed_it->protocol_id);
     EXPECT_EQ(expected_it->host, parsed_it->host);
     EXPECT_EQ(expected_it->port, parsed_it->port);
-    EXPECT_EQ(expected_it->version, parsed_it->version);
     EXPECT_EQ(expected_it->max_age, parsed_it->max_age);
     EXPECT_DOUBLE_EQ(expected_it->probability, parsed_it->probability);
+    EXPECT_EQ(expected_it->version, parsed_it->version);
   }
 
   // Test SerializeHeaderFieldValue().
@@ -350,7 +351,9 @@ TEST(SpdyAltSvcWireFormatTest, ParseHeaderFieldValueInvalid) {
       "a=\"b:42\" ; min-age", "a=\"b:42\" ; ma", "a=\"b:42\" ; ma=",
       "a=\"b:42\" ; ma=ma", "a=\"b:42\" ; ma=123bar", "a=\"b:42\" ; p=\"-2\"",
       "a=\"b:42\" ; p=\"..\"", "a=\"b:42\" ; p=\"1.05\"", "a=\"b:42\" ; p=0.4",
-      "a=\"b:42\" ; p=\" 1.0\"", "a=\"b:42\" ; v=-3", "a=\"b:42\" ; v=1.2"};
+      "a=\"b:42\" ; p=\" 1.0\"", "a=\"b:42\" ; v=24", "a=\"b:42\" ; v=24,25",
+      "a=\"b:42\" ; v=\"-3\"", "a=\"b:42\" ; v=\"1.2\"",
+      "a=\"b:42\" ; v=\"24,\""};
   for (const char* invalid_field_value : invalid_field_value_array) {
     EXPECT_FALSE(SpdyAltSvcWireFormat::ParseHeaderFieldValue(
         invalid_field_value, &altsvc_vector))