Update from https://crrev.com/304121

net/quic/quic_utils.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.
 
 #include "net/quic/quic_utils.h"
 
 #include <ctype.h>
 
 #include <algorithm>
+#include <vector>
 
 #include "base/basictypes.h"
+#include "base/containers/adapters.h"
 #include "base/logging.h"
 #include "base/port.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"
 #include "net/quic/quic_write_blocked_list.h"
 
 using base::StringPiece;
 using std::string;
 
 namespace net {
 
 // static
 uint64 QuicUtils::FNV1a_64_Hash(const char* data, int len) {
   static const uint64 kOffset = GG_UINT64_C(14695981039346656037);
@@ skipping 247 matching lines @@
   }
 
   if (ascii) {
     return string(chars, sizeof(chars));
   }
 
   return base::UintToString(orig_tag);
 }
 
 // static
+QuicTagVector QuicUtils::ParseQuicConnectionOptions(
+    const std::string& connection_options) {
+  QuicTagVector options;
+  std::vector<std::string> tokens;
+  base::SplitString(connection_options, ',', &tokens);
+  // Tokens are expected to be no more than 4 characters long, but we
+  // handle overflow gracefully.
+  for (const std::string& token : tokens) {
+    uint32 option = 0;
+    for (char token_char : base::Reversed(token)) {
+      option <<= 8;
+      option |= static_cast<unsigned char>(token_char);
+    }
+    options.push_back(option);
+  }
+  return options;
+}
+
+// static
 string QuicUtils::StringToHexASCIIDump(StringPiece in_buffer) {
   int offset = 0;
   const int kBytesPerLine = 16;   // Max bytes dumped per line
   const char* buf = in_buffer.data();
   int bytes_remaining = in_buffer.size();
   string s;   // our output
   const char* p = buf;
   while (bytes_remaining > 0) {
     const int line_bytes = std::min(bytes_remaining, kBytesPerLine);
     base::StringAppendF(&s, "0x%04x:  ", offset);  // Do the line header
@@ skipping 22 matching lines @@
 QuicPriority QuicUtils::LowestPriority() {
   return QuicWriteBlockedList::kLowestPriority;
 }
 
 // static
 QuicPriority QuicUtils::HighestPriority() {
   return QuicWriteBlockedList::kHighestPriority;
 }
 
 }  // namespace net