Update from https://crrev.com/316786

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>
@@ skipping 24 matching lines @@
   for (int i = 0; i < len; ++i) {
     hash = hash ^ octets[i];
     hash = hash * kPrime;
   }
 
   return hash;
 }
 
 // static
 uint128 QuicUtils::FNV1a_128_Hash(const char* data, int len) {
-  // The following two constants are defined as part of the hash algorithm.
+  return FNV1a_128_Hash_Two(data, len, nullptr, 0);
+}
+
+// static
+uint128 QuicUtils::FNV1a_128_Hash_Two(const char* data1,
+                                      int len1,
+                                      const char* data2,
+                                      int len2) {
+  // The two constants are defined as part of the hash algorithm.
   // see http://www.isthe.com/chongo/tech/comp/fnv/
-  // 309485009821345068724781371
-  const uint128 kPrime(16777216, 315);
   // 144066263297769815596495629667062367629
   const uint128 kOffset(GG_UINT64_C(7809847782465536322),
                         GG_UINT64_C(7113472399480571277));
 
+  uint128 hash = IncrementalHash(kOffset, data1, len1);
+  if (data2 == nullptr) {
+    return hash;
+  }
+  return IncrementalHash(hash, data2, len2);
+}
+
+// static
+uint128 QuicUtils::IncrementalHash(uint128 hash, const char* data, size_t len) {
+  // 309485009821345068724781371
+  const uint128 kPrime(16777216, 315);
   const uint8* octets = reinterpret_cast<const uint8*>(data);
-
-  uint128 hash = kOffset;
-
-  for (int i = 0; i < len; ++i) {
+  for (size_t i = 0; i < len; ++i) {
     hash  = hash ^ uint128(0, octets[i]);
     hash = hash * kPrime;
   }
-
   return hash;
 }
 
 // static
 bool QuicUtils::FindMutualTag(const QuicTagVector& our_tags_vector,
                               const QuicTag* their_tags,
                               size_t num_their_tags,
                               Priority priority,
                               QuicTag* out_result,
                               size_t* out_index) {
@@ skipping 142 matching lines @@
     RETURN_STRING_LITERAL(QUIC_CRYPTO_DUPLICATE_TAG);
     RETURN_STRING_LITERAL(QUIC_CRYPTO_ENCRYPTION_LEVEL_INCORRECT);
     RETURN_STRING_LITERAL(QUIC_CRYPTO_SERVER_CONFIG_EXPIRED);
     RETURN_STRING_LITERAL(QUIC_INVALID_CHANNEL_ID_SIGNATURE);
     RETURN_STRING_LITERAL(QUIC_CRYPTO_SYMMETRIC_KEY_SETUP_FAILED);
     RETURN_STRING_LITERAL(QUIC_CRYPTO_MESSAGE_WHILE_VALIDATING_CLIENT_HELLO);
     RETURN_STRING_LITERAL(QUIC_CRYPTO_UPDATE_BEFORE_HANDSHAKE_COMPLETE);
     RETURN_STRING_LITERAL(QUIC_VERSION_NEGOTIATION_MISMATCH);
     RETURN_STRING_LITERAL(QUIC_TOO_MANY_OUTSTANDING_SENT_PACKETS);
     RETURN_STRING_LITERAL(QUIC_TOO_MANY_OUTSTANDING_RECEIVED_PACKETS);
+    RETURN_STRING_LITERAL(QUIC_CONNECTION_CANCELLED);
     RETURN_STRING_LITERAL(QUIC_LAST_ERROR);
     // Intentionally have no default case, so we'll break the build
     // if we add errors and don't put them here.
   }
   // Return a default value so that we return this when |error| doesn't match
   // any of the QuicErrorCodes. This can happen when the ConnectionClose
   // frame sent by the peer (attacker) has invalid error code.
   return "INVALID_ERROR_CODE";
 }
 
@@ skipping 102 matching lines @@
 QuicPriority QuicUtils::LowestPriority() {
   return QuicWriteBlockedList::kLowestPriority;
 }
 
 // static
 QuicPriority QuicUtils::HighestPriority() {
   return QuicWriteBlockedList::kHighestPriority;
 }
 
 }  // namespace net