Update from https://crrev.com/306655

net/quic/crypto/strike_register.cc

 // Copyright (c) 2013 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/crypto/strike_register.h"
 
 #include <limits>
 
 #include "base/logging.h"
 
@@ skipping 48 matching lines @@
   void SetOtherBits(uint8 otherbits) {
     data_[1] = (data_[1] & 0xffffff00) | otherbits;
   }
 
   void SetNextPtr(uint32 next) { data_[0] = next; }
 
   uint32 next() const { return data_[0]; }
 
   uint32 child(unsigned n) const { return data_[n] >> 8; }
 
-  uint8 critbyte() const { return data_[0]; }
+  uint8 critbyte() const { return static_cast<uint8>(data_[0]); }
 
-  uint8 otherbits() const { return data_[1]; }
+  uint8 otherbits() const { return static_cast<uint8>(data_[1]); }
 
   // These bytes are organised thus:
   //   <24 bits> left child
   //   <8 bits> crit-byte
   //   <24 bits> right child
   //   <8 bits> other-bits
   uint32 data_[2];
 };
 
 // kCreationTimeFromInternalEpoch contains the number of seconds between the
@@ skipping 105 matching lines @@
   // If we just evicted the best match, then we have to try and match again.
   // We know that we didn't just empty the tree because we require that
   // max_entries_ >= 2. Also, we know that it doesn't match because, if it
   // did, it would have been returned previously.
   if (external_node_index == best_match_index) {
     best_match_index = BestMatch(value);
     best_match = external_node(best_match_index);
   }
 
   // Now we need to find the first bit where we differ from |best_match|.
-  unsigned differing_byte;
+  uint8 differing_byte;
   uint8 new_other_bits;
-  for (differing_byte = 0; differing_byte < sizeof(value); differing_byte++) {
+  for (differing_byte = 0; differing_byte < arraysize(value);
+       differing_byte++) {
     new_other_bits = value[differing_byte] ^ best_match[differing_byte];
     if (new_other_bits) {
       break;
     }
   }
 
   // Once we have the XOR the of first differing byte in new_other_bits we need
   // to find the most significant differing bit. We could do this with a simple
   // for loop, testing bits 7..0. Instead we fold the bits so that we end up
   // with a byte where all the bits below the most significant one, are set.
@@ skipping 301 matching lines @@
       CHECK_EQ(free_internal_nodes.count(inter), 0u);
       CHECK_EQ(used_internal_nodes->count(inter), 0u);
       used_internal_nodes->insert(inter);
       ValidateTree(inter, bit, bits, free_internal_nodes, free_external_nodes,
                    used_internal_nodes, used_external_nodes);
     }
   }
 }
 
 }  // namespace net