Use struct AlternativeService in OnAltSvc() and OnSpdyAltSvc() methods.

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 18 matching lines @@
     }
     *value += *c - '0';
   }
   return (c == end && *value > 0);
 }
 
 }  // namespace
 
 // static
 bool SpdyAltSvcWireFormat::ParseHeaderFieldValue(StringPiece value,
-                                                 std::string* protocol_id,
-                                                 std::string* host,
-                                                 uint16* port,
-                                                 uint32* max_age,
-                                                 double* p) {
-  *max_age = 86400;
-  *p = 1.0;
+                                                 AlternativeService* altsvc) {
+  altsvc->max_age = 86400;
+  altsvc->p = 1.0;
 
   StringPiece::const_iterator c = value.begin();
   StringPiece::const_iterator percent_encoded_protocol_id_end =
       std::find(c, value.end(), '=');
   if (percent_encoded_protocol_id_end == c ||
-      !PercentDecode(c, percent_encoded_protocol_id_end, protocol_id)) {
+      !PercentDecode(c, percent_encoded_protocol_id_end,
+                     &(altsvc->protocol_id))) {
     return false;
   }
   c = percent_encoded_protocol_id_end;
   if (c == value.end()) {
     return false;
   }
   DCHECK_EQ('=', *c);
   ++c;
   if (c == value.end() || *c != '"') {
     return false;
   }
   ++c;
   StringPiece::const_iterator alt_authority_begin = c;
   for (; c != value.end() && *c != '"'; ++c) {
     // Decode backslash encoding.
     if (*c != '\\') {
       continue;
     }
     ++c;
     if (c == value.end()) {
       return false;
     }
   }
   if (c == alt_authority_begin || c == value.end()) {
     return false;
   }
   DCHECK_EQ('"', *c);
-  if (!ParseAltAuthority(alt_authority_begin, c, host, port)) {
+  if (!ParseAltAuthority(alt_authority_begin, c, &(altsvc->host),
+                         &(altsvc->port))) {
     return false;
   }
   ++c;
   StringPiece::const_iterator parameters_end = std::find(c, value.end(), ',');
   while (c != parameters_end) {
     SkipWhiteSpace(&c, parameters_end);
     if (c == parameters_end) {
       return true;
     }
     if (*c != ';') {
@@ skipping 14 matching lines @@
     }
     ++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("ma") == 0) {
-      if (!ParsePositiveInteger32(parameter_value_begin, c, max_age)) {
+      if (!ParsePositiveInteger32(parameter_value_begin, c,
+                                  &(altsvc->max_age))) {
         return false;
       }
     } else if (parameter_name.compare("p") == 0) {
-      if (!ParseProbability(parameter_value_begin, c, p)) {
+      if (!ParseProbability(parameter_value_begin, c, &(altsvc->p))) {
         return false;
       }
     }
     SkipWhiteSpace(&c, parameters_end);
   }
   // TODO(bnc): Parse additional alternative services delimited by ','.
   return true;
 }
 
 // static
 std::string SpdyAltSvcWireFormat::SerializeHeaderFieldValue(
-    const std::string& protocol_id,
-    const std::string& host,
-    uint16 port,
-    uint32 max_age,
-    double p) {
+    const AlternativeService& altsvc) {
   const char kNibbleToHex[] = "0123456789ABCDEF";
   std::string value;
   // Percent escape protocol id according to
   // http://tools.ietf.org/html/rfc7230#section-3.2.6.
-  for (char c : protocol_id) {
+  for (char c : altsvc.protocol_id) {
     if (isalnum(c)) {
       value.push_back(c);
       continue;
     }
     switch (c) {
       case '!':
       case '#':
       case '$':
       case '&':
       case '\'':
@@ skipping 11 matching lines @@
       default:
         value.push_back('%');
         // Network byte order is big-endian.
         value.push_back(kNibbleToHex[c >> 4]);
         value.push_back(kNibbleToHex[c & 0x0f]);
         break;
     }
   }
   value.push_back('=');
   value.push_back('"');
-  for (char c : host) {
+  for (char c : altsvc.host) {
     if (c == '"' || c == '\\') {
       value.push_back('\\');
     }
     value.push_back(c);
   }
-  base::StringAppendF(&value, ":%d\"", port);
-  if (max_age != 86400) {
-    base::StringAppendF(&value, "; ma=%d", max_age);
+  base::StringAppendF(&value, ":%d\"", altsvc.port);
+  if (altsvc.max_age != 86400) {
+    base::StringAppendF(&value, "; ma=%d", altsvc.max_age);
   }
-  if (p != 1.0) {
-    base::StringAppendF(&value, "; p=%.2f", p);
+  if (altsvc.p != 1.0) {
+    base::StringAppendF(&value, "; p=%.2f", altsvc.p);
   }
   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) {
     *p += place_value * (*c - '0');
     place_value *= 0.1;
   }
   return (c == end && *p <= 1.0);
 }
 
 }  // namespace net