Update brotli to v1.0.0-snapshot.

third_party/brotli/enc/find_match_length.h

 /* Copyright 2010 Google Inc. All Rights Reserved.
 
    Distributed under MIT license.
    See file LICENSE for detail or copy at https://opensource.org/licenses/MIT
 */
 
-// Function to find maximal matching prefixes of strings.
+/* Function to find maximal matching prefixes of strings. */
 
 #ifndef BROTLI_ENC_FIND_MATCH_LENGTH_H_
 #define BROTLI_ENC_FIND_MATCH_LENGTH_H_
 
+#include <brotli/types.h>
+#include "./port.h"
 
-#include "./port.h"
-#include "./types.h"
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
 
-namespace brotli {
-
-// Separate implementation for little-endian 64-bit targets, for speed.
+/* Separate implementation for little-endian 64-bit targets, for speed. */
 #if defined(__GNUC__) && defined(_LP64) && defined(IS_LITTLE_ENDIAN)
 
-static inline size_t FindMatchLengthWithLimit(const uint8_t* s1,
-                                              const uint8_t* s2,
-                                              size_t limit) {
+static BROTLI_INLINE size_t FindMatchLengthWithLimit(const uint8_t* s1,
+                                                     const uint8_t* s2,
+                                                     size_t limit) {
   size_t matched = 0;
-  size_t limit2 = (limit >> 3) + 1;  // + 1 is for pre-decrement in while
-  while (PREDICT_TRUE(--limit2)) {
-    if (PREDICT_FALSE(BROTLI_UNALIGNED_LOAD64(s2) ==
+  size_t limit2 = (limit >> 3) + 1;  /* + 1 is for pre-decrement in while */
+  while (BROTLI_PREDICT_TRUE(--limit2)) {
+    if (BROTLI_PREDICT_FALSE(BROTLI_UNALIGNED_LOAD64(s2) ==
                       BROTLI_UNALIGNED_LOAD64(s1 + matched))) {
       s2 += 8;
       matched += 8;
     } else {
       uint64_t x =
           BROTLI_UNALIGNED_LOAD64(s2) ^ BROTLI_UNALIGNED_LOAD64(s1 + matched);
-      size_t matching_bits = static_cast<size_t>(__builtin_ctzll(x));
+      size_t matching_bits = (size_t)__builtin_ctzll(x);
       matched += matching_bits >> 3;
       return matched;
     }
   }
-  limit = (limit & 7) + 1;  // + 1 is for pre-decrement in while
+  limit = (limit & 7) + 1;  /* + 1 is for pre-decrement in while */
   while (--limit) {
-    if (PREDICT_TRUE(s1[matched] == *s2)) {
+    if (BROTLI_PREDICT_TRUE(s1[matched] == *s2)) {
       ++s2;
       ++matched;
     } else {
       return matched;
     }
   }
   return matched;
 }
 #else
-static inline size_t FindMatchLengthWithLimit(const uint8_t* s1,
-                                             const uint8_t* s2,
-                                             size_t limit) {
+static BROTLI_INLINE size_t FindMatchLengthWithLimit(const uint8_t* s1,
+                                                     const uint8_t* s2,
+                                                     size_t limit) {
   size_t matched = 0;
   const uint8_t* s2_limit = s2 + limit;
   const uint8_t* s2_ptr = s2;
-  // Find out how long the match is. We loop over the data 32 bits at a
-  // time until we find a 32-bit block that doesn't match; then we find
-  // the first non-matching bit and use that to calculate the total
-  // length of the match.
+  /* Find out how long the match is. We loop over the data 32 bits at a
+     time until we find a 32-bit block that doesn't match; then we find
+     the first non-matching bit and use that to calculate the total
+     length of the match. */
   while (s2_ptr <= s2_limit - 4 &&
          BROTLI_UNALIGNED_LOAD32(s2_ptr) ==
          BROTLI_UNALIGNED_LOAD32(s1 + matched)) {
     s2_ptr += 4;
     matched += 4;
   }
   while ((s2_ptr < s2_limit) && (s1[matched] == *s2_ptr)) {
     ++s2_ptr;
     ++matched;
   }
   return matched;
 }
 #endif
 
-}  // namespace brotli
+#if defined(__cplusplus) || defined(c_plusplus)
+}  /* extern "C" */
+#endif
 
-#endif  // BROTLI_ENC_FIND_MATCH_LENGTH_H_
+#endif  /* BROTLI_ENC_FIND_MATCH_LENGTH_H_ */