diff --git a/deps/zlib/BUILD.gn b/deps/zlib/BUILD.gn
index 5f8873357d35d15..34d8c0a61f73c64 100644
--- a/deps/zlib/BUILD.gn
+++ b/deps/zlib/BUILD.gn
@@ -4,6 +4,10 @@
 
 import("//build/config/compiler/compiler.gni")
 
+if (build_with_chromium) {
+  import("//testing/test.gni")
+}
+
 if (current_cpu == "arm" || current_cpu == "arm64") {
   import("//build/config/arm.gni")
 }
@@ -14,10 +18,36 @@ config("zlib_config") {
 
 config("zlib_internal_config") {
   defines = [ "ZLIB_IMPLEMENTATION" ]
+
+  if (!is_debug) {
+    # Build code using -O3, see: crbug.com/1084371.
+    configs = [ "//build/config/compiler:optimize_speed" ]
+  }
+  if (is_debug || use_libfuzzer) {
+    # Enable zlib's asserts in debug and fuzzer builds.
+    defines += [ "ZLIB_DEBUG" ]
+  }
+}
+
+source_set("zlib_common_headers") {
+  sources = [
+    "chromeconf.h",
+    "deflate.h",
+    "inffast.h",
+    "inffixed.h",
+    "inflate.h",
+    "inftrees.h",
+    "zconf.h",
+    "zlib.h",
+    "zutil.h",
+  ]
 }
 
 use_arm_neon_optimizations = false
-if (current_cpu == "arm" || current_cpu == "arm64") {
+if ((current_cpu == "arm" || current_cpu == "arm64") &&
+    !(is_win && !is_clang)) {
+  # TODO(richard.townsend@arm.com): Optimizations temporarily disabled for
+  # Windows on Arm MSVC builds, see http://crbug.com/v8/10012.
   if (arm_use_neon) {
     use_arm_neon_optimizations = true
   }
@@ -29,6 +59,11 @@ use_x86_x64_optimizations =
 config("zlib_adler32_simd_config") {
   if (use_x86_x64_optimizations) {
     defines = [ "ADLER32_SIMD_SSSE3" ]
+    if (is_win) {
+      defines += [ "X86_WINDOWS" ]
+    } else {
+      defines += [ "X86_NOT_WINDOWS" ]
+    }
   }
 
   if (use_arm_neon_optimizations) {
@@ -55,16 +90,13 @@ source_set("zlib_adler32_simd") {
       "adler32_simd.c",
       "adler32_simd.h",
     ]
-    if (!is_debug) {
-      # Use optimize_speed (-O3) to output the _smallest_ code.
-      configs -= [ "//build/config/compiler:default_optimization" ]
-      configs += [ "//build/config/compiler:optimize_speed" ]
-    }
   }
 
   configs += [ ":zlib_internal_config" ]
 
   public_configs = [ ":zlib_adler32_simd_config" ]
+
+  public_deps = [ ":zlib_common_headers" ]
 }
 
 if (use_arm_neon_optimizations) {
@@ -78,6 +110,8 @@ if (use_arm_neon_optimizations) {
         defines += [ "ARMV8_OS_ANDROID" ]
       } else if (is_linux || is_chromeos) {
         defines += [ "ARMV8_OS_LINUX" ]
+      } else if (is_mac) {
+        defines += [ "ARMV8_OS_MACOS" ]
       } else if (is_fuchsia) {
         defines += [ "ARMV8_OS_FUCHSIA" ]
       } else if (is_win) {
@@ -94,37 +128,23 @@ if (use_arm_neon_optimizations) {
     if (!is_ios) {
       include_dirs = [ "." ]
 
-      if (is_android) {
-        import("//build/config/android/config.gni")
-        if (defined(android_ndk_root) && android_ndk_root != "") {
-          deps = [
-            "//third_party/android_ndk:cpu_features",
-          ]
-        } else {
-          assert(false, "CPU detection requires the Android NDK")
-        }
-      } else if (!is_win && !is_clang) {
+      if (!is_win && !is_clang) {
         assert(!use_thin_lto,
                "ThinLTO fails mixing different module-level targets")
         cflags_c = [ "-march=armv8-a+crc" ]
       }
 
       sources = [
-        "arm_features.c",
-        "arm_features.h",
         "crc32_simd.c",
         "crc32_simd.h",
       ]
-
-      if (!is_debug) {
-        configs -= [ "//build/config/compiler:default_optimization" ]
-        configs += [ "//build/config/compiler:optimize_speed" ]
-      }
     }
 
     configs += [ ":zlib_internal_config" ]
 
     public_configs = [ ":zlib_arm_crc32_config" ]
+
+    public_deps = [ ":zlib_common_headers" ]
   }
 }
 
@@ -139,6 +159,7 @@ config("zlib_inflate_chunk_simd_config") {
 
   if (use_arm_neon_optimizations) {
     defines = [ "INFLATE_CHUNK_SIMD_NEON" ]
+
     if (current_cpu == "arm64") {
       defines += [ "INFLATE_CHUNK_READ_64LE" ]
     }
@@ -157,22 +178,18 @@ source_set("zlib_inflate_chunk_simd") {
       "contrib/optimizations/inffast_chunk.h",
       "contrib/optimizations/inflate.c",
     ]
-
-    if (use_arm_neon_optimizations && !is_debug) {
-      # Here we trade better performance on newer/bigger ARMv8 cores
-      # for less perf on ARMv7, per crbug.com/772870#c40
-      configs -= [ "//build/config/compiler:default_optimization" ]
-      configs += [ "//build/config/compiler:optimize_speed" ]
-    }
   }
 
+  configs += [ ":zlib_internal_config" ]
+
+  # Needed for MSVC, which is still supported by V8 and PDFium. zlib uses K&R C
+  # style function declarations, which triggers warning C4131.
   configs -= [ "//build/config/compiler:chromium_code" ]
-  configs += [
-    ":zlib_internal_config",
-    "//build/config/compiler:no_chromium_code",
-  ]
+  configs += [ "//build/config/compiler:no_chromium_code" ]
 
   public_configs = [ ":zlib_inflate_chunk_simd_config" ]
+
+  public_deps = [ ":zlib_common_headers" ]
 }
 
 config("zlib_crc32_simd_config") {
@@ -201,6 +218,16 @@ source_set("zlib_crc32_simd") {
   configs += [ ":zlib_internal_config" ]
 
   public_configs = [ ":zlib_crc32_simd_config" ]
+  public_deps = [ ":zlib_common_headers" ]
+}
+
+config("zlib_x86_simd_config") {
+  if (use_x86_x64_optimizations) {
+    defines = [
+      "CRC32_SIMD_SSE42_PCLMUL",
+      "DEFLATE_FILL_WINDOW_SSE2",
+    ]
+  }
 }
 
 source_set("zlib_x86_simd") {
@@ -218,17 +245,13 @@ source_set("zlib_x86_simd") {
         "-mpclmul",
       ]
     }
-  } else {
-    sources = [
-      "simd_stub.c",
-    ]
   }
 
-  configs -= [ "//build/config/compiler:chromium_code" ]
-  configs += [
-    ":zlib_internal_config",
-    "//build/config/compiler:no_chromium_code",
-  ]
+  configs += [ ":zlib_internal_config" ]
+
+  public_configs = [ ":zlib_x86_simd_config" ]
+
+  public_deps = [ ":zlib_common_headers" ]
 }
 
 config("zlib_warnings") {
@@ -248,6 +271,8 @@ component("zlib") {
     "chromeconf.h",
     "compress.c",
     "contrib/optimizations/insert_string.h",
+    "cpu_features.c",
+    "cpu_features.h",
     "crc32.c",
     "crc32.h",
     "deflate.c",
@@ -267,7 +292,6 @@ component("zlib") {
     "trees.c",
     "trees.h",
     "uncompr.c",
-    "x86.h",
     "zconf.h",
     "zlib.h",
     "zutil.c",
@@ -277,6 +301,20 @@ component("zlib") {
   defines = []
   deps = []
 
+  if (!use_x86_x64_optimizations && !use_arm_neon_optimizations) {
+    # Apparently android_cronet bot builds with NEON disabled and
+    # we also should disable optimizations for iOS@x86 (a.k.a. simulator).
+    defines += [ "CPU_NO_SIMD" ]
+  }
+
+  if (is_ios) {
+    # iOS@ARM is a special case where we always have NEON but don't check
+    # for crypto extensions.
+    # TODO(cavalcantii): verify what is the current state of CPU features
+    # shipped on latest iOS devices.
+    defines += [ "ARM_OS_IOS" ]
+  }
+
   if (use_x86_x64_optimizations || use_arm_neon_optimizations) {
     deps += [
       ":zlib_adler32_simd",
@@ -284,7 +322,6 @@ component("zlib") {
     ]
 
     if (use_x86_x64_optimizations) {
-      sources += [ "x86.c" ]
       deps += [ ":zlib_crc32_simd" ]
     } else if (use_arm_neon_optimizations) {
       sources += [ "contrib/optimizations/slide_hash_neon.h" ]
@@ -294,18 +331,29 @@ component("zlib") {
     sources += [ "inflate.c" ]
   }
 
+  deps += [ ":zlib_x86_simd" ]
+
+  if (is_android) {
+    import("//build/config/android/config.gni")
+    if (defined(android_ndk_root) && android_ndk_root != "") {
+      deps += [ "//third_party/android_ndk:cpu_features" ]
+    } else {
+      assert(false, "CPU detection requires the Android NDK")
+    }
+  }
+
   configs -= [ "//build/config/compiler:chromium_code" ]
+  configs += [ "//build/config/compiler:no_chromium_code" ]
+
+  public_configs = [ ":zlib_config" ]
+
   configs += [
     ":zlib_internal_config",
-    "//build/config/compiler:no_chromium_code",
 
     # Must be after no_chromium_code for warning flags to be ordered correctly.
     ":zlib_warnings",
   ]
 
-  public_configs = [ ":zlib_config" ]
-
-  deps += [ ":zlib_x86_simd" ]
   allow_circular_includes_from = deps
 }
 
@@ -337,43 +385,63 @@ static_library("minizip") {
     ]
   }
 
-  if (is_mac || is_ios || is_android || is_nacl) {
+  if (is_apple || is_android || is_nacl) {
     # Mac, Android and the BSDs don't have fopen64, ftello64, or fseeko64. We
     # use fopen, ftell, and fseek instead on these systems.
     defines = [ "USE_FILE32API" ]
   }
 
-  deps = [
-    ":zlib",
-  ]
+  deps = [ ":zlib" ]
 
   configs -= [ "//build/config/compiler:chromium_code" ]
-  configs += [
-    "//build/config/compiler:no_chromium_code",
+  configs += [ "//build/config/compiler:no_chromium_code" ]
 
+  public_configs = [ ":zlib_config" ]
+
+  configs += [
     # Must be after no_chromium_code for warning flags to be ordered correctly.
     ":minizip_warnings",
   ]
-
-  public_configs = [ ":zlib_config" ]
 }
 
 executable("zlib_bench") {
   include_dirs = [ "." ]
 
-  sources = [
-    "contrib/bench/zlib_bench.cc",
-  ]
-
+  sources = [ "contrib/bench/zlib_bench.cc" ]
   if (!is_debug) {
     configs -= [ "//build/config/compiler:default_optimization" ]
     configs += [ "//build/config/compiler:optimize_speed" ]
   }
 
+  deps = [ ":zlib" ]
+
   configs -= [ "//build/config/compiler:chromium_code" ]
   configs += [ "//build/config/compiler:no_chromium_code" ]
+}
 
-  deps = [
-    ":zlib",
-  ]
+if (build_with_chromium) {
+  test("zlib_unittests") {
+    testonly = true
+
+    sources = [
+      "contrib/tests/infcover.cc",
+      "contrib/tests/infcover.h",
+      "contrib/tests/run_all_unittests.cc",
+      "contrib/tests/utils_unittest.cc",
+      "google/compression_utils_portable.cc",
+      "google/compression_utils_portable.h",
+    ]
+
+    deps = [
+      ":zlib",
+      "//base/test:test_support",
+      "//testing/gtest",
+    ]
+
+    include_dirs = [
+      "//third_party/googletest/src/googletest/include/gtest",
+      ".",
+      "google",
+    ]
+  }
 }
diff --git a/deps/zlib/OWNERS b/deps/zlib/OWNERS
index 069bcd8c2a1445a..22f4d8938efbc14 100644
--- a/deps/zlib/OWNERS
+++ b/deps/zlib/OWNERS
@@ -1,7 +1,7 @@
 agl@chromium.org
 cavalcantii@chromium.org
 cblume@chromium.org
-mtklein@chromium.org
-scroggo@chromium.org
+mtklein@google.com
+scroggo@google.com
 
 # COMPONENT: Internals
diff --git a/deps/zlib/README.chromium b/deps/zlib/README.chromium
index 3d90f79be2ffc28..c3c1ef69ad46568 100644
--- a/deps/zlib/README.chromium
+++ b/deps/zlib/README.chromium
@@ -2,6 +2,7 @@ Name: zlib
 Short Name: zlib
 URL: http://zlib.net/
 Version: 1.2.11
+CPEPrefix: cpe:/a:zlib:zlib:1.2.11
 Security Critical: yes
 License: Custom license
 License File: LICENSE
diff --git a/deps/zlib/adler32.c b/deps/zlib/adler32.c
index a42f35fce2a2e03..696773a09d43d2a 100644
--- a/deps/zlib/adler32.c
+++ b/deps/zlib/adler32.c
@@ -59,10 +59,8 @@ local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
 #  define MOD63(a) a %= BASE
 #endif
 
-#if defined(ADLER32_SIMD_SSSE3)
-#include "adler32_simd.h"
-#include "x86.h"
-#elif defined(ADLER32_SIMD_NEON)
+#include "cpu_features.h"
+#if defined(ADLER32_SIMD_SSSE3) || defined(ADLER32_SIMD_NEON)
 #include "adler32_simd.h"
 #endif
 
@@ -108,7 +106,7 @@ uLong ZEXPORT adler32_z(adler, buf, len)
      */
     if (buf == Z_NULL) {
         if (!len) /* Assume user is calling adler32(0, NULL, 0); */
-            x86_check_features();
+            cpu_check_features();
         return 1L;
     }
 #else
diff --git a/deps/zlib/adler32_simd.c b/deps/zlib/adler32_simd.c
index f8b07297b938405..1354915cc099ad8 100644
--- a/deps/zlib/adler32_simd.c
+++ b/deps/zlib/adler32_simd.c
@@ -50,13 +50,9 @@
 #define NMAX 5552
 
 #if defined(ADLER32_SIMD_SSSE3)
-#ifndef __GNUC__
-#define __attribute__()
-#endif
 
 #include <tmmintrin.h>
 
-__attribute__((target("ssse3")))
 uint32_t ZLIB_INTERNAL adler32_simd_(  /* SSSE3 */
     uint32_t adler,
     const unsigned char *buf,
diff --git a/deps/zlib/arm_features.c b/deps/zlib/arm_features.c
deleted file mode 100644
index f5641c39bbce976..000000000000000
--- a/deps/zlib/arm_features.c
+++ /dev/null
@@ -1,90 +0,0 @@
-/* arm_features.c -- ARM processor features detection.
- *
- * Copyright 2018 The Chromium Authors. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the Chromium source repository LICENSE file.
- */
-
-#include "arm_features.h"
-#include "zutil.h"
-#include <stdint.h>
-
-int ZLIB_INTERNAL arm_cpu_enable_crc32 = 0;
-int ZLIB_INTERNAL arm_cpu_enable_pmull = 0;
-
-#if defined(ARMV8_OS_ANDROID) || defined(ARMV8_OS_LINUX) || defined(ARMV8_OS_FUCHSIA)
-#include <pthread.h>
-#endif
-
-#if defined(ARMV8_OS_ANDROID)
-#include <cpu-features.h>
-#elif defined(ARMV8_OS_LINUX)
-#include <asm/hwcap.h>
-#include <sys/auxv.h>
-#elif defined(ARMV8_OS_FUCHSIA)
-#include <zircon/features.h>
-#include <zircon/syscalls.h>
-#include <zircon/types.h>
-#elif defined(ARMV8_OS_WINDOWS)
-#include <windows.h>
-#else
-#error arm_features.c ARM feature detection in not defined for your platform
-#endif
-
-static void _arm_check_features(void);
-
-#if defined(ARMV8_OS_ANDROID) || defined(ARMV8_OS_LINUX) || defined(ARMV8_OS_FUCHSIA)
-static pthread_once_t cpu_check_inited_once = PTHREAD_ONCE_INIT;
-void ZLIB_INTERNAL arm_check_features(void)
-{
-    pthread_once(&cpu_check_inited_once, _arm_check_features);
-}
-#elif defined(ARMV8_OS_WINDOWS)
-static INIT_ONCE cpu_check_inited_once = INIT_ONCE_STATIC_INIT;
-static BOOL CALLBACK _arm_check_features_forwarder(PINIT_ONCE once, PVOID param, PVOID* context)
-{
-    _arm_check_features();
-    return TRUE;
-}
-void ZLIB_INTERNAL arm_check_features(void)
-{
-    InitOnceExecuteOnce(&cpu_check_inited_once, _arm_check_features_forwarder,
-                        NULL, NULL);
-}
-#endif
-
-/*
- * See http://bit.ly/2CcoEsr for run-time detection of ARM features and also
- * crbug.com/931275 for android_getCpuFeatures() use in the Android sandbox.
- */
-static void _arm_check_features(void)
-{
-#if defined(ARMV8_OS_ANDROID) && defined(__aarch64__)
-    uint64_t features = android_getCpuFeatures();
-    arm_cpu_enable_crc32 = !!(features & ANDROID_CPU_ARM64_FEATURE_CRC32);
-    arm_cpu_enable_pmull = !!(features & ANDROID_CPU_ARM64_FEATURE_PMULL);
-#elif defined(ARMV8_OS_ANDROID) /* aarch32 */
-    uint64_t features = android_getCpuFeatures();
-    arm_cpu_enable_crc32 = !!(features & ANDROID_CPU_ARM_FEATURE_CRC32);
-    arm_cpu_enable_pmull = !!(features & ANDROID_CPU_ARM_FEATURE_PMULL);
-#elif defined(ARMV8_OS_LINUX) && defined(__aarch64__)
-    unsigned long features = getauxval(AT_HWCAP);
-    arm_cpu_enable_crc32 = !!(features & HWCAP_CRC32);
-    arm_cpu_enable_pmull = !!(features & HWCAP_PMULL);
-#elif defined(ARMV8_OS_LINUX) && (defined(__ARM_NEON) || defined(__ARM_NEON__))
-    /* Query HWCAP2 for ARMV8-A SoCs running in aarch32 mode */
-    unsigned long features = getauxval(AT_HWCAP2);
-    arm_cpu_enable_crc32 = !!(features & HWCAP2_CRC32);
-    arm_cpu_enable_pmull = !!(features & HWCAP2_PMULL);
-#elif defined(ARMV8_OS_FUCHSIA)
-    uint32_t features;
-    zx_status_t rc = zx_system_get_features(ZX_FEATURE_KIND_CPU, &features);
-    if (rc != ZX_OK || (features & ZX_ARM64_FEATURE_ISA_ASIMD) == 0)
-        return;  /* Report nothing if ASIMD(NEON) is missing */
-    arm_cpu_enable_crc32 = !!(features & ZX_ARM64_FEATURE_ISA_CRC32);
-    arm_cpu_enable_pmull = !!(features & ZX_ARM64_FEATURE_ISA_PMULL);
-#elif defined(ARMV8_OS_WINDOWS)
-    arm_cpu_enable_crc32 = IsProcessorFeaturePresent(PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE);
-    arm_cpu_enable_pmull = IsProcessorFeaturePresent(PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE);
-#endif
-}
diff --git a/deps/zlib/chromeconf.h b/deps/zlib/chromeconf.h
index 666093d696a5835..5ecf29edbff5ae7 100644
--- a/deps/zlib/chromeconf.h
+++ b/deps/zlib/chromeconf.h
@@ -192,4 +192,8 @@
 #define arm_check_features Cr_z_arm_check_features
 #define armv8_crc32_little Cr_z_armv8_crc32_little
 
+/* Symbols added by cpu_features.c */
+#define cpu_check_features Cr_z_cpu_check_features
+#define x86_cpu_enable_sse2 Cr_z_x86_cpu_enable_sse2
+
 #endif /* THIRD_PARTY_ZLIB_CHROMECONF_H_ */
diff --git a/deps/zlib/contrib/bench/zlib_bench.cc b/deps/zlib/contrib/bench/zlib_bench.cc
index 5dcdef09f36b769..bc2f741a25bc9d7 100644
--- a/deps/zlib/contrib/bench/zlib_bench.cc
+++ b/deps/zlib/contrib/bench/zlib_bench.cc
@@ -38,7 +38,7 @@ void error_exit(const char* error, int code) {
 }
 
 inline char* string_data(std::string* s) {
-  return s->empty() ? 0 : &*s->begin();
+  return s->empty() ? nullptr : &*s->begin();
 }
 
 struct Data {
@@ -99,10 +99,25 @@ const char* zlib_wrapper_name(zlib_wrapper type) {
   if (type == kWrapperZRAW)
     return "RAW";
   error_exit("bad wrapper type", int(type));
-  return 0;
+  return nullptr;
+}
+
+static int zlib_strategy = Z_DEFAULT_STRATEGY;
+
+const char* zlib_level_strategy_name(int compression_level) {
+  if (compression_level == 0)
+    return "";  // strategy is meaningless at level 0
+  if (zlib_strategy == Z_HUFFMAN_ONLY)
+    return "huffman ";
+  if (zlib_strategy == Z_RLE)
+    return "rle ";
+  if (zlib_strategy == Z_DEFAULT_STRATEGY)
+    return "";
+  error_exit("bad strategy", zlib_strategy);
+  return nullptr;
 }
 
-static int zlib_compression_level;
+static int zlib_compression_level = Z_DEFAULT_COMPRESSION;
 
 void zlib_compress(
     const zlib_wrapper type,
@@ -119,7 +134,7 @@ void zlib_compress(
   memset(&stream, 0, sizeof(stream));
 
   int result = deflateInit2(&stream, zlib_compression_level, Z_DEFLATED,
-      zlib_stream_wrapper_type(type), MAX_MEM_LEVEL, Z_DEFAULT_STRATEGY);
+      zlib_stream_wrapper_type(type), MAX_MEM_LEVEL, zlib_strategy);
   if (result != Z_OK)
     error_exit("deflateInit2 failed", result);
 
@@ -185,7 +200,12 @@ void zlib_file(const char* name, const zlib_wrapper type) {
   const auto file = read_file_data_or_exit(name);
   const int length = static_cast<int>(file.size);
   const char* data = file.data.get();
-  printf("%-40s :\n", name);
+
+  /*
+   * Report compression strategy and file name.
+   */
+  const char* strategy = zlib_level_strategy_name(zlib_compression_level);
+  printf("%s%-40s :\n", strategy, name);
 
   /*
    * Chop the data into blocks.
@@ -276,18 +296,21 @@ static int argn = 1;
 
 char* get_option(int argc, char* argv[], const char* option) {
   if (argn < argc)
-    return !strcmp(argv[argn], option) ? argv[argn++] : 0;
-  return 0;
+    return !strcmp(argv[argn], option) ? argv[argn++] : nullptr;
+  return nullptr;
 }
 
 bool get_compression(int argc, char* argv[], int* value) {
   if (argn < argc)
-    *value = atoi(argv[argn++]);
-  return *value >= 1 && *value <= 9;
+    *value = isdigit(argv[argn][0]) ? atoi(argv[argn++]) : -1;
+  return *value >= 0 && *value <= 9;
 }
 
 void usage_exit(const char* program) {
-  printf("usage: %s gzip|zlib|raw [--compression 1:9] files...\n", program);
+  printf(
+      "usage: %s gzip|zlib|raw [--compression 0:9] [--huffman|--rle] "
+      "files...\n",
+      program);
   exit(1);
 }
 
@@ -302,10 +325,18 @@ int main(int argc, char* argv[]) {
   else
     usage_exit(argv[0]);
 
-  if (!get_option(argc, argv, "--compression"))
-    zlib_compression_level = Z_DEFAULT_COMPRESSION;
-  else if (!get_compression(argc, argv, &zlib_compression_level))
-    usage_exit(argv[0]);
+  while (argn < argc && argv[argn][0] == '-') {
+    if (get_option(argc, argv, "--compression")) {
+      if (!get_compression(argc, argv, &zlib_compression_level))
+        usage_exit(argv[0]);
+    } else if (get_option(argc, argv, "--huffman")) {
+      zlib_strategy = Z_HUFFMAN_ONLY;
+    } else if (get_option(argc, argv, "--rle")) {
+      zlib_strategy = Z_RLE;
+    } else {
+      usage_exit(argv[0]);
+    }
+  }
 
   if (argn >= argc)
     usage_exit(argv[0]);
diff --git a/deps/zlib/contrib/minizip/iowin32.c b/deps/zlib/contrib/minizip/iowin32.c
index 246ceb91a13942f..c6bc314b3c28afc 100644
--- a/deps/zlib/contrib/minizip/iowin32.c
+++ b/deps/zlib/contrib/minizip/iowin32.c
@@ -31,14 +31,12 @@
 #define _WIN32_WINNT 0x601
 #endif
 
-#if _WIN32_WINNT >= _WIN32_WINNT_WIN8
-// see Include/shared/winapifamily.h in the Windows Kit
-#if defined(WINAPI_FAMILY_PARTITION) && (!(defined(IOWIN32_USING_WINRT_API)))
-#if WINAPI_FAMILY_ONE_PARTITION(WINAPI_FAMILY, WINAPI_PARTITION_APP)
+#if !defined(IOWIN32_USING_WINRT_API)
+#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
+// Windows Store or Universal Windows Platform
 #define IOWIN32_USING_WINRT_API 1
 #endif
 #endif
-#endif
 
 voidpf  ZCALLBACK win32_open_file_func  OF((voidpf opaque, const char* filename, int mode));
 uLong   ZCALLBACK win32_read_file_func  OF((voidpf opaque, voidpf stream, void* buf, uLong size));
diff --git a/deps/zlib/contrib/optimizations/chunkcopy.h b/deps/zlib/contrib/optimizations/chunkcopy.h
index 38ba0ed8a27f456..9c0b7cb06c2dcca 100644
--- a/deps/zlib/contrib/optimizations/chunkcopy.h
+++ b/deps/zlib/contrib/optimizations/chunkcopy.h
@@ -112,6 +112,10 @@ static inline unsigned char FAR* chunkcopy_core_safe(
   Assert(out + len <= limit, "chunk copy exceeds safety limit");
   if ((limit - out) < (ptrdiff_t)CHUNKCOPY_CHUNK_SIZE) {
     const unsigned char FAR* Z_RESTRICT rfrom = from;
+    Assert((uintptr_t)out - (uintptr_t)from >= len,
+           "invalid restrict in chunkcopy_core_safe");
+    Assert((uintptr_t)from - (uintptr_t)out >= len,
+           "invalid restrict in chunkcopy_core_safe");
     if (len & 8) {
       Z_BUILTIN_MEMCPY(out, rfrom, 8);
       out += 8;
@@ -338,6 +342,10 @@ static inline unsigned char FAR* chunkcopy_relaxed(
     unsigned char FAR* Z_RESTRICT out,
     const unsigned char FAR* Z_RESTRICT from,
     unsigned len) {
+  Assert((uintptr_t)out - (uintptr_t)from >= len,
+         "invalid restrict in chunkcopy_relaxed");
+  Assert((uintptr_t)from - (uintptr_t)out >= len,
+         "invalid restrict in chunkcopy_relaxed");
   return chunkcopy_core(out, from, len);
 }
 
@@ -360,6 +368,11 @@ static inline unsigned char FAR* chunkcopy_safe(
     unsigned len,
     unsigned char FAR* limit) {
   Assert(out + len <= limit, "chunk copy exceeds safety limit");
+  Assert((uintptr_t)out - (uintptr_t)from >= len,
+         "invalid restrict in chunkcopy_safe");
+  Assert((uintptr_t)from - (uintptr_t)out >= len,
+         "invalid restrict in chunkcopy_safe");
+
   return chunkcopy_core_safe(out, from, len, limit);
 }
 
@@ -406,6 +419,26 @@ static inline unsigned char FAR* chunkcopy_lapped_safe(
   return chunkcopy_lapped_relaxed(out, dist, len);
 }
 
+/* TODO(cavalcanti): see crbug.com/1110083. */
+static inline unsigned char FAR* chunkcopy_safe_ugly(unsigned char FAR* out,
+                                                     unsigned dist,
+                                                     unsigned len,
+                                                     unsigned char FAR* limit) {
+#if defined(__GNUC__) && !defined(__clang__)
+  /* Speed is the same as using chunkcopy_safe
+     w/ GCC on ARM (tested gcc 6.3 and 7.5) and avoids
+     undefined behavior.
+  */
+  return chunkcopy_core_safe(out, out - dist, len, limit);
+#elif defined(__clang__) && defined(ARMV8_OS_ANDROID) && !defined(__aarch64__)
+  /* Seems to perform better on 32bit (i.e. Android). */
+  return chunkcopy_core_safe(out, out - dist, len, limit);
+#else
+  /* Seems to perform better on 64bit. */
+  return chunkcopy_lapped_safe(out, dist, len, limit);
+#endif
+}
+
 /*
  * The chunk-copy code above deals with writing the decoded DEFLATE data to
  * the output with SIMD methods to increase decode speed. Reading the input
diff --git a/deps/zlib/contrib/optimizations/inffast_chunk.c b/deps/zlib/contrib/optimizations/inffast_chunk.c
index 4099edf3961d747..4bacbc46f620a37 100644
--- a/deps/zlib/contrib/optimizations/inffast_chunk.c
+++ b/deps/zlib/contrib/optimizations/inffast_chunk.c
@@ -276,7 +276,7 @@ unsigned start;         /* inflate()'s starting value for strm->avail_out */
                            the main copy is near the end.
                           */
                         out = chunkunroll_relaxed(out, &dist, &len);
-                        out = chunkcopy_safe(out, out - dist, len, limit);
+                        out = chunkcopy_safe_ugly(out, dist, len, limit);
                     } else {
                         /* from points to window, so there is no risk of
                            overlapping pointers requiring memset-like behaviour
diff --git a/deps/zlib/contrib/optimizations/insert_string.h b/deps/zlib/contrib/optimizations/insert_string.h
index 69eee3dc9e91fcc..9f634ae351b2e58 100644
--- a/deps/zlib/contrib/optimizations/insert_string.h
+++ b/deps/zlib/contrib/optimizations/insert_string.h
@@ -4,45 +4,51 @@
  * Use of this source code is governed by a BSD-style license that can be
  * found in the Chromium source repository LICENSE file.
  */
-#ifdef _MSC_VER
+
+#if defined(_MSC_VER)
 #define INLINE __inline
 #else
 #define INLINE inline
 #endif
 
-/* Optimized insert_string block */
-#if defined(CRC32_SIMD_SSE42_PCLMUL) || defined(CRC32_ARMV8_CRC32)
-#define TARGET_CPU_WITH_CRC
+#include "cpu_features.h"
+
 // clang-format off
 #if defined(CRC32_SIMD_SSE42_PCLMUL)
-  /* Required to make MSVC bot build pass. */
-  #include <smmintrin.h>
-  #if defined(__GNUC__) || defined(__clang__)
-    #undef TARGET_CPU_WITH_CRC
+  #include <smmintrin.h>  /* Required to make MSVC bot build pass. */
+
+  #if defined(__clang__) || defined(__GNUC__)
     #define TARGET_CPU_WITH_CRC __attribute__((target("sse4.2")))
+  #else
+    #define TARGET_CPU_WITH_CRC
   #endif
 
   #define _cpu_crc32_u32 _mm_crc32_u32
 
 #elif defined(CRC32_ARMV8_CRC32)
-  #include "arm_features.h"
   #if defined(__clang__)
-    #undef TARGET_CPU_WITH_CRC
     #define __crc32cw __builtin_arm_crc32cw
+  #elif defined(__GNUC__)
+    #define __crc32cw __builtin_aarch64_crc32cw
   #endif
 
-  #define _cpu_crc32_u32 __crc32cw
-
-  #if defined(__aarch64__)
+  #if defined(__aarch64__) && defined(__clang__)
     #define TARGET_CPU_WITH_CRC __attribute__((target("crc")))
-  #else  // !defined(__aarch64__)
+  #elif defined(__aarch64__) && defined(__GNUC__)
+    #define TARGET_CPU_WITH_CRC __attribute__((target("+crc")))
+  #elif defined(__clang__) // !defined(__aarch64__)
     #define TARGET_CPU_WITH_CRC __attribute__((target("armv8-a,crc")))
   #endif  // defined(__aarch64__)
+
+  #define _cpu_crc32_u32 __crc32cw
+
 #endif
 // clang-format on
+
+#if defined(TARGET_CPU_WITH_CRC)
+
 TARGET_CPU_WITH_CRC
-local INLINE Pos insert_string_optimized(deflate_state* const s,
-                                         const Pos str) {
+local INLINE Pos insert_string_simd(deflate_state* const s, const Pos str) {
   Pos ret;
   unsigned *ip, val, h = 0;
 
@@ -64,7 +70,8 @@ local INLINE Pos insert_string_optimized(deflate_state* const s,
   s->prev[str & s->w_mask] = ret;
   return ret;
 }
-#endif /* Optimized insert_string block */
+
+#endif // TARGET_CPU_WITH_CRC
 
 /* ===========================================================================
  * Update a hash value with the given input byte
@@ -99,24 +106,22 @@ local INLINE Pos insert_string_c(deflate_state* const s, const Pos str) {
 }
 
 local INLINE Pos insert_string(deflate_state* const s, const Pos str) {
-/* String dictionary insertion: faster symbol hashing has a positive impact
- * on data compression speeds (around 20% on Intel and 36% on Arm Cortex big
- * cores).
- * A misfeature is that the generated compressed output will differ from
- * vanilla zlib (even though it is still valid 'DEFLATE-d' content).
+/* insert_string_simd string dictionary insertion: this SIMD symbol hashing
+ * significantly improves data compression speed.
  *
- * We offer here a way to disable the optimization if there is the expectation
- * that compressed content should match when compared to vanilla zlib.
+ * Note: the generated compressed output is a valid DEFLATE stream but will
+ * differ from vanilla zlib output ...
  */
-#if !defined(CHROMIUM_ZLIB_NO_CASTAGNOLI)
-  /* TODO(cavalcantii): unify CPU features code. */
-#if defined(CRC32_ARMV8_CRC32)
-  if (arm_cpu_enable_crc32)
-    return insert_string_optimized(s, str);
-#elif defined(CRC32_SIMD_SSE42_PCLMUL)
+#if defined(CHROMIUM_ZLIB_NO_CASTAGNOLI)
+/* ... so this build-time option can used to disable the SIMD symbol hasher
+ * if matching vanilla zlib DEFLATE output is required.
+ */ (;) /* FALLTHOUGH */
+#elif defined(TARGET_CPU_WITH_CRC) && defined(CRC32_SIMD_SSE42_PCLMUL)
   if (x86_cpu_enable_simd)
-    return insert_string_optimized(s, str);
-#endif
+    return insert_string_simd(s, str);
+#elif defined(TARGET_CPU_WITH_CRC) && defined(CRC32_ARMV8_CRC32)
+  if (arm_cpu_enable_crc32)
+    return insert_string_simd(s, str);
 #endif
   return insert_string_c(s, str);
 }
diff --git a/deps/zlib/contrib/tests/DEPS b/deps/zlib/contrib/tests/DEPS
new file mode 100644
index 000000000000000..427517406867767
--- /dev/null
+++ b/deps/zlib/contrib/tests/DEPS
@@ -0,0 +1,4 @@
+include_rules = [
+    "+testing/gtest",
+    "+base",
+]
diff --git a/deps/zlib/contrib/tests/OWNERS b/deps/zlib/contrib/tests/OWNERS
index 9a2fb6fbdc6b3f0..aa6a2d1bb3c0417 100644
--- a/deps/zlib/contrib/tests/OWNERS
+++ b/deps/zlib/contrib/tests/OWNERS
@@ -1 +1,2 @@
 cblume@chromium.org
+cavalcantii@chromium.org
diff --git a/deps/zlib/contrib/tests/fuzzers/BUILD.gn b/deps/zlib/contrib/tests/fuzzers/BUILD.gn
index c46b66440073a5d..10abe00c0515b67 100644
--- a/deps/zlib/contrib/tests/fuzzers/BUILD.gn
+++ b/deps/zlib/contrib/tests/fuzzers/BUILD.gn
@@ -9,37 +9,27 @@ group("fuzzers") {
 }
 
 fuzzer_test("zlib_uncompress_fuzzer") {
-  sources = [
-    "uncompress_fuzzer.cc",
-  ]
-  deps = [
-    "../../../:zlib",
-  ]
+  sources = [ "uncompress_fuzzer.cc" ]
+  deps = [ "../../../:zlib" ]
 }
 
 fuzzer_test("zlib_inflate_fuzzer") {
-  sources = [
-    "inflate_fuzzer.cc",
-  ]
-  deps = [
-    "../../../:zlib",
-  ]
+  sources = [ "inflate_fuzzer.cc" ]
+  deps = [ "../../../:zlib" ]
+}
+
+fuzzer_test("zlib_streaming_inflate_fuzzer") {
+  sources = [ "streaming_inflate_fuzzer.cc" ]
+  deps = [ "../../../:zlib" ]
+  libfuzzer_options = [ "max_len=256000" ]
 }
 
 fuzzer_test("zlib_deflate_set_dictionary_fuzzer") {
-  sources = [
-    "deflate_set_dictionary_fuzzer.cc",
-  ]
-  deps = [
-    "../../../:zlib",
-  ]
+  sources = [ "deflate_set_dictionary_fuzzer.cc" ]
+  deps = [ "../../../:zlib" ]
 }
 
 fuzzer_test("zlib_deflate_fuzzer") {
-  sources = [
-    "deflate_fuzzer.cc",
-  ]
-  deps = [
-    "../../../:zlib",
-  ]
+  sources = [ "deflate_fuzzer.cc" ]
+  deps = [ "../../../:zlib" ]
 }
diff --git a/deps/zlib/contrib/tests/fuzzers/deflate_fuzzer.cc b/deps/zlib/contrib/tests/fuzzers/deflate_fuzzer.cc
index 6098ff162ce1c03..c00e71551d80db9 100644
--- a/deps/zlib/contrib/tests/fuzzers/deflate_fuzzer.cc
+++ b/deps/zlib/contrib/tests/fuzzers/deflate_fuzzer.cc
@@ -2,46 +2,73 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <fuzzer/FuzzedDataProvider.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
-#include <cassert>
 #include <vector>
 
 #include "third_party/zlib/zlib.h"
 
-static Bytef buffer[256 * 1024] = {0};
+// Fuzzer builds often have NDEBUG set, so roll our own assert macro.
+#define ASSERT(cond)                                                           \
+  do {                                                                         \
+    if (!(cond)) {                                                             \
+      fprintf(stderr, "%s:%d Assert failed: %s\n", __FILE__, __LINE__, #cond); \
+      exit(1);                                                                 \
+    }                                                                          \
+  } while (0)
 
-// Entry point for LibFuzzer.
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  // zlib's deflate requires non-zero input sizes
-  if (!size)
-    return 0;
-
-  // We need to strip the 'const' for zlib.
-  std::vector<unsigned char> input_buffer{data, data+size};
-
-  uLongf buffer_length = static_cast<uLongf>(sizeof(buffer));
+  FuzzedDataProvider fdp(data, size);
+  int level = fdp.PickValueInArray({0, 1, 2, 3, 4, 5, 6, 7, 8, 9});
+  int windowBits = fdp.PickValueInArray({9, 10, 11, 12, 13, 14, 15});
+  int memLevel = fdp.PickValueInArray({1, 2, 3, 4, 5, 6, 7, 8, 9});
+  int strategy = fdp.PickValueInArray(
+      {Z_DEFAULT_STRATEGY, Z_FILTERED, Z_HUFFMAN_ONLY, Z_RLE, Z_FIXED});
+  std::vector<uint8_t> src = fdp.ConsumeRemainingBytes<uint8_t>();
 
   z_stream stream;
-  stream.next_in = input_buffer.data();
-  stream.avail_in = size;
-  stream.total_in = size;
-  stream.next_out = buffer;
-  stream.avail_out = buffer_length;
-  stream.total_out = buffer_length;
   stream.zalloc = Z_NULL;
   stream.zfree = Z_NULL;
 
-  if (Z_OK != deflateInit(&stream, Z_DEFAULT_COMPRESSION)) {
-    deflateEnd(&stream);
-    assert(false);
+  // Compress the data one byte at a time to exercise the streaming code.
+  int ret =
+      deflateInit2(&stream, level, Z_DEFLATED, windowBits, memLevel, strategy);
+  ASSERT(ret == Z_OK);
+  std::vector<uint8_t> compressed(src.size() * 2 + 1000);
+  stream.next_out = compressed.data();
+  stream.avail_out = compressed.size();
+  for (uint8_t b : src) {
+    stream.next_in = &b;
+    stream.avail_in = 1;
+    ret = deflate(&stream, Z_NO_FLUSH);
+    ASSERT(ret == Z_OK);
   }
-
-  auto deflate_result = deflate(&stream, Z_NO_FLUSH);
+  stream.next_in = Z_NULL;
+  stream.avail_in = 0;
+  ret = deflate(&stream, Z_FINISH);
+  ASSERT(ret == Z_STREAM_END);
+  compressed.resize(compressed.size() - stream.avail_out);
   deflateEnd(&stream);
-  if (Z_OK != deflate_result)
-    assert(false);
+
+  // Verify that the data decompresses correctly.
+  ret = inflateInit2(&stream, windowBits);
+  ASSERT(ret == Z_OK);
+  // Make room for at least one byte so it's never empty.
+  std::vector<uint8_t> decompressed(src.size() + 1);
+  stream.next_in = compressed.data();
+  stream.avail_in = compressed.size();
+  stream.next_out = decompressed.data();
+  stream.avail_out = decompressed.size();
+  ret = inflate(&stream, Z_FINISH);
+  ASSERT(ret == Z_STREAM_END);
+  decompressed.resize(decompressed.size() - stream.avail_out);
+  inflateEnd(&stream);
+
+  ASSERT(decompressed == src);
 
   return 0;
 }
diff --git a/deps/zlib/contrib/tests/fuzzers/streaming_inflate_fuzzer.cc b/deps/zlib/contrib/tests/fuzzers/streaming_inflate_fuzzer.cc
new file mode 100644
index 000000000000000..de4d216756cb425
--- /dev/null
+++ b/deps/zlib/contrib/tests/fuzzers/streaming_inflate_fuzzer.cc
@@ -0,0 +1,74 @@
+// Copyright 2020 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 <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "third_party/zlib/zlib.h"
+
+// Fuzzer builds often have NDEBUG set, so roll our own assert macro.
+#define ASSERT(cond)                                                           \
+  do {                                                                         \
+    if (!(cond)) {                                                             \
+      fprintf(stderr, "%s:%d Assert failed: %s\n", __FILE__, __LINE__, #cond); \
+      exit(1);                                                                 \
+    }                                                                          \
+  } while (0)
+
+// Entry point for LibFuzzer.
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+  // Deflate data.
+  z_stream comp_strm;
+  comp_strm.zalloc = Z_NULL;
+  comp_strm.zfree = Z_NULL;
+  comp_strm.opaque = Z_NULL;
+  int ret = deflateInit(&comp_strm, Z_DEFAULT_COMPRESSION);
+  ASSERT(ret == Z_OK);
+
+  size_t comp_buf_cap = deflateBound(&comp_strm, size);
+  uint8_t* comp_buf = (uint8_t*)malloc(comp_buf_cap);
+  ASSERT(comp_buf != nullptr);
+  comp_strm.next_out = comp_buf;
+  comp_strm.avail_out = comp_buf_cap;
+  comp_strm.next_in = (unsigned char*)data;
+  comp_strm.avail_in = size;
+  ret = deflate(&comp_strm, Z_FINISH);
+  ASSERT(ret == Z_STREAM_END);
+  size_t comp_sz = comp_buf_cap - comp_strm.avail_out;
+
+  // Inflate comp_buf one chunk at a time.
+  z_stream decomp_strm;
+  decomp_strm.zalloc = Z_NULL;
+  decomp_strm.zfree = Z_NULL;
+  decomp_strm.opaque = Z_NULL;
+  ret = inflateInit(&decomp_strm);
+  ASSERT(ret == Z_OK);
+  decomp_strm.next_in = comp_buf;
+  decomp_strm.avail_in = comp_sz;
+
+  while (decomp_strm.avail_in > 0) {
+    uint8_t decomp_buf[1024];
+    decomp_strm.next_out = decomp_buf;
+    decomp_strm.avail_out = sizeof(decomp_buf);
+    ret = inflate(&decomp_strm, Z_FINISH);
+    ASSERT(ret == Z_OK || ret == Z_STREAM_END || ret == Z_BUF_ERROR);
+
+    // Verify the output bytes.
+    size_t num_out = sizeof(decomp_buf) - decomp_strm.avail_out;
+    for (size_t i = 0; i < num_out; i++) {
+      ASSERT(decomp_buf[i] == data[decomp_strm.total_out - num_out + i]);
+    }
+  }
+
+  ret = deflateEnd(&comp_strm);
+  ASSERT(ret == Z_OK);
+  free(comp_buf);
+
+  inflateEnd(&decomp_strm);
+  ASSERT(ret == Z_OK);
+
+  return 0;
+}
diff --git a/deps/zlib/contrib/tests/infcover.cc b/deps/zlib/contrib/tests/infcover.cc
new file mode 100644
index 000000000000000..c5300a52111aa21
--- /dev/null
+++ b/deps/zlib/contrib/tests/infcover.cc
@@ -0,0 +1,684 @@
+/* infcover.c -- test zlib's inflate routines with full code coverage
+ * Copyright (C) 2011, 2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* to use, do: ./configure --cover && make cover */
+// clang-format off
+#include "infcover.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "zlib.h"
+
+/* get definition of internal structure so we can mess with it (see pull()),
+   and so we can call inflate_trees() (see cover5()) */
+#define ZLIB_INTERNAL
+#include "inftrees.h"
+#include "inflate.h"
+
+/* XXX: use C++ streams instead of printf/fputs/etc due to portability
+ * as type sizes can vary between platforms.
+ */
+#include <iostream>
+#define local static
+
+/* XXX: hacking C assert and plugging into GTest. */
+#include "gtest.h"
+#if defined(assert)
+#undef assert
+#define assert EXPECT_TRUE
+#endif
+
+/* XXX: handle what is a reserved word in C++. */
+#define try try_f
+
+/* -- memory tracking routines -- */
+
+/*
+   These memory tracking routines are provided to zlib and track all of zlib's
+   allocations and deallocations, check for LIFO operations, keep a current
+   and high water mark of total bytes requested, optionally set a limit on the
+   total memory that can be allocated, and when done check for memory leaks.
+
+   They are used as follows:
+
+   z_stream strm;
+   mem_setup(&strm)         initializes the memory tracking and sets the
+                            zalloc, zfree, and opaque members of strm to use
+                            memory tracking for all zlib operations on strm
+   mem_limit(&strm, limit)  sets a limit on the total bytes requested -- a
+                            request that exceeds this limit will result in an
+                            allocation failure (returns NULL) -- setting the
+                            limit to zero means no limit, which is the default
+                            after mem_setup()
+   mem_used(&strm, "msg")   prints to stderr "msg" and the total bytes used
+   mem_high(&strm, "msg")   prints to stderr "msg" and the high water mark
+   mem_done(&strm, "msg")   ends memory tracking, releases all allocations
+                            for the tracking as well as leaked zlib blocks, if
+                            any.  If there was anything unusual, such as leaked
+                            blocks, non-FIFO frees, or frees of addresses not
+                            allocated, then "msg" and information about the
+                            problem is printed to stderr.  If everything is
+                            normal, nothing is printed. mem_done resets the
+                            strm members to Z_NULL to use the default memory
+                            allocation routines on the next zlib initialization
+                            using strm.
+ */
+
+/* these items are strung together in a linked list, one for each allocation */
+struct mem_item {
+    void *ptr;                  /* pointer to allocated memory */
+    size_t size;                /* requested size of allocation */
+    struct mem_item *next;      /* pointer to next item in list, or NULL */
+};
+
+/* this structure is at the root of the linked list, and tracks statistics */
+struct mem_zone {
+    struct mem_item *first;     /* pointer to first item in list, or NULL */
+    size_t total, highwater;    /* total allocations, and largest total */
+    size_t limit;               /* memory allocation limit, or 0 if no limit */
+    int notlifo, rogue;         /* counts of non-LIFO frees and rogue frees */
+};
+
+/* memory allocation routine to pass to zlib */
+local void *mem_alloc(void *mem, unsigned count, unsigned size)
+{
+    void *ptr;
+    struct mem_item *item;
+    struct mem_zone *zone = static_cast<struct mem_zone *>(mem);
+    size_t len = count * (size_t)size;
+
+    /* induced allocation failure */
+    if (zone == NULL || (zone->limit && zone->total + len > zone->limit))
+        return NULL;
+
+    /* perform allocation using the standard library, fill memory with a
+       non-zero value to make sure that the code isn't depending on zeros */
+    ptr = malloc(len);
+    if (ptr == NULL)
+        return NULL;
+    memset(ptr, 0xa5, len);
+
+    /* create a new item for the list */
+    item = static_cast<struct mem_item *>(malloc(sizeof(struct mem_item)));
+    if (item == NULL) {
+        free(ptr);
+        return NULL;
+    }
+    item->ptr = ptr;
+    item->size = len;
+
+    /* insert item at the beginning of the list */
+    item->next = zone->first;
+    zone->first = item;
+
+    /* update the statistics */
+    zone->total += item->size;
+    if (zone->total > zone->highwater)
+        zone->highwater = zone->total;
+
+    /* return the allocated memory */
+    return ptr;
+}
+
+/* memory free routine to pass to zlib */
+local void mem_free(void *mem, void *ptr)
+{
+    struct mem_item *item, *next;
+    struct mem_zone *zone = static_cast<struct mem_zone *>(mem);
+
+    /* if no zone, just do a free */
+    if (zone == NULL) {
+        free(ptr);
+        return;
+    }
+
+    /* point next to the item that matches ptr, or NULL if not found -- remove
+       the item from the linked list if found */
+    next = zone->first;
+    if (next) {
+        if (next->ptr == ptr)
+            zone->first = next->next;   /* first one is it, remove from list */
+        else {
+            do {                        /* search the linked list */
+                item = next;
+                next = item->next;
+            } while (next != NULL && next->ptr != ptr);
+            if (next) {                 /* if found, remove from linked list */
+                item->next = next->next;
+                zone->notlifo++;        /* not a LIFO free */
+            }
+
+        }
+    }
+
+    /* if found, update the statistics and free the item */
+    if (next) {
+        zone->total -= next->size;
+        free(next);
+    }
+
+    /* if not found, update the rogue count */
+    else
+        zone->rogue++;
+
+    /* in any case, do the requested free with the standard library function */
+    free(ptr);
+}
+
+/* set up a controlled memory allocation space for monitoring, set the stream
+   parameters to the controlled routines, with opaque pointing to the space */
+local void mem_setup(z_stream *strm)
+{
+    struct mem_zone *zone;
+
+    zone = static_cast<struct mem_zone *>(malloc(sizeof(struct mem_zone)));
+    assert(zone != NULL);
+    zone->first = NULL;
+    zone->total = 0;
+    zone->highwater = 0;
+    zone->limit = 0;
+    zone->notlifo = 0;
+    zone->rogue = 0;
+    strm->opaque = zone;
+    strm->zalloc = mem_alloc;
+    strm->zfree = mem_free;
+}
+
+/* set a limit on the total memory allocation, or 0 to remove the limit */
+local void mem_limit(z_stream *strm, size_t limit)
+{
+    struct mem_zone *zone = static_cast<struct mem_zone *>(strm->opaque);
+
+    zone->limit = limit;
+}
+
+/* show the current total requested allocations in bytes */
+local void mem_used(z_stream *strm, const char *prefix)
+{
+    struct mem_zone *zone = static_cast<struct mem_zone *>(strm->opaque);
+
+    std::cout << prefix << ": " << zone->total << " allocated" << std::endl;
+}
+
+/* show the high water allocation in bytes */
+local void mem_high(z_stream *strm, const char *prefix)
+{
+    struct mem_zone *zone = static_cast<struct mem_zone *>(strm->opaque);
+
+    std::cout << prefix << ": " << zone->highwater << " high water mark" << std::endl;
+}
+
+/* release the memory allocation zone -- if there are any surprises, notify */
+local void mem_done(z_stream *strm, const char *prefix)
+{
+    int count = 0;
+    struct mem_item *item, *next;
+    struct mem_zone *zone = static_cast<struct mem_zone *>(strm->opaque);
+
+    /* show high water mark */
+    mem_high(strm, prefix);
+
+    /* free leftover allocations and item structures, if any */
+    item = zone->first;
+    while (item != NULL) {
+        free(item->ptr);
+        next = item->next;
+        free(item);
+        item = next;
+        count++;
+    }
+
+    /* issue alerts about anything unexpected */
+    if (count || zone->total)
+        std::cout << "** " << prefix << ": "
+                  << zone->total << " bytes in "
+                  << count << " blocks not freed"
+                  << std::endl;
+
+    if (zone->notlifo)
+        std::cout << "** " << prefix << ": "
+                  << zone->notlifo << " frees not LIFO"
+                  << std::endl;
+
+    if (zone->rogue)
+        std::cout << "** " << prefix << ": "
+                  << zone->rogue << " frees not recognized"
+                  << std::endl;
+
+    /* free the zone and delete from the stream */
+    free(zone);
+    strm->opaque = Z_NULL;
+    strm->zalloc = Z_NULL;
+    strm->zfree = Z_NULL;
+}
+
+/* -- inflate test routines -- */
+
+/* Decode a hexadecimal string, set *len to length, in[] to the bytes.  This
+   decodes liberally, in that hex digits can be adjacent, in which case two in
+   a row writes a byte.  Or they can be delimited by any non-hex character,
+   where the delimiters are ignored except when a single hex digit is followed
+   by a delimiter, where that single digit writes a byte.  The returned data is
+   allocated and must eventually be freed.  NULL is returned if out of memory.
+   If the length is not needed, then len can be NULL. */
+local unsigned char *h2b(const char *hex, unsigned *len)
+{
+    unsigned char *in, *re;
+    unsigned next, val;
+
+    in = static_cast<unsigned char *>(malloc((strlen(hex) + 1) >> 1));
+    if (in == NULL)
+        return NULL;
+    next = 0;
+    val = 1;
+    do {
+        if (*hex >= '0' && *hex <= '9')
+            val = (val << 4) + *hex - '0';
+        else if (*hex >= 'A' && *hex <= 'F')
+            val = (val << 4) + *hex - 'A' + 10;
+        else if (*hex >= 'a' && *hex <= 'f')
+            val = (val << 4) + *hex - 'a' + 10;
+        else if (val != 1 && val < 32)  /* one digit followed by delimiter */
+            val += 240;                 /* make it look like two digits */
+        if (val > 255) {                /* have two digits */
+            in[next++] = val & 0xff;    /* save the decoded byte */
+            val = 1;                    /* start over */
+        }
+    } while (*hex++);       /* go through the loop with the terminating null */
+    if (len != NULL)
+        *len = next;
+    re = static_cast<unsigned char *>(realloc(in, next));
+    return re == NULL ? in : re;
+}
+
+/* generic inflate() run, where hex is the hexadecimal input data, what is the
+   text to include in an error message, step is how much input data to feed
+   inflate() on each call, or zero to feed it all, win is the window bits
+   parameter to inflateInit2(), len is the size of the output buffer, and err
+   is the error code expected from the first inflate() call (the second
+   inflate() call is expected to return Z_STREAM_END).  If win is 47, then
+   header information is collected with inflateGetHeader().  If a zlib stream
+   is looking for a dictionary, then an empty dictionary is provided.
+   inflate() is run until all of the input data is consumed. */
+local void inf(const char *hex, const char *what, unsigned step, int win, unsigned len,
+               int err)
+{
+    int ret;
+    unsigned have;
+    unsigned char *in, *out;
+    z_stream strm, copy;
+    gz_header head;
+
+    mem_setup(&strm);
+    strm.avail_in = 0;
+    strm.next_in = Z_NULL;
+    ret = inflateInit2(&strm, win);
+    if (ret != Z_OK) {
+        mem_done(&strm, what);
+        return;
+    }
+    out = static_cast<unsigned char *>(malloc(len));                          assert(out != NULL);
+    if (win == 47) {
+        head.extra = out;
+        head.extra_max = len;
+        head.name = out;
+        head.name_max = len;
+        head.comment = out;
+        head.comm_max = len;
+        ret = inflateGetHeader(&strm, &head);   assert(ret == Z_OK);
+    }
+    in = h2b(hex, &have);                       assert(in != NULL);
+    if (step == 0 || step > have)
+        step = have;
+    strm.avail_in = step;
+    have -= step;
+    strm.next_in = in;
+    do {
+        strm.avail_out = len;
+        strm.next_out = out;
+        ret = inflate(&strm, Z_NO_FLUSH);       assert(err == 9 || ret == err);
+        if (ret != Z_OK && ret != Z_BUF_ERROR && ret != Z_NEED_DICT)
+            break;
+        if (ret == Z_NEED_DICT) {
+            ret = inflateSetDictionary(&strm, in, 1);
+                                                assert(ret == Z_DATA_ERROR);
+            mem_limit(&strm, 1);
+            ret = inflateSetDictionary(&strm, out, 0);
+                                                assert(ret == Z_MEM_ERROR);
+            mem_limit(&strm, 0);
+            ((struct inflate_state *)strm.state)->mode = DICT;
+            ret = inflateSetDictionary(&strm, out, 0);
+                                                assert(ret == Z_OK);
+            ret = inflate(&strm, Z_NO_FLUSH);   assert(ret == Z_BUF_ERROR);
+        }
+        ret = inflateCopy(&copy, &strm);        assert(ret == Z_OK);
+        ret = inflateEnd(&copy);                assert(ret == Z_OK);
+        err = 9;                        /* don't care next time around */
+        have += strm.avail_in;
+        strm.avail_in = step > have ? have : step;
+        have -= strm.avail_in;
+    } while (strm.avail_in);
+    free(in);
+    free(out);
+    ret = inflateReset2(&strm, -8);             assert(ret == Z_OK);
+    ret = inflateEnd(&strm);                    assert(ret == Z_OK);
+    mem_done(&strm, what);
+}
+
+/* cover all of the lines in inflate.c up to inflate() */
+void cover_support(void)
+{
+    int ret;
+    z_stream strm;
+
+    mem_setup(&strm);
+    strm.avail_in = 0;
+    strm.next_in = Z_NULL;
+    ret = inflateInit(&strm);                   assert(ret == Z_OK);
+    mem_used(&strm, "inflate init");
+    ret = inflatePrime(&strm, 5, 31);           assert(ret == Z_OK);
+    ret = inflatePrime(&strm, -1, 0);           assert(ret == Z_OK);
+    ret = inflateSetDictionary(&strm, Z_NULL, 0);
+                                                assert(ret == Z_STREAM_ERROR);
+    ret = inflateEnd(&strm);                    assert(ret == Z_OK);
+    mem_done(&strm, "prime");
+
+    inf("63 0", "force window allocation", 0, -15, 1, Z_OK);
+    inf("63 18 5", "force window replacement", 0, -8, 259, Z_OK);
+    inf("63 18 68 30 d0 0 0", "force split window update", 4, -8, 259, Z_OK);
+    inf("3 0", "use fixed blocks", 0, -15, 1, Z_STREAM_END);
+    inf("", "bad window size", 0, 1, 0, Z_STREAM_ERROR);
+
+    mem_setup(&strm);
+    strm.avail_in = 0;
+    strm.next_in = Z_NULL;
+    ret = inflateInit_(&strm, ZLIB_VERSION - 1, (int)sizeof(z_stream));
+                                                assert(ret == Z_VERSION_ERROR);
+    mem_done(&strm, "wrong version");
+
+    strm.avail_in = 0;
+    strm.next_in = Z_NULL;
+    ret = inflateInit(&strm);                   assert(ret == Z_OK);
+    ret = inflateEnd(&strm);                    assert(ret == Z_OK);
+    std::cout << "inflate built-in memory routines" << std::endl;;
+}
+
+/* cover all inflate() header and trailer cases and code after inflate() */
+void cover_wrap(void)
+{
+    int ret;
+    z_stream strm, copy;
+    unsigned char dict[257];
+
+    ret = inflate(Z_NULL, 0);                   assert(ret == Z_STREAM_ERROR);
+    ret = inflateEnd(Z_NULL);                   assert(ret == Z_STREAM_ERROR);
+    ret = inflateCopy(Z_NULL, Z_NULL);          assert(ret == Z_STREAM_ERROR);
+    std::cout << "inflate bad parameters" << std::endl;
+
+    inf("1f 8b 0 0", "bad gzip method", 0, 31, 0, Z_DATA_ERROR);
+    inf("1f 8b 8 80", "bad gzip flags", 0, 31, 0, Z_DATA_ERROR);
+    inf("77 85", "bad zlib method", 0, 15, 0, Z_DATA_ERROR);
+    inf("8 99", "set window size from header", 0, 0, 0, Z_OK);
+    inf("78 9c", "bad zlib window size", 0, 8, 0, Z_DATA_ERROR);
+    inf("78 9c 63 0 0 0 1 0 1", "check adler32", 0, 15, 1, Z_STREAM_END);
+    inf("1f 8b 8 1e 0 0 0 0 0 0 1 0 0 0 0 0 0", "bad header crc", 0, 47, 1,
+        Z_DATA_ERROR);
+    inf("1f 8b 8 2 0 0 0 0 0 0 1d 26 3 0 0 0 0 0 0 0 0 0", "check gzip length",
+        0, 47, 0, Z_STREAM_END);
+    inf("78 90", "bad zlib header check", 0, 47, 0, Z_DATA_ERROR);
+    inf("8 b8 0 0 0 1", "need dictionary", 0, 8, 0, Z_NEED_DICT);
+    inf("78 9c 63 0", "compute adler32", 0, 15, 1, Z_OK);
+
+    mem_setup(&strm);
+    strm.avail_in = 0;
+    strm.next_in = Z_NULL;
+    ret = inflateInit2(&strm, -8);
+    strm.avail_in = 2;
+    strm.next_in = (Bytef *)"\x63";
+    strm.avail_out = 1;
+    strm.next_out = (Bytef *)&ret;
+    mem_limit(&strm, 1);
+    ret = inflate(&strm, Z_NO_FLUSH);           assert(ret == Z_MEM_ERROR);
+    ret = inflate(&strm, Z_NO_FLUSH);           assert(ret == Z_MEM_ERROR);
+    mem_limit(&strm, 0);
+    memset(dict, 0, 257);
+    ret = inflateSetDictionary(&strm, dict, 257);
+                                                assert(ret == Z_OK);
+    mem_limit(&strm, (sizeof(struct inflate_state) << 1) + 256);
+    ret = inflatePrime(&strm, 16, 0);           assert(ret == Z_OK);
+    strm.avail_in = 2;
+    strm.next_in = (Bytef *)"\x80";
+    ret = inflateSync(&strm);                   assert(ret == Z_DATA_ERROR);
+    ret = inflate(&strm, Z_NO_FLUSH);           assert(ret == Z_STREAM_ERROR);
+    strm.avail_in = 4;
+    strm.next_in = (Bytef *)"\0\0\xff\xff";
+    ret = inflateSync(&strm);                   assert(ret == Z_OK);
+    (void)inflateSyncPoint(&strm);
+    ret = inflateCopy(&copy, &strm);            assert(ret == Z_MEM_ERROR);
+    mem_limit(&strm, 0);
+    ret = inflateUndermine(&strm, 1);           assert(ret == Z_DATA_ERROR);
+    (void)inflateMark(&strm);
+    ret = inflateEnd(&strm);                    assert(ret == Z_OK);
+    mem_done(&strm, "miscellaneous, force memory errors");
+}
+
+/* input and output functions for inflateBack() */
+local unsigned pull(void *desc, unsigned char **buf)
+{
+    static unsigned int next = 0;
+    static unsigned char dat[] = {0x63, 0, 2, 0};
+    struct inflate_state *state;
+
+    if (desc == Z_NULL) {
+        next = 0;
+        return 0;   /* no input (already provided at next_in) */
+    }
+    state = reinterpret_cast<struct inflate_state *>(((z_stream *)desc)->state);
+    if (state != Z_NULL)
+        state->mode = SYNC;     /* force an otherwise impossible situation */
+    return next < sizeof(dat) ? (*buf = dat + next++, 1) : 0;
+}
+
+local int push(void *desc, unsigned char *buf, unsigned len)
+{
+    buf += len;
+    return desc != Z_NULL;      /* force error if desc not null */
+}
+
+/* cover inflateBack() up to common deflate data cases and after those */
+void cover_back(void)
+{
+    int ret;
+    z_stream strm;
+    unsigned char win[32768];
+
+    ret = inflateBackInit_(Z_NULL, 0, win, 0, 0);
+                                                assert(ret == Z_VERSION_ERROR);
+    ret = inflateBackInit(Z_NULL, 0, win);      assert(ret == Z_STREAM_ERROR);
+    ret = inflateBack(Z_NULL, Z_NULL, Z_NULL, Z_NULL, Z_NULL);
+                                                assert(ret == Z_STREAM_ERROR);
+    ret = inflateBackEnd(Z_NULL);               assert(ret == Z_STREAM_ERROR);
+    std::cout << "inflateBack bad parameters" << std::endl;;
+
+    mem_setup(&strm);
+    ret = inflateBackInit(&strm, 15, win);      assert(ret == Z_OK);
+    strm.avail_in = 2;
+    strm.next_in = (Bytef *)"\x03";
+    ret = inflateBack(&strm, pull, Z_NULL, push, Z_NULL);
+                                                assert(ret == Z_STREAM_END);
+        /* force output error */
+    strm.avail_in = 3;
+    strm.next_in = (Bytef *)"\x63\x00";
+    ret = inflateBack(&strm, pull, Z_NULL, push, &strm);
+                                                assert(ret == Z_BUF_ERROR);
+        /* force mode error by mucking with state */
+    ret = inflateBack(&strm, pull, &strm, push, Z_NULL);
+                                                assert(ret == Z_STREAM_ERROR);
+    ret = inflateBackEnd(&strm);                assert(ret == Z_OK);
+    mem_done(&strm, "inflateBack bad state");
+
+    ret = inflateBackInit(&strm, 15, win);      assert(ret == Z_OK);
+    ret = inflateBackEnd(&strm);                assert(ret == Z_OK);
+    std::cout << "inflateBack built-in memory routines" << std::endl;;
+}
+
+/* do a raw inflate of data in hexadecimal with both inflate and inflateBack */
+local int try(const char *hex, const char *id, int err)
+{
+    int ret;
+    unsigned len, size;
+    unsigned char *in, *out, *win;
+    char *prefix;
+    z_stream strm;
+
+    /* convert to hex */
+    in = h2b(hex, &len);
+    assert(in != NULL);
+
+    /* allocate work areas */
+    size = len << 3;
+    out = static_cast<unsigned char *>(malloc(size));
+    assert(out != NULL);
+    win = static_cast<unsigned char *>(malloc(32768));
+    assert(win != NULL);
+    prefix = static_cast<char *>(malloc(strlen(id) + 6));
+    assert(prefix != NULL);
+
+    /* first with inflate */
+    strcpy(prefix, id);
+    strcat(prefix, "-late");
+    mem_setup(&strm);
+    strm.avail_in = 0;
+    strm.next_in = Z_NULL;
+    ret = inflateInit2(&strm, err < 0 ? 47 : -15);
+    assert(ret == Z_OK);
+    strm.avail_in = len;
+    strm.next_in = in;
+    do {
+        strm.avail_out = size;
+        strm.next_out = out;
+        ret = inflate(&strm, Z_TREES);
+        assert(ret != Z_STREAM_ERROR && ret != Z_MEM_ERROR);
+        if (ret == Z_DATA_ERROR || ret == Z_NEED_DICT)
+            break;
+    } while (strm.avail_in || strm.avail_out == 0);
+    if (err) {
+        assert(ret == Z_DATA_ERROR);
+        assert(strcmp(id, strm.msg) == 0);
+    }
+    inflateEnd(&strm);
+    mem_done(&strm, prefix);
+
+    /* then with inflateBack */
+    if (err >= 0) {
+        strcpy(prefix, id);
+        strcat(prefix, "-back");
+        mem_setup(&strm);
+        ret = inflateBackInit(&strm, 15, win);
+        assert(ret == Z_OK);
+        strm.avail_in = len;
+        strm.next_in = in;
+        ret = inflateBack(&strm, pull, Z_NULL, push, Z_NULL);
+        assert(ret != Z_STREAM_ERROR);
+        if (err) {
+            assert(ret == Z_DATA_ERROR);
+            assert(strcmp(id, strm.msg) == 0);
+        }
+        inflateBackEnd(&strm);
+        mem_done(&strm, prefix);
+    }
+
+    /* clean up */
+    free(prefix);
+    free(win);
+    free(out);
+    free(in);
+    return ret;
+}
+
+/* cover deflate data cases in both inflate() and inflateBack() */
+void cover_inflate(void)
+{
+    try("0 0 0 0 0", "invalid stored block lengths", 1);
+    try("3 0", "fixed", 0);
+    try("6", "invalid block type", 1);
+    try("1 1 0 fe ff 0", "stored", 0);
+    try("fc 0 0", "too many length or distance symbols", 1);
+    try("4 0 fe ff", "invalid code lengths set", 1);
+    try("4 0 24 49 0", "invalid bit length repeat", 1);
+    try("4 0 24 e9 ff ff", "invalid bit length repeat", 1);
+    try("4 0 24 e9 ff 6d", "invalid code -- missing end-of-block", 1);
+    try("4 80 49 92 24 49 92 24 71 ff ff 93 11 0",
+        "invalid literal/lengths set", 1);
+    try("4 80 49 92 24 49 92 24 f b4 ff ff c3 84", "invalid distances set", 1);
+    try("4 c0 81 8 0 0 0 0 20 7f eb b 0 0", "invalid literal/length code", 1);
+    try("2 7e ff ff", "invalid distance code", 1);
+    try("c c0 81 0 0 0 0 0 90 ff 6b 4 0", "invalid distance too far back", 1);
+
+    /* also trailer mismatch just in inflate() */
+    try("1f 8b 8 0 0 0 0 0 0 0 3 0 0 0 0 1", "incorrect data check", -1);
+    try("1f 8b 8 0 0 0 0 0 0 0 3 0 0 0 0 0 0 0 0 1",
+        "incorrect length check", -1);
+    try("5 c0 21 d 0 0 0 80 b0 fe 6d 2f 91 6c", "pull 17", 0);
+    try("5 e0 81 91 24 cb b2 2c 49 e2 f 2e 8b 9a 47 56 9f fb fe ec d2 ff 1f",
+        "long code", 0);
+    try("ed c0 1 1 0 0 0 40 20 ff 57 1b 42 2c 4f", "length extra", 0);
+    try("ed cf c1 b1 2c 47 10 c4 30 fa 6f 35 1d 1 82 59 3d fb be 2e 2a fc f c",
+        "long distance and extra", 0);
+    try("ed c0 81 0 0 0 0 80 a0 fd a9 17 a9 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 "
+        "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6", "window end", 0);
+    inf("2 8 20 80 0 3 0", "inflate_fast TYPE return", 0, -15, 258,
+        Z_STREAM_END);
+    inf("63 18 5 40 c 0", "window wrap", 3, -8, 300, Z_OK);
+}
+
+/* XXX(cavalcantii): fix linking error due inflate_table. */
+/* cover remaining lines in inftrees.c */
+/* void cover_trees(void) */
+/* { */
+/*     int ret; */
+/*     unsigned bits; */
+/*     unsigned short lens[16], work[16]; */
+/*     code *next, table[ENOUGH_DISTS]; */
+
+/*     /\* we need to call inflate_table() directly in order to manifest not- */
+/*        enough errors, since zlib insures that enough is always enough *\/ */
+/*     for (bits = 0; bits < 15; bits++) */
+/*         lens[bits] = (unsigned short)(bits + 1); */
+/*     lens[15] = 15; */
+/*     next = table; */
+/*     bits = 15; */
+/*     ret = inflate_table(DISTS, lens, 16, &next, &bits, work); */
+/*                                                 assert(ret == 1); */
+/*     next = table; */
+/*     bits = 1; */
+/*     ret = inflate_table(DISTS, lens, 16, &next, &bits, work); */
+/*                                                 assert(ret == 1); */
+/*     fputs("inflate_table not enough errors\n", stderr); */
+/* } */
+
+/* cover remaining inffast.c decoding and window copying */
+void cover_fast(void)
+{
+    inf("e5 e0 81 ad 6d cb b2 2c c9 01 1e 59 63 ae 7d ee fb 4d fd b5 35 41 68"
+        " ff 7f 0f 0 0 0", "fast length extra bits", 0, -8, 258, Z_DATA_ERROR);
+    inf("25 fd 81 b5 6d 59 b6 6a 49 ea af 35 6 34 eb 8c b9 f6 b9 1e ef 67 49"
+        " 50 fe ff ff 3f 0 0", "fast distance extra bits", 0, -8, 258,
+        Z_DATA_ERROR);
+    inf("3 7e 0 0 0 0 0", "fast invalid distance code", 0, -8, 258,
+        Z_DATA_ERROR);
+    inf("1b 7 0 0 0 0 0", "fast invalid literal/length code", 0, -8, 258,
+        Z_DATA_ERROR);
+    inf("d c7 1 ae eb 38 c 4 41 a0 87 72 de df fb 1f b8 36 b1 38 5d ff ff 0",
+        "fast 2nd level codes and too far back", 0, -8, 258, Z_DATA_ERROR);
+    inf("63 18 5 8c 10 8 0 0 0 0", "very common case", 0, -8, 259, Z_OK);
+    inf("63 60 60 18 c9 0 8 18 18 18 26 c0 28 0 29 0 0 0",
+        "contiguous and wrap around window", 6, -8, 259, Z_OK);
+    inf("63 0 3 0 0 0 0 0", "copy direct from output", 0, -8, 259,
+        Z_STREAM_END);
+}
+
+// clang-format on
diff --git a/deps/zlib/contrib/tests/infcover.h b/deps/zlib/contrib/tests/infcover.h
new file mode 100644
index 000000000000000..b3e112f9154cbe5
--- /dev/null
+++ b/deps/zlib/contrib/tests/infcover.h
@@ -0,0 +1,11 @@
+#ifndef __INF_COVER_H__
+#define __INF_COVER_H__
+
+void cover_support(void);
+void cover_wrap(void);
+void cover_back(void);
+void cover_inflate(void);
+void cover_trees(void);
+void cover_fast(void);
+
+#endif
diff --git a/deps/zlib/contrib/tests/run_all_unittests.cc b/deps/zlib/contrib/tests/run_all_unittests.cc
new file mode 100644
index 000000000000000..65ed57e7fd70992
--- /dev/null
+++ b/deps/zlib/contrib/tests/run_all_unittests.cc
@@ -0,0 +1,14 @@
+// Copyright 2020 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 "base/bind.h"
+#include "base/test/launcher/unit_test_launcher.h"
+#include "base/test/test_suite.h"
+
+int main(int argc, char** argv) {
+  base::TestSuite test_suite(argc, argv);
+  return base::LaunchUnitTests(
+      argc, argv,
+      base::BindOnce(&base::TestSuite::Run, base::Unretained(&test_suite)));
+}
diff --git a/deps/zlib/contrib/tests/utils_unittest.cc b/deps/zlib/contrib/tests/utils_unittest.cc
new file mode 100644
index 000000000000000..35df3a8f279ff35
--- /dev/null
+++ b/deps/zlib/contrib/tests/utils_unittest.cc
@@ -0,0 +1,420 @@
+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the Chromium source repository LICENSE file.
+
+#include "infcover.h"
+
+#include <cstddef>
+#include <vector>
+
+#include "compression_utils_portable.h"
+#include "gtest.h"
+#include "zlib.h"
+
+void TestPayloads(size_t input_size, zlib_internal::WrapperType type) {
+  std::vector<unsigned char> input;
+  input.reserve(input_size);
+  for (size_t i = 1; i <= input_size; ++i)
+    input.push_back(i & 0xff);
+
+  // If it is big enough for GZIP, will work for other wrappers.
+  std::vector<unsigned char> compressed(
+      zlib_internal::GzipExpectedCompressedSize(input.size()));
+  std::vector<unsigned char> decompressed(input.size());
+
+  // Libcores's java/util/zip/Deflater default settings: ZLIB,
+  // DEFAULT_COMPRESSION and DEFAULT_STRATEGY.
+  unsigned long compressed_size = static_cast<unsigned long>(compressed.size());
+  int result = zlib_internal::CompressHelper(
+      type, compressed.data(), &compressed_size, input.data(), input.size(),
+      Z_DEFAULT_COMPRESSION, nullptr, nullptr);
+  ASSERT_EQ(result, Z_OK);
+
+  unsigned long decompressed_size =
+      static_cast<unsigned long>(decompressed.size());
+  result = zlib_internal::UncompressHelper(type, decompressed.data(),
+                                           &decompressed_size,
+                                           compressed.data(), compressed_size);
+  ASSERT_EQ(result, Z_OK);
+  EXPECT_EQ(input, decompressed);
+}
+
+TEST(ZlibTest, ZlibWrapper) {
+  // Minimal ZLIB wrapped short stream size is about 8 bytes.
+  for (size_t i = 1; i < 1024; ++i)
+    TestPayloads(i, zlib_internal::WrapperType::ZLIB);
+}
+
+TEST(ZlibTest, GzipWrapper) {
+  // GZIP should be 12 bytes bigger than ZLIB wrapper.
+  for (size_t i = 1; i < 1024; ++i)
+    TestPayloads(i, zlib_internal::WrapperType::GZIP);
+}
+
+TEST(ZlibTest, RawWrapper) {
+  // RAW has no wrapper (V8 Blobs is a known user), size
+  // should be payload_size + 2 for short payloads.
+  for (size_t i = 1; i < 1024; ++i)
+    TestPayloads(i, zlib_internal::WrapperType::ZRAW);
+}
+
+TEST(ZlibTest, InflateCover) {
+  cover_support();
+  cover_wrap();
+  cover_back();
+  cover_inflate();
+  // TODO(cavalcantii): enable this last test.
+  // cover_trees();
+  cover_fast();
+}
+
+TEST(ZlibTest, DeflateStored) {
+  const int no_compression = 0;
+  const zlib_internal::WrapperType type = zlib_internal::WrapperType::GZIP;
+  std::vector<unsigned char> input(1 << 10, 42);
+  std::vector<unsigned char> compressed(
+      zlib_internal::GzipExpectedCompressedSize(input.size()));
+  std::vector<unsigned char> decompressed(input.size());
+  unsigned long compressed_size = static_cast<unsigned long>(compressed.size());
+  int result = zlib_internal::CompressHelper(
+      type, compressed.data(), &compressed_size, input.data(), input.size(),
+      no_compression, nullptr, nullptr);
+  ASSERT_EQ(result, Z_OK);
+
+  unsigned long decompressed_size =
+      static_cast<unsigned long>(decompressed.size());
+  result = zlib_internal::UncompressHelper(type, decompressed.data(),
+                                           &decompressed_size,
+                                           compressed.data(), compressed_size);
+  ASSERT_EQ(result, Z_OK);
+  EXPECT_EQ(input, decompressed);
+}
+
+TEST(ZlibTest, StreamingInflate) {
+  uint8_t comp_buf[4096], decomp_buf[4096];
+  z_stream comp_strm, decomp_strm;
+  int ret;
+
+  std::vector<uint8_t> src;
+  for (size_t i = 0; i < 1000; i++) {
+    for (size_t j = 0; j < 40; j++) {
+      src.push_back(j);
+    }
+  }
+
+  // Deflate src into comp_buf.
+  comp_strm.zalloc = Z_NULL;
+  comp_strm.zfree = Z_NULL;
+  comp_strm.opaque = Z_NULL;
+  ret = deflateInit(&comp_strm, Z_BEST_COMPRESSION);
+  ASSERT_EQ(ret, Z_OK);
+  comp_strm.next_out = comp_buf;
+  comp_strm.avail_out = sizeof(comp_buf);
+  comp_strm.next_in = src.data();
+  comp_strm.avail_in = src.size();
+  ret = deflate(&comp_strm, Z_FINISH);
+  ASSERT_EQ(ret, Z_STREAM_END);
+  size_t comp_sz = sizeof(comp_buf) - comp_strm.avail_out;
+
+  // Inflate comp_buf one 4096-byte buffer at a time.
+  decomp_strm.zalloc = Z_NULL;
+  decomp_strm.zfree = Z_NULL;
+  decomp_strm.opaque = Z_NULL;
+  ret = inflateInit(&decomp_strm);
+  ASSERT_EQ(ret, Z_OK);
+  decomp_strm.next_in = comp_buf;
+  decomp_strm.avail_in = comp_sz;
+
+  while (decomp_strm.avail_in > 0) {
+    decomp_strm.next_out = decomp_buf;
+    decomp_strm.avail_out = sizeof(decomp_buf);
+    ret = inflate(&decomp_strm, Z_FINISH);
+    ASSERT_TRUE(ret == Z_OK || ret == Z_STREAM_END || ret == Z_BUF_ERROR);
+
+    // Verify the output bytes.
+    size_t num_out = sizeof(decomp_buf) - decomp_strm.avail_out;
+    for (size_t i = 0; i < num_out; i++) {
+      EXPECT_EQ(decomp_buf[i], src[decomp_strm.total_out - num_out + i]);
+    }
+  }
+
+  // Cleanup memory (i.e. makes ASAN bot happy).
+  ret = deflateEnd(&comp_strm);
+  EXPECT_EQ(ret, Z_OK);
+  ret = inflateEnd(&decomp_strm);
+  EXPECT_EQ(ret, Z_OK);
+}
+
+TEST(ZlibTest, CRCHashBitsCollision) {
+  // The CRC32c of the hex sequences 2a,14,14,14 and 2a,14,db,14 have the same
+  // lower 9 bits. Since longest_match doesn't check match[2], a bad match could
+  // be chosen when the number of hash bits is <= 9. For this reason, the number
+  // of hash bits must be set higher, regardless of the memlevel parameter, when
+  // using CRC32c hashing for string matching. See https://crbug.com/1113596
+
+  std::vector<uint8_t> src = {
+      // Random byte; zlib doesn't match at offset 0.
+      123,
+
+      // This will look like 5-byte match.
+      0x2a,
+      0x14,
+      0xdb,
+      0x14,
+      0x15,
+
+      // Offer a 4-byte match to bump the next expected match length to 5.
+      0x2a,
+      0x14,
+      0x14,
+      0x14,
+
+      0x2a,
+      0x14,
+      0x14,
+      0x14,
+      0x15,
+  };
+
+  z_stream stream;
+  stream.zalloc = nullptr;
+  stream.zfree = nullptr;
+
+  // Using a low memlevel to try to reduce the number of hash bits. Negative
+  // windowbits means raw deflate, i.e. without the zlib header.
+  int ret = deflateInit2(&stream, /*comp level*/ 2, /*method*/ Z_DEFLATED,
+                         /*windowbits*/ -15, /*memlevel*/ 2,
+                         /*strategy*/ Z_DEFAULT_STRATEGY);
+  ASSERT_EQ(ret, Z_OK);
+  std::vector<uint8_t> compressed(100, '\0');
+  stream.next_out = compressed.data();
+  stream.avail_out = compressed.size();
+  stream.next_in = src.data();
+  stream.avail_in = src.size();
+  ret = deflate(&stream, Z_FINISH);
+  ASSERT_EQ(ret, Z_STREAM_END);
+  compressed.resize(compressed.size() - stream.avail_out);
+  deflateEnd(&stream);
+
+  ret = inflateInit2(&stream, /*windowbits*/ -15);
+  ASSERT_EQ(ret, Z_OK);
+  std::vector<uint8_t> decompressed(src.size(), '\0');
+  stream.next_in = compressed.data();
+  stream.avail_in = compressed.size();
+  stream.next_out = decompressed.data();
+  stream.avail_out = decompressed.size();
+  ret = inflate(&stream, Z_FINISH);
+  ASSERT_EQ(ret, Z_STREAM_END);
+  EXPECT_EQ(0U, stream.avail_out);
+  inflateEnd(&stream);
+
+  EXPECT_EQ(src, decompressed);
+}
+
+TEST(ZlibTest, CRCHashAssert) {
+  // The CRC32c of the hex sequences ff,ff,5e,6f and ff,ff,13,ff have the same
+  // lower 15 bits. This means longest_match's assert that match[2] == scan[2]
+  // won't hold. However, such hash collisions are only possible when one of the
+  // other four bytes also mismatch. This tests that zlib's assert handles this
+  // case.
+
+  std::vector<uint8_t> src = {
+      // Random byte; zlib doesn't match at offset 0.
+      123,
+
+      // This has the same hash as the last byte sequence, and the first two and
+      // last two bytes match; though the third and the fourth don't.
+      0xff,
+      0xff,
+      0x5e,
+      0x6f,
+      0x12,
+      0x34,
+
+      // Offer a 5-byte match to bump the next expected match length to 6
+      // (because the two first and two last bytes need to match).
+      0xff,
+      0xff,
+      0x13,
+      0xff,
+      0x12,
+
+      0xff,
+      0xff,
+      0x13,
+      0xff,
+      0x12,
+      0x34,
+  };
+
+  z_stream stream;
+  stream.zalloc = nullptr;
+  stream.zfree = nullptr;
+
+  int ret = deflateInit2(&stream, /*comp level*/ 5, /*method*/ Z_DEFLATED,
+                         /*windowbits*/ -15, /*memlevel*/ 8,
+                         /*strategy*/ Z_DEFAULT_STRATEGY);
+  ASSERT_EQ(ret, Z_OK);
+  std::vector<uint8_t> compressed(100, '\0');
+  stream.next_out = compressed.data();
+  stream.avail_out = compressed.size();
+  stream.next_in = src.data();
+  stream.avail_in = src.size();
+  ret = deflate(&stream, Z_FINISH);
+  ASSERT_EQ(ret, Z_STREAM_END);
+  compressed.resize(compressed.size() - stream.avail_out);
+  deflateEnd(&stream);
+
+  ret = inflateInit2(&stream, /*windowbits*/ -15);
+  ASSERT_EQ(ret, Z_OK);
+  std::vector<uint8_t> decompressed(src.size(), '\0');
+  stream.next_in = compressed.data();
+  stream.avail_in = compressed.size();
+  stream.next_out = decompressed.data();
+  stream.avail_out = decompressed.size();
+  ret = inflate(&stream, Z_FINISH);
+  ASSERT_EQ(ret, Z_STREAM_END);
+  EXPECT_EQ(0U, stream.avail_out);
+  inflateEnd(&stream);
+
+  EXPECT_EQ(src, decompressed);
+}
+
+// Fuzzer generated.
+static const uint8_t checkMatchCrashData[] = {
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc5, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00,
+    0x6e, 0x6e, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x6e, 0x01, 0x39, 0x6e, 0x6e,
+    0x00, 0x00, 0x00, 0x00, 0xf7, 0xff, 0x00, 0x00, 0x00, 0x00, 0x6e, 0x6e,
+    0x00, 0x00, 0x0a, 0x9a, 0x00, 0x00, 0x6e, 0x6e, 0x6e, 0x2a, 0x00, 0x00,
+    0x00, 0xd5, 0xf0, 0x00, 0x81, 0x02, 0xf3, 0xfd, 0xff, 0xab, 0xf3, 0x6e,
+    0x7e, 0x04, 0x5b, 0xf6, 0x2a, 0x2c, 0xf8, 0x00, 0x54, 0xf3, 0xa5, 0x0e,
+    0xfd, 0x6e, 0xff, 0x00, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0xa4, 0x0b, 0xa5, 0x2a, 0x0d, 0x10, 0x01, 0x26, 0xf6, 0x04, 0x0e,
+    0xff, 0x6e, 0x6e, 0x6e, 0x76, 0x00, 0x00, 0x87, 0x01, 0xfe, 0x0d, 0xb6,
+    0x6e, 0x6e, 0xf7, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xfd, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x29, 0x00, 0x9b,
+    0x02, 0x00, 0x00, 0x00, 0x00, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+    0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x6e, 0xff, 0xff, 0x00,
+    0x00, 0xd5, 0xf0, 0x00, 0xff, 0x40, 0x7e, 0x0b, 0xa5, 0x10, 0x67, 0x01,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x40, 0x7e, 0x0b, 0xa5, 0x10, 0x67,
+    0x7e, 0x32, 0x6e, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x40, 0x0b, 0xa5,
+    0x10, 0x67, 0x01, 0xfe, 0x0d, 0xb6, 0x2a, 0x00, 0x00, 0x58, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x6e, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x3d, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xd6, 0x2d, 0x2d, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+    0x8a, 0x8a, 0x8a, 0x8a, 0x66, 0x8a, 0x8a, 0x8a, 0xee, 0x1d, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0xee, 0x0a, 0x00, 0x00, 0x00, 0x54, 0x40,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xf3, 0x00, 0x00, 0xff, 0xff, 0x23, 0x7e, 0x00, 0x1e,
+    0x00, 0x00, 0xd5, 0xf0, 0x00, 0xff, 0x40, 0x0b, 0xa5, 0x10, 0x67, 0x01,
+    0xfe, 0x0d, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+    0x8a, 0x8a, 0x8a, 0x2d, 0x6e, 0x2d, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x0e,
+    0xfb, 0x00, 0x10, 0x24, 0x00, 0x00, 0xfb, 0xff, 0x00, 0x00, 0xff, 0x1f,
+    0xb3, 0x00, 0x04, 0x3d, 0x00, 0xee, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00,
+    0x01, 0x45, 0x3d, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x11, 0x21, 0x00, 0x1e,
+    0x00, 0x0c, 0xb3, 0xfe, 0x0e, 0xee, 0x02, 0x00, 0x1d, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x6e, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x6e, 0x00,
+    0x00, 0x87, 0x00, 0x33, 0x38, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x00, 0x00,
+    0x00, 0x38, 0x00, 0x00, 0xff, 0xff, 0xff, 0x04, 0x3f, 0xff, 0xff, 0xff,
+    0x00, 0x00, 0x00, 0x00, 0xf0, 0x00, 0xff, 0x00, 0x31, 0x13, 0x13, 0x13,
+    0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xab, 0x30, 0x83, 0x33,
+    0x00, 0x00, 0x01, 0x05, 0x00, 0x00, 0xff, 0xff, 0x7d, 0xff, 0x00, 0x01,
+    0x10, 0x0d, 0x2a, 0xa5, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0x00, 0x11,
+    0x21, 0x00, 0xa5, 0x00, 0x68, 0x68, 0x68, 0x67, 0x00, 0x00, 0xff, 0xff,
+    0x02, 0x00, 0x00, 0x68, 0x68, 0x68, 0x68, 0x00, 0x00, 0xfa, 0xff, 0xff,
+    0x03, 0x01, 0xff, 0x02, 0x00, 0x00, 0x68, 0x68, 0x68, 0x68, 0x0a, 0x10,
+    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
+    0x06, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xfa, 0xff, 0xff, 0x08, 0xff, 0xff, 0xff, 0x00, 0x06, 0x04,
+    0x00, 0xf8, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00,
+    0x00, 0xff, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x78, 0x00, 0x00, 0x01, 0x00, 0xff, 0xff, 0xff, 0x00, 0x06, 0x04, 0x6e,
+    0x7e, 0x87, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00,
+    0x00, 0x6e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x87, 0x6e, 0x6e, 0x6e,
+    0x00, 0x01, 0x38, 0xd5, 0xf0, 0x00, 0x00, 0x2a, 0xfe, 0x04, 0x5b, 0x0d,
+    0xfd, 0x6e, 0x92, 0x28, 0xf9, 0xfb, 0xff, 0x07, 0xd2, 0xd6, 0x2d, 0x2d,
+    0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
+    0x8a, 0x8a, 0xc2, 0x91, 0x00, 0x5b, 0xef, 0xde, 0xf2, 0x6e, 0x6e, 0xfd,
+    0x0c, 0x02, 0x91, 0x62, 0x91, 0xfd, 0x6e, 0x6e, 0xd3, 0x06, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00,
+    0xd5, 0xf0, 0x00, 0xff, 0x00, 0x00, 0x31, 0x13, 0x13, 0x13, 0x04, 0x00,
+    0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x04, 0x00, 0x13, 0x0a, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x6e, 0x00, 0x00, 0x01,
+    0x00, 0x00, 0x09, 0x00, 0x6a, 0x24, 0x26, 0x30, 0x01, 0x2e, 0x2a, 0xfe,
+    0x04, 0x5b, 0x0d, 0xfd, 0x6e, 0x6e, 0xd7, 0x06, 0x6e, 0x6e, 0x6e, 0x00,
+    0x00, 0xb1, 0xb1, 0xb1, 0xb1, 0x00, 0x00, 0x00, 0x6e, 0x5b, 0x00, 0x00,
+    0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x01, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x1e, 0x00, 0x00, 0x00, 0x87, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6b, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x0b,
+    0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x24, 0x2a, 0x6e, 0x5c, 0x24,
+    0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x87, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xeb,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x40, 0x00, 0x40, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x05, 0x00, 0x00, 0x00, 0x5d, 0x10, 0x6e, 0x6e, 0xa5, 0x2f, 0x00, 0x00,
+    0x95, 0x87, 0x00, 0x6e};
+
+TEST(ZlibTest, CheckMatchCrash) {
+  // See https://crbug.com/1113142.
+  z_stream stream;
+  stream.zalloc = nullptr;
+  stream.zfree = nullptr;
+
+  // Low windowbits to hit window sliding also with a relatively small input.
+  int ret = deflateInit2(&stream, /*comp level*/ 5, /*method*/ Z_DEFLATED,
+                         /*windowbits*/ -9, /*memlevel*/ 8,
+                         /*strategy*/ Z_DEFAULT_STRATEGY);
+  ASSERT_EQ(ret, Z_OK);
+
+  uint8_t compressed[sizeof(checkMatchCrashData) * 2];
+  stream.next_out = compressed;
+  stream.avail_out = sizeof(compressed);
+
+  for (size_t i = 0; i < sizeof(checkMatchCrashData); i++) {
+    ASSERT_GT(stream.avail_out, 0U);
+    stream.next_in = (uint8_t*)&checkMatchCrashData[i];
+    stream.avail_in = 1;
+    ret = deflate(&stream, Z_NO_FLUSH);
+    ASSERT_EQ(ret, Z_OK);
+  }
+
+  stream.next_in = nullptr;
+  stream.avail_in = 0;
+  ASSERT_GT(stream.avail_out, 0U);
+  ret = deflate(&stream, Z_FINISH);
+  ASSERT_EQ(ret, Z_STREAM_END);
+  size_t compressed_sz = sizeof(compressed) - stream.avail_out;
+  deflateEnd(&stream);
+
+  uint8_t decompressed[sizeof(checkMatchCrashData)];
+  ret = inflateInit2(&stream, -15);
+  ASSERT_EQ(ret, Z_OK);
+  stream.next_in = compressed;
+  stream.avail_in = compressed_sz;
+  stream.next_out = decompressed;
+  stream.avail_out = sizeof(decompressed);
+  ret = inflate(&stream, Z_FINISH);
+  ASSERT_EQ(ret, Z_STREAM_END);
+  inflateEnd(&stream);
+  ASSERT_EQ(
+      memcmp(checkMatchCrashData, decompressed, sizeof(checkMatchCrashData)),
+      0);
+}
diff --git a/deps/zlib/cpu_features.c b/deps/zlib/cpu_features.c
new file mode 100644
index 000000000000000..70f01beebe30b59
--- /dev/null
+++ b/deps/zlib/cpu_features.c
@@ -0,0 +1,167 @@
+/* cpu_features.c -- Processor features detection.
+ *
+ * Copyright 2018 The Chromium Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the Chromium source repository LICENSE file.
+ */
+
+#include "cpu_features.h"
+#include "zutil.h"
+
+#include <stdint.h>
+#if defined(_MSC_VER)
+#include <intrin.h>
+#elif defined(ADLER32_SIMD_SSSE3)
+#include <cpuid.h>
+#endif
+
+/* TODO(cavalcantii): remove checks for x86_flags on deflate.
+ */
+#if defined(ARMV8_OS_MACOS)
+/* crc32 is a baseline feature in ARMv8.1-A, and macOS running on arm64 is new
+ * enough that this can be assumed without runtime detection. */
+int ZLIB_INTERNAL arm_cpu_enable_crc32 = 1;
+#else
+int ZLIB_INTERNAL arm_cpu_enable_crc32 = 0;
+#endif
+int ZLIB_INTERNAL arm_cpu_enable_pmull = 0;
+int ZLIB_INTERNAL x86_cpu_enable_sse2 = 0;
+int ZLIB_INTERNAL x86_cpu_enable_ssse3 = 0;
+int ZLIB_INTERNAL x86_cpu_enable_simd = 0;
+
+#ifndef CPU_NO_SIMD
+
+#if defined(ARMV8_OS_ANDROID) || defined(ARMV8_OS_LINUX) || defined(ARMV8_OS_FUCHSIA)
+#include <pthread.h>
+#endif
+
+#if defined(ARMV8_OS_ANDROID)
+#include <cpu-features.h>
+#elif defined(ARMV8_OS_LINUX)
+#include <asm/hwcap.h>
+#include <sys/auxv.h>
+#elif defined(ARMV8_OS_FUCHSIA)
+#include <zircon/features.h>
+#include <zircon/syscalls.h>
+#include <zircon/types.h>
+#elif defined(ARMV8_OS_WINDOWS) || defined(X86_WINDOWS)
+#include <windows.h>
+#elif !defined(_MSC_VER)
+#include <pthread.h>
+#else
+#error cpu_features.c CPU feature detection in not defined for your platform
+#endif
+
+#if !defined(CPU_NO_SIMD) && !defined(ARMV8_OS_MACOS) && !defined(ARM_OS_IOS)
+static void _cpu_check_features(void);
+#endif
+
+#if defined(ARMV8_OS_ANDROID) || defined(ARMV8_OS_LINUX) || defined(ARMV8_OS_MACOS) || defined(ARMV8_OS_FUCHSIA) || defined(X86_NOT_WINDOWS)
+#if !defined(ARMV8_OS_MACOS)
+// _cpu_check_features() doesn't need to do anything on mac/arm since all
+// features are known at build time, so don't call it.
+// Do provide cpu_check_features() (with a no-op implementation) so that we
+// don't have to make all callers of it check for mac/arm.
+static pthread_once_t cpu_check_inited_once = PTHREAD_ONCE_INIT;
+#endif
+void ZLIB_INTERNAL cpu_check_features(void)
+{
+#if !defined(ARMV8_OS_MACOS)
+    pthread_once(&cpu_check_inited_once, _cpu_check_features);
+#endif
+}
+#elif defined(ARMV8_OS_WINDOWS) || defined(X86_WINDOWS)
+static INIT_ONCE cpu_check_inited_once = INIT_ONCE_STATIC_INIT;
+static BOOL CALLBACK _cpu_check_features_forwarder(PINIT_ONCE once, PVOID param, PVOID* context)
+{
+    _cpu_check_features();
+    return TRUE;
+}
+void ZLIB_INTERNAL cpu_check_features(void)
+{
+    InitOnceExecuteOnce(&cpu_check_inited_once, _cpu_check_features_forwarder,
+                        NULL, NULL);
+}
+#endif
+
+#if (defined(__ARM_NEON__) || defined(__ARM_NEON))
+/*
+ * iOS@ARM is a special case where we always have NEON but don't check
+ * for crypto extensions.
+ */
+#if !defined(ARMV8_OS_MACOS) && !defined(ARM_OS_IOS)
+/*
+ * See http://bit.ly/2CcoEsr for run-time detection of ARM features and also
+ * crbug.com/931275 for android_getCpuFeatures() use in the Android sandbox.
+ */
+static void _cpu_check_features(void)
+{
+#if defined(ARMV8_OS_ANDROID) && defined(__aarch64__)
+    uint64_t features = android_getCpuFeatures();
+    arm_cpu_enable_crc32 = !!(features & ANDROID_CPU_ARM64_FEATURE_CRC32);
+    arm_cpu_enable_pmull = !!(features & ANDROID_CPU_ARM64_FEATURE_PMULL);
+#elif defined(ARMV8_OS_ANDROID) /* aarch32 */
+    uint64_t features = android_getCpuFeatures();
+    arm_cpu_enable_crc32 = !!(features & ANDROID_CPU_ARM_FEATURE_CRC32);
+    arm_cpu_enable_pmull = !!(features & ANDROID_CPU_ARM_FEATURE_PMULL);
+#elif defined(ARMV8_OS_LINUX) && defined(__aarch64__)
+    unsigned long features = getauxval(AT_HWCAP);
+    arm_cpu_enable_crc32 = !!(features & HWCAP_CRC32);
+    arm_cpu_enable_pmull = !!(features & HWCAP_PMULL);
+#elif defined(ARMV8_OS_LINUX) && (defined(__ARM_NEON) || defined(__ARM_NEON__))
+    /* Query HWCAP2 for ARMV8-A SoCs running in aarch32 mode */
+    unsigned long features = getauxval(AT_HWCAP2);
+    arm_cpu_enable_crc32 = !!(features & HWCAP2_CRC32);
+    arm_cpu_enable_pmull = !!(features & HWCAP2_PMULL);
+#elif defined(ARMV8_OS_FUCHSIA)
+    uint32_t features;
+    zx_status_t rc = zx_system_get_features(ZX_FEATURE_KIND_CPU, &features);
+    if (rc != ZX_OK || (features & ZX_ARM64_FEATURE_ISA_ASIMD) == 0)
+        return;  /* Report nothing if ASIMD(NEON) is missing */
+    arm_cpu_enable_crc32 = !!(features & ZX_ARM64_FEATURE_ISA_CRC32);
+    arm_cpu_enable_pmull = !!(features & ZX_ARM64_FEATURE_ISA_PMULL);
+#elif defined(ARMV8_OS_WINDOWS)
+    arm_cpu_enable_crc32 = IsProcessorFeaturePresent(PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE);
+    arm_cpu_enable_pmull = IsProcessorFeaturePresent(PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE);
+#endif
+}
+#endif
+#elif defined(X86_NOT_WINDOWS) || defined(X86_WINDOWS)
+/*
+ * iOS@x86 (i.e. emulator) is another special case where we disable
+ * SIMD optimizations.
+ */
+#ifndef CPU_NO_SIMD
+/* On x86 we simply use a instruction to check the CPU features.
+ * (i.e. CPUID).
+ */
+static void _cpu_check_features(void)
+{
+    int x86_cpu_has_sse2;
+    int x86_cpu_has_ssse3;
+    int x86_cpu_has_sse42;
+    int x86_cpu_has_pclmulqdq;
+    int abcd[4];
+
+#ifdef _MSC_VER
+    __cpuid(abcd, 1);
+#else
+    __cpuid(1, abcd[0], abcd[1], abcd[2], abcd[3]);
+#endif
+
+    x86_cpu_has_sse2 = abcd[3] & 0x4000000;
+    x86_cpu_has_ssse3 = abcd[2] & 0x000200;
+    x86_cpu_has_sse42 = abcd[2] & 0x100000;
+    x86_cpu_has_pclmulqdq = abcd[2] & 0x2;
+
+    x86_cpu_enable_sse2 = x86_cpu_has_sse2;
+
+    x86_cpu_enable_ssse3 = x86_cpu_has_ssse3;
+
+    x86_cpu_enable_simd = x86_cpu_has_sse2 &&
+                          x86_cpu_has_sse42 &&
+                          x86_cpu_has_pclmulqdq;
+}
+#endif
+#endif
+#endif
diff --git a/deps/zlib/arm_features.h b/deps/zlib/cpu_features.h
similarity index 53%
rename from deps/zlib/arm_features.h
rename to deps/zlib/cpu_features.h
index 09fec259b1c9248..c7b15c5597623fc 100644
--- a/deps/zlib/arm_features.h
+++ b/deps/zlib/cpu_features.h
@@ -1,4 +1,4 @@
-/* arm_features.h -- ARM processor features detection.
+/* cpu_features.h -- Processor features detection.
  *
  * Copyright 2018 The Chromium Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
@@ -7,7 +7,12 @@
 
 #include "zlib.h"
 
+/* TODO(cavalcantii): remove checks for x86_flags on deflate.
+ */
 extern int arm_cpu_enable_crc32;
 extern int arm_cpu_enable_pmull;
+extern int x86_cpu_enable_sse2;
+extern int x86_cpu_enable_ssse3;
+extern int x86_cpu_enable_simd;
 
-void arm_check_features(void);
+void cpu_check_features(void);
diff --git a/deps/zlib/crc32.c b/deps/zlib/crc32.c
index e95b9087351c1a4..d4c3248d98415be 100644
--- a/deps/zlib/crc32.c
+++ b/deps/zlib/crc32.c
@@ -29,13 +29,10 @@
 #endif /* MAKECRCH */
 
 #include "deflate.h"
-#include "x86.h"
+#include "cpu_features.h"
 #include "zutil.h"      /* for STDC and FAR definitions */
 
-#if defined(CRC32_SIMD_SSE42_PCLMUL)
-#include "crc32_simd.h"
-#elif defined(CRC32_ARMV8_CRC32)
-#include "arm_features.h"
+#if defined(CRC32_SIMD_SSE42_PCLMUL) || defined(CRC32_ARMV8_CRC32)
 #include "crc32_simd.h"
 #endif
 
@@ -226,7 +223,7 @@ unsigned long ZEXPORT crc32_z(crc, buf, len)
      */
     if (buf == Z_NULL) {
         if (!len) /* Assume user is calling crc32(0, NULL, 0); */
-            x86_check_features();
+            cpu_check_features();
         return 0UL;
     }
 
@@ -289,7 +286,7 @@ unsigned long ZEXPORT crc32(crc, buf, len)
      */
     if (buf == Z_NULL) {
         if (!len) /* Assume user is calling crc32(0, NULL, 0); */
-            arm_check_features();
+            cpu_check_features();
         return 0UL;
     }
 
@@ -500,25 +497,31 @@ uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
 
 ZLIB_INTERNAL void crc_reset(deflate_state *const s)
 {
+#ifdef CRC32_SIMD_SSE42_PCLMUL
     if (x86_cpu_enable_simd) {
         crc_fold_init(s);
         return;
     }
+#endif
     s->strm->adler = crc32(0L, Z_NULL, 0);
 }
 
 ZLIB_INTERNAL void crc_finalize(deflate_state *const s)
 {
+#ifdef CRC32_SIMD_SSE42_PCLMUL
     if (x86_cpu_enable_simd)
         s->strm->adler = crc_fold_512to32(s);
+#endif
 }
 
 ZLIB_INTERNAL void copy_with_crc(z_streamp strm, Bytef *dst, long size)
 {
+#ifdef CRC32_SIMD_SSE42_PCLMUL
     if (x86_cpu_enable_simd) {
         crc_fold_copy(strm->state, dst, strm->next_in, size);
         return;
     }
+#endif
     zmemcpy(dst, strm->next_in, size);
     strm->adler = crc32(strm->adler, dst, size);
 }
diff --git a/deps/zlib/crc32_simd.c b/deps/zlib/crc32_simd.c
index 27481847e97b90e..c8e5592f38ef1e4 100644
--- a/deps/zlib/crc32_simd.c
+++ b/deps/zlib/crc32_simd.c
@@ -8,9 +8,6 @@
 #include "crc32_simd.h"
 
 #if defined(CRC32_SIMD_SSE42_PCLMUL)
-#ifndef __GNUC__
-#define __attribute__()
-#endif
 
 /*
  * crc32_sse42_simd_(): compute the crc32 of the buffer, where the buffer
@@ -24,7 +21,6 @@
 #include <smmintrin.h>
 #include <wmmintrin.h>
 
-__attribute__((target("sse4.2,pclmul")))
 uint32_t ZLIB_INTERNAL crc32_sse42_simd_(  /* SSE4.2+PCLMUL */
     const unsigned char *buf,
     z_size_t len,
diff --git a/deps/zlib/crc_folding.c b/deps/zlib/crc_folding.c
index 54f4b5c94010893..ee31d4918d6413d 100644
--- a/deps/zlib/crc_folding.c
+++ b/deps/zlib/crc_folding.c
@@ -18,15 +18,13 @@
 
 #include "deflate.h"
 
+#ifdef CRC32_SIMD_SSE42_PCLMUL
+
 #include <inttypes.h>
 #include <emmintrin.h>
 #include <immintrin.h>
 #include <wmmintrin.h>
 
-#ifndef __GNUC__
-#define __attribute__()
-#endif
-
 #define CRC_LOAD(s) \
     do { \
         __m128i xmm_crc0 = _mm_loadu_si128((__m128i *)s->crc0 + 0);\
@@ -43,7 +41,6 @@
         _mm_storeu_si128((__m128i *)s->crc0 + 4, xmm_crc_part);\
     } while (0);
 
-__attribute__((target("sse4.2,pclmul")))
 ZLIB_INTERNAL void crc_fold_init(deflate_state *const s)
 {
     CRC_LOAD(s)
@@ -58,7 +55,6 @@ ZLIB_INTERNAL void crc_fold_init(deflate_state *const s)
     s->strm->adler = 0;
 }
 
-__attribute__((target("sse4.2,pclmul")))
 local void fold_1(deflate_state *const s,
         __m128i *xmm_crc0, __m128i *xmm_crc1,
         __m128i *xmm_crc2, __m128i *xmm_crc3)
@@ -85,7 +81,6 @@ local void fold_1(deflate_state *const s,
     *xmm_crc3 = _mm_castps_si128(ps_res);
 }
 
-__attribute__((target("sse4.2,pclmul")))
 local void fold_2(deflate_state *const s,
         __m128i *xmm_crc0, __m128i *xmm_crc1,
         __m128i *xmm_crc2, __m128i *xmm_crc3)
@@ -120,7 +115,6 @@ local void fold_2(deflate_state *const s,
     *xmm_crc3 = _mm_castps_si128(ps_res31);
 }
 
-__attribute__((target("sse4.2,pclmul")))
 local void fold_3(deflate_state *const s,
         __m128i *xmm_crc0, __m128i *xmm_crc1,
         __m128i *xmm_crc2, __m128i *xmm_crc3)
@@ -161,7 +155,6 @@ local void fold_3(deflate_state *const s,
     *xmm_crc3 = _mm_castps_si128(ps_res32);
 }
 
-__attribute__((target("sse4.2,pclmul")))
 local void fold_4(deflate_state *const s,
         __m128i *xmm_crc0, __m128i *xmm_crc1,
         __m128i *xmm_crc2, __m128i *xmm_crc3)
@@ -228,7 +221,6 @@ local const unsigned zalign(32) pshufb_shf_table[60] = {
 	0x0201008f,0x06050403,0x0a090807,0x0e0d0c0b  /* shl  1 (16 -15)/shr15*/
 };
 
-__attribute__((target("sse4.2,pclmul")))
 local void partial_fold(deflate_state *const s, const size_t len,
         __m128i *xmm_crc0, __m128i *xmm_crc1,
         __m128i *xmm_crc2, __m128i *xmm_crc3,
@@ -279,7 +271,6 @@ local void partial_fold(deflate_state *const s, const size_t len,
     *xmm_crc3 = _mm_castps_si128(ps_res);
 }
 
-__attribute__((target("sse4.2,pclmul")))
 ZLIB_INTERNAL void crc_fold_copy(deflate_state *const s,
         unsigned char *dst, const unsigned char *src, long len)
 {
@@ -294,7 +285,7 @@ ZLIB_INTERNAL void crc_fold_copy(deflate_state *const s,
         goto partial;
     }
 
-    algn_diff = 0 - (uintptr_t)src & 0xF;
+    algn_diff = (0 - (uintptr_t)src) & 0xF;
     if (algn_diff) {
         xmm_crc_part = _mm_loadu_si128((__m128i *)src);
         _mm_storeu_si128((__m128i *)dst, xmm_crc_part);
@@ -436,7 +427,6 @@ local const unsigned zalign(16) crc_mask2[4] = {
     0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF
 };
 
-__attribute__((target("sse4.2,pclmul")))
 unsigned ZLIB_INTERNAL crc_fold_512to32(deflate_state *const s)
 {
     const __m128i xmm_mask  = _mm_load_si128((__m128i *)crc_mask);
@@ -503,3 +493,5 @@ unsigned ZLIB_INTERNAL crc_fold_512to32(deflate_state *const s)
     return ~crc;
     CRC_SAVE(s)
 }
+
+#endif  /* CRC32_SIMD_SSE42_PCLMUL */
diff --git a/deps/zlib/deflate.c b/deps/zlib/deflate.c
index 201254ac1b664eb..8bf93e524875203 100644
--- a/deps/zlib/deflate.c
+++ b/deps/zlib/deflate.c
@@ -50,7 +50,7 @@
 /* @(#) $Id$ */
 #include <assert.h>
 #include "deflate.h"
-#include "x86.h"
+#include "cpu_features.h"
 #include "contrib/optimizations/insert_string.h"
 
 #if (defined(__ARM_NEON__) || defined(__ARM_NEON))
@@ -60,6 +60,11 @@
 #include "crc32_simd.h"
 #endif
 
+#ifdef FASTEST
+/* See http://crbug.com/1113596 */
+#error "FASTEST is not supported in Chromium's zlib."
+#endif
+
 const char deflate_copyright[] =
    " deflate 1.2.11 Copyright 1995-2017 Jean-loup Gailly and Mark Adler ";
 /*
@@ -244,10 +249,8 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
     // for all wrapper formats (e.g. RAW, ZLIB, GZIP).
     // Feature detection is not triggered while using RAW mode (i.e. we never
     // call crc32() with a NULL buffer).
-#if defined(CRC32_ARMV8_CRC32)
-    arm_check_features();
-#elif defined(CRC32_SIMD_SSE42_PCLMUL)
-    x86_check_features();
+#if defined(CRC32_ARMV8_CRC32) || defined(CRC32_SIMD_SSE42_PCLMUL)
+    cpu_check_features();
 #endif
 
     if (version == Z_NULL || version[0] != my_version[0] ||
@@ -306,10 +309,9 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
     s->w_size = 1 << s->w_bits;
     s->w_mask = s->w_size - 1;
 
-    if (x86_cpu_enable_simd) {
+    s->hash_bits = memLevel + 7;
+    if ((x86_cpu_enable_simd || arm_cpu_enable_crc32) && s->hash_bits < 15) {
         s->hash_bits = 15;
-    } else {
-        s->hash_bits = memLevel + 7;
     }
 
     s->hash_size = 1 << s->hash_bits;
@@ -320,6 +322,10 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
                                  s->w_size + window_padding,
                                  2*sizeof(Byte));
     s->prev   = (Posf *)  ZALLOC(strm, s->w_size, sizeof(Pos));
+    /* Avoid use of uninitialized value, see:
+     * https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=11360
+     */
+    zmemzero(s->prev, s->w_size * sizeof(Pos));
     s->head   = (Posf *)  ZALLOC(strm, s->hash_size, sizeof(Pos));
 
     s->high_water = 0;      /* nothing written to s->window yet */
@@ -1211,7 +1217,7 @@ ZLIB_INTERNAL unsigned deflate_read_buf(strm, buf, size)
 #ifdef GZIP
     if (strm->state->wrap == 2)
         copy_with_crc(strm, buf, len);
-    else 
+    else
 #endif
     {
         zmemcpy(buf, strm->next_in, len);
@@ -1344,7 +1350,16 @@ local uInt longest_match(s, cur_match)
          * necessary to put more guard bytes at the end of the window, or
          * to check more often for insufficient lookahead.
          */
-        Assert(scan[2] == match[2], "scan[2]?");
+        if (!x86_cpu_enable_simd && !arm_cpu_enable_crc32) {
+          Assert(scan[2] == match[2], "scan[2]?");
+        } else {
+          /* When using CRC hashing, scan[2] and match[2] may mismatch, but in
+           * that case at least one of the other hashed bytes will mismatch
+           * also. Bytes 0 and 1 were already checked above, and we know there
+           * are at least four bytes to check otherwise the mismatch would have
+           * been found by the scan_end comparison above, so: */
+          Assert(scan[2] == match[2] || scan[3] != match[3], "scan[2]??");
+        }
         scan++, match++;
         do {
         } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
@@ -1375,7 +1390,16 @@ local uInt longest_match(s, cur_match)
          * the hash keys are equal and that HASH_BITS >= 8.
          */
         scan += 2, match++;
-        Assert(*scan == *match, "match[2]?");
+        if (!x86_cpu_enable_simd && !arm_cpu_enable_crc32) {
+          Assert(*scan == *match, "match[2]?");
+        } else {
+          /* When using CRC hashing, scan[2] and match[2] may mismatch, but in
+           * that case at least one of the other hashed bytes will mismatch
+           * also. Bytes 0 and 1 were already checked above, and we know there
+           * are at least four bytes to check otherwise the mismatch would have
+           * been found by the scan_end comparison above, so: */
+          Assert(*scan == *match || scan[1] != match[1], "match[2]??");
+        }
 
         /* We check for insufficient lookahead only every 8th comparison;
          * the 256th check will be made at strstart+258.
@@ -1519,11 +1543,12 @@ local void fill_window_c(deflate_state *s);
 
 local void fill_window(deflate_state *s)
 {
+#ifdef DEFLATE_FILL_WINDOW_SSE2
     if (x86_cpu_enable_simd) {
         fill_window_sse(s);
         return;
     }
-
+#endif
     fill_window_c(s);
 }
 
@@ -2035,7 +2060,13 @@ local block_state deflate_slow(s, flush)
             uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
             /* Do not insert strings in hash table beyond this. */
 
-            check_match(s, s->strstart-1, s->prev_match, s->prev_length);
+            if (s->prev_match == -1) {
+                /* The window has slid one byte past the previous match,
+                 * so the first byte cannot be compared. */
+                check_match(s, s->strstart, s->prev_match+1, s->prev_length-1);
+            } else {
+                check_match(s, s->strstart-1, s->prev_match, s->prev_length);
+            }
 
             _tr_tally_dist(s, s->strstart -1 - s->prev_match,
                            s->prev_length - MIN_MATCH, bflush);
diff --git a/deps/zlib/fill_window_sse.c b/deps/zlib/fill_window_sse.c
index ed1e5d1d6735b12..a841c99904baeee 100644
--- a/deps/zlib/fill_window_sse.c
+++ b/deps/zlib/fill_window_sse.c
@@ -9,9 +9,10 @@
  * For conditions of distribution and use, see copyright notice in zlib.h
  */
 
-#include <immintrin.h>
 #include "deflate.h"
 
+#ifdef DEFLATE_FILL_WINDOW_SSE2
+
 #define UPDATE_HASH(s,h,i) \
     {\
         if (s->level < 6) { \
@@ -28,6 +29,8 @@
 
 extern int deflate_read_buf OF((z_streamp strm, Bytef *buf, unsigned size));
 
+#include <immintrin.h>
+
 void fill_window_sse(deflate_state *s)
 {
     const __m128i xmm_wsize = _mm_set1_epi16(s->w_size);
@@ -175,3 +178,5 @@ void fill_window_sse(deflate_state *s)
     Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
            "not enough room for search");
 }
+
+#endif  /* DEFLATE_FILL_WINDOW_SSE2 */
diff --git a/deps/zlib/google/BUILD.gn b/deps/zlib/google/BUILD.gn
index 4024836205f64c3..a49b8c81b2aff3d 100644
--- a/deps/zlib/google/BUILD.gn
+++ b/deps/zlib/google/BUILD.gn
@@ -42,7 +42,5 @@ static_library("compression_utils_portable") {
     "compression_utils_portable.cc",
     "compression_utils_portable.h",
   ]
-  deps = [
-    "//third_party/zlib",
-  ]
+  public_deps = [ "//third_party/zlib" ]
 }
diff --git a/deps/zlib/google/DEPS b/deps/zlib/google/DEPS
index 144fbd149295b32..03f2cb950b9517a 100644
--- a/deps/zlib/google/DEPS
+++ b/deps/zlib/google/DEPS
@@ -2,4 +2,5 @@ include_rules = [
   '+base',
   '+build',
   '+testing',
+  "+third_party/zlib/zlib.h",
 ]
diff --git a/deps/zlib/google/OWNERS b/deps/zlib/google/OWNERS
index 1ca253146311244..868af3cc6628527 100644
--- a/deps/zlib/google/OWNERS
+++ b/deps/zlib/google/OWNERS
@@ -3,3 +3,4 @@ satorux@chromium.org
 # compression_utils*
 asvitkine@chromium.org
 isherman@chromium.org
+cavalcantii@chromium.org
diff --git a/deps/zlib/google/compression_utils.cc b/deps/zlib/google/compression_utils.cc
index 9f63a840167d473..781c805d0a950bb 100644
--- a/deps/zlib/google/compression_utils.cc
+++ b/deps/zlib/google/compression_utils.cc
@@ -5,16 +5,15 @@
 #include "third_party/zlib/google/compression_utils.h"
 
 #include "base/bit_cast.h"
-#include "base/logging.h"
+#include "base/check_op.h"
 #include "base/process/memory.h"
-#include "base/strings/string_piece.h"
 #include "base/sys_byteorder.h"
 
 #include "third_party/zlib/google/compression_utils_portable.h"
 
 namespace compression {
 
-bool GzipCompress(base::StringPiece input,
+bool GzipCompress(base::span<const char> input,
                   char* output_buffer,
                   size_t output_buffer_size,
                   size_t* compressed_size,
@@ -35,7 +34,11 @@ bool GzipCompress(base::StringPiece input,
   return true;
 }
 
-bool GzipCompress(base::StringPiece input, std::string* output) {
+bool GzipCompress(base::span<const char> input, std::string* output) {
+  return GzipCompress(base::as_bytes(input), output);
+}
+
+bool GzipCompress(base::span<const uint8_t> input, std::string* output) {
   // Not using std::vector<> because allocation failures are recoverable,
   // which is hidden by std::vector<>.
   static_assert(sizeof(Bytef) == 1, "");
@@ -87,30 +90,44 @@ bool GzipUncompress(const std::string& input, std::string* output) {
   return false;
 }
 
-bool GzipUncompress(base::StringPiece input, base::StringPiece output) {
+bool GzipUncompress(base::span<const char> input,
+                    base::span<const char> output) {
+  return GzipUncompress(base::as_bytes(input), base::as_bytes(output));
+}
+
+bool GzipUncompress(base::span<const uint8_t> input,
+                    base::span<const uint8_t> output) {
   uLongf uncompressed_size = GetUncompressedSize(input);
   if (uncompressed_size > output.size())
     return false;
   return zlib_internal::GzipUncompressHelper(
              bit_cast<Bytef*>(output.data()), &uncompressed_size,
              bit_cast<const Bytef*>(input.data()),
-             static_cast<uLongf>(input.length())) == Z_OK;
+             static_cast<uLongf>(input.size())) == Z_OK;
 }
 
-bool GzipUncompress(base::StringPiece input, std::string* output) {
+bool GzipUncompress(base::span<const char> input, std::string* output) {
+  return GzipUncompress(base::as_bytes(input), output);
+}
+
+bool GzipUncompress(base::span<const uint8_t> input, std::string* output) {
   // Disallow in-place usage, i.e., |input| using |*output| as underlying data.
-  DCHECK_NE(input.data(), output->data());
+  DCHECK_NE(reinterpret_cast<const char*>(input.data()), output->data());
   uLongf uncompressed_size = GetUncompressedSize(input);
   output->resize(uncompressed_size);
   return zlib_internal::GzipUncompressHelper(
              bit_cast<Bytef*>(output->data()), &uncompressed_size,
              bit_cast<const Bytef*>(input.data()),
-             static_cast<uLongf>(input.length())) == Z_OK;
+             static_cast<uLongf>(input.size())) == Z_OK;
+}
+
+uint32_t GetUncompressedSize(base::span<const char> compressed_data) {
+  return GetUncompressedSize(base::as_bytes(compressed_data));
 }
 
-uint32_t GetUncompressedSize(base::StringPiece compressed_data) {
+uint32_t GetUncompressedSize(base::span<const uint8_t> compressed_data) {
   return zlib_internal::GetGzipUncompressedSize(
-      bit_cast<Bytef*>(compressed_data.data()), compressed_data.length());
+      bit_cast<Bytef*>(compressed_data.data()), compressed_data.size());
 }
 
 }  // namespace compression
diff --git a/deps/zlib/google/compression_utils.h b/deps/zlib/google/compression_utils.h
index 516220719ff43cf..cca47be1efef6a1 100644
--- a/deps/zlib/google/compression_utils.h
+++ b/deps/zlib/google/compression_utils.h
@@ -7,7 +7,7 @@
 
 #include <string>
 
-#include "base/strings/string_piece.h"
+#include "base/containers/span.h"
 
 namespace compression {
 
@@ -18,7 +18,7 @@ namespace compression {
 // |malloc_fn| and |free_fn| are pointers to malloc() and free()-like functions,
 // or nullptr to use the standard ones.
 // Returns true for success.
-bool GzipCompress(base::StringPiece input,
+bool GzipCompress(base::span<const char> input,
                   char* output_buffer,
                   size_t output_buffer_size,
                   size_t* compressed_size,
@@ -29,27 +29,41 @@ bool GzipCompress(base::StringPiece input,
 // |input| and |output| are allowed to point to the same string (in-place
 // operation).
 // Returns true for success.
-bool GzipCompress(base::StringPiece input, std::string* output);
+bool GzipCompress(base::span<const char> input, std::string* output);
+
+// Like the above method, but using uint8_t instead.
+bool GzipCompress(base::span<const uint8_t> input, std::string* output);
 
 // Uncompresses the data in |input| using gzip, storing the result in |output|.
 // |input| and |output| are allowed to be the same string (in-place operation).
 // Returns true for success.
 bool GzipUncompress(const std::string& input, std::string* output);
 
-// Like the above method, but uses base::StringPiece to avoid allocations if
+// Like the above method, but uses base::span to avoid allocations if
 // needed. |output|'s size must be at least as large as the return value from
 // GetUncompressedSize.
 // Returns true for success.
-bool GzipUncompress(base::StringPiece input, base::StringPiece output);
+bool GzipUncompress(base::span<const char> input,
+                    base::span<const char> output);
+
+// Like the above method, but using uint8_t instead.
+bool GzipUncompress(base::span<const uint8_t> input,
+                    base::span<const uint8_t> output);
 
 // Uncompresses the data in |input| using gzip, and writes the results to
 // |output|, which must NOT be the underlying string of |input|, and is resized
 // if necessary.
 // Returns true for success.
-bool GzipUncompress(base::StringPiece input, std::string* output);
+bool GzipUncompress(base::span<const char> input, std::string* output);
+
+// Like the above method, but using uint8_t instead.
+bool GzipUncompress(base::span<const uint8_t> input, std::string* output);
 
 // Returns the uncompressed size from GZIP-compressed |compressed_data|.
-uint32_t GetUncompressedSize(base::StringPiece compressed_data);
+uint32_t GetUncompressedSize(base::span<const char> compressed_data);
+
+// Like the above method, but using uint8_t instead.
+uint32_t GetUncompressedSize(base::span<const uint8_t> compressed_data);
 
 }  // namespace compression
 
diff --git a/deps/zlib/google/compression_utils_portable.cc b/deps/zlib/google/compression_utils_portable.cc
index 191e349e31ad308..331e41e12572539 100644
--- a/deps/zlib/google/compression_utils_portable.cc
+++ b/deps/zlib/google/compression_utils_portable.cc
@@ -5,7 +5,7 @@
  * found in the Chromium source repository LICENSE file.
  */
 
-#include "third_party/zlib/google/compression_utils_portable.h"
+#include "compression_utils_portable.h"
 
 #include <stddef.h>
 #include <stdlib.h>
@@ -84,7 +84,7 @@ int CompressHelper(WrapperType wrapper_type,
                    int compression_level,
                    void* (*malloc_fn)(size_t),
                    void (*free_fn)(void*)) {
-  if (compression_level < 1 || compression_level > 9) {
+  if (compression_level < 0 || compression_level > 9) {
     compression_level = Z_DEFAULT_COMPRESSION;
   }
 
diff --git a/deps/zlib/google/compression_utils_portable.h b/deps/zlib/google/compression_utils_portable.h
index cd004e86cf515c0..c1f377571fbba04 100644
--- a/deps/zlib/google/compression_utils_portable.h
+++ b/deps/zlib/google/compression_utils_portable.h
@@ -9,10 +9,14 @@
 
 #include <stdint.h>
 
+/* TODO(cavalcantii): remove support for Chromium ever building with a system
+ * zlib.
+ */
 #if defined(USE_SYSTEM_ZLIB)
 #include <zlib.h>
+/* AOSP build requires relative paths. */
 #else
-#include "third_party/zlib/zlib.h"
+#include "zlib.h"
 #endif
 
 namespace zlib_internal {
diff --git a/deps/zlib/google/compression_utils_unittest.cc b/deps/zlib/google/compression_utils_unittest.cc
index b0e04b8c973633a..31c3226f0f00dd0 100644
--- a/deps/zlib/google/compression_utils_unittest.cc
+++ b/deps/zlib/google/compression_utils_unittest.cc
@@ -9,7 +9,6 @@
 
 #include <string>
 
-#include "base/logging.h"
 #include "base/stl_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -55,13 +54,9 @@ TEST(CompressionUtilsTest, GzipUncompression) {
   EXPECT_EQ(golden_data, uncompressed_data);
 }
 
-TEST(CompressionUtilsTest, GzipUncompressionFromStringPieceToString) {
-  base::StringPiece compressed_data(
-      reinterpret_cast<const char*>(kCompressedData),
-      base::size(kCompressedData));
-
+TEST(CompressionUtilsTest, GzipUncompressionFromSpanToString) {
   std::string uncompressed_data;
-  EXPECT_TRUE(GzipUncompress(compressed_data, &uncompressed_data));
+  EXPECT_TRUE(GzipUncompress(kCompressedData, &uncompressed_data));
 
   std::string golden_data(reinterpret_cast<const char*>(kData),
                           base::size(kData));
diff --git a/deps/zlib/google/zip_internal.cc b/deps/zlib/google/zip_internal.cc
index 314740f5447c03d..9cbb78cb58bcb0b 100644
--- a/deps/zlib/google/zip_internal.cc
+++ b/deps/zlib/google/zip_internal.cc
@@ -5,10 +5,12 @@
 #include "third_party/zlib/google/zip_internal.h"
 
 #include <stddef.h>
+#include <string.h>
 
 #include <algorithm>
 
 #include "base/logging.h"
+#include "base/notreached.h"
 #include "base/strings/utf_string_conversions.h"
 
 #if defined(USE_SYSTEM_MINIZIP)
diff --git a/deps/zlib/google/zip_reader_unittest.cc b/deps/zlib/google/zip_reader_unittest.cc
index 87190c7e0dee76b..bba4365298ba42f 100644
--- a/deps/zlib/google/zip_reader_unittest.cc
+++ b/deps/zlib/google/zip_reader_unittest.cc
@@ -12,11 +12,11 @@
 #include <string>
 
 #include "base/bind.h"
+#include "base/check.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/hash/md5.h"
-#include "base/logging.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
diff --git a/deps/zlib/google/zip_unittest.cc b/deps/zlib/google/zip_unittest.cc
index 7ea3c36c2a80f1b..10f2ef7a9742adf 100644
--- a/deps/zlib/google/zip_unittest.cc
+++ b/deps/zlib/google/zip_unittest.cc
@@ -16,6 +16,7 @@
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/logging.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
diff --git a/deps/zlib/google/zip_writer.cc b/deps/zlib/google/zip_writer.cc
index 1f2f073b30cb32d..6f38d42b6ba5dbe 100644
--- a/deps/zlib/google/zip_writer.cc
+++ b/deps/zlib/google/zip_writer.cc
@@ -5,6 +5,7 @@
 #include "third_party/zlib/google/zip_writer.h"
 
 #include "base/files/file.h"
+#include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "third_party/zlib/google/zip_internal.h"
 
diff --git a/deps/zlib/patches/0003-uninitializedjump.patch b/deps/zlib/patches/0003-uninitializedjump.patch
new file mode 100644
index 000000000000000..7aae3238a5011aa
--- /dev/null
+++ b/deps/zlib/patches/0003-uninitializedjump.patch
@@ -0,0 +1,15 @@
+diff --git a/third_party/zlib/deflate.c b/third_party/zlib/deflate.c
+index a39e62787862..c6053fd1c7ea 100644
+--- a/third_party/zlib/deflate.c
++++ b/third_party/zlib/deflate.c
+@@ -318,6 +318,10 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
+                                  s->w_size + window_padding,
+                                  2*sizeof(Byte));
+     s->prev   = (Posf *)  ZALLOC(strm, s->w_size, sizeof(Pos));
++    /* Avoid use of uninitialized value, see:
++     * https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=11360
++     */
++    zmemzero(s->prev, s->w_size * sizeof(Pos));
+     s->head   = (Posf *)  ZALLOC(strm, s->hash_size, sizeof(Pos));
+ 
+     s->high_water = 0;      /* nothing written to s->window yet */
diff --git a/deps/zlib/patches/0004-fix-uwp.patch b/deps/zlib/patches/0004-fix-uwp.patch
new file mode 100644
index 000000000000000..23145a7ae5357f5
--- /dev/null
+++ b/deps/zlib/patches/0004-fix-uwp.patch
@@ -0,0 +1,22 @@
+diff --git a/third_party/zlib/contrib/minizip/iowin32.c b/third_party/zlib/contrib/minizip/iowin32.c
+index 246ceb91a139..c6bc314b3c28 100644
+--- a/third_party/zlib/contrib/minizip/iowin32.c
++++ b/third_party/zlib/contrib/minizip/iowin32.c
+@@ -31,14 +31,12 @@
+ #define _WIN32_WINNT 0x601
+ #endif
+ 
+-#if _WIN32_WINNT >= _WIN32_WINNT_WIN8
+-// see Include/shared/winapifamily.h in the Windows Kit
+-#if defined(WINAPI_FAMILY_PARTITION) && (!(defined(IOWIN32_USING_WINRT_API)))
+-#if WINAPI_FAMILY_ONE_PARTITION(WINAPI_FAMILY, WINAPI_PARTITION_APP)
++#if !defined(IOWIN32_USING_WINRT_API)
++#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
++// Windows Store or Universal Windows Platform
+ #define IOWIN32_USING_WINRT_API 1
+ #endif
+ #endif
+-#endif
+ 
+ voidpf  ZCALLBACK win32_open_file_func  OF((voidpf opaque, const char* filename, int mode));
+ uLong   ZCALLBACK win32_read_file_func  OF((voidpf opaque, voidpf stream, void* buf, uLong size));
diff --git a/deps/zlib/patches/0005-infcover-gtest.patch b/deps/zlib/patches/0005-infcover-gtest.patch
new file mode 100644
index 000000000000000..f5443bd7d88e1cd
--- /dev/null
+++ b/deps/zlib/patches/0005-infcover-gtest.patch
@@ -0,0 +1,405 @@
+From 409594639f15d825202971db7a275023e05772ff Mon Sep 17 00:00:00 2001
+From: Adenilson Cavalcanti <adenilson.cavalcanti@arm.com>
+Date: Tue, 28 Apr 2020 10:48:01 -0700
+Subject: [PATCH] Local Changes:   - make C tests build as C++ code so we can
+ use gtest.   - use gtest EXPECT_TRUE instead of C assert.   - replace C
+ streams for C++ (portability issues).
+
+---
+ test/infcover.c | 167 ++++++++++++++++++++++++++----------------------
+ 1 file changed, 90 insertions(+), 77 deletions(-)
+
+diff --git a/test/infcover.c b/test/infcover.c
+index 2be0164..a8c51c7 100644
+--- a/test/infcover.c
++++ b/test/infcover.c
+@@ -4,11 +4,12 @@
+  */
+ 
+ /* to use, do: ./configure --cover && make cover */
+-
++// clang-format off
++#include "infcover.h"
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
+-#include <assert.h>
++
+ #include "zlib.h"
+ 
+ /* get definition of internal structure so we can mess with it (see pull()),
+@@ -17,8 +18,22 @@
+ #include "inftrees.h"
+ #include "inflate.h"
+ 
++/* XXX: use C++ streams instead of printf/fputs/etc due to portability
++ * as type sizes can vary between platforms.
++ */
++#include <iostream>
+ #define local static
+ 
++/* XXX: hacking C assert and plugging into GTest. */
++#include "gtest.h"
++#if defined(assert)
++#undef assert
++#define assert EXPECT_TRUE
++#endif
++
++/* XXX: handle what is a reserved word in C++. */
++#define try try_f
++
+ /* -- memory tracking routines -- */
+ 
+ /*
+@@ -72,7 +87,7 @@ local void *mem_alloc(void *mem, unsigned count, unsigned size)
+ {
+     void *ptr;
+     struct mem_item *item;
+-    struct mem_zone *zone = mem;
++    struct mem_zone *zone = static_cast<struct mem_zone *>(mem);
+     size_t len = count * (size_t)size;
+ 
+     /* induced allocation failure */
+@@ -87,7 +102,7 @@ local void *mem_alloc(void *mem, unsigned count, unsigned size)
+     memset(ptr, 0xa5, len);
+ 
+     /* create a new item for the list */
+-    item = malloc(sizeof(struct mem_item));
++    item = static_cast<struct mem_item *>(malloc(sizeof(struct mem_item)));
+     if (item == NULL) {
+         free(ptr);
+         return NULL;
+@@ -112,7 +127,7 @@ local void *mem_alloc(void *mem, unsigned count, unsigned size)
+ local void mem_free(void *mem, void *ptr)
+ {
+     struct mem_item *item, *next;
+-    struct mem_zone *zone = mem;
++    struct mem_zone *zone = static_cast<struct mem_zone *>(mem);
+ 
+     /* if no zone, just do a free */
+     if (zone == NULL) {
+@@ -159,7 +174,7 @@ local void mem_setup(z_stream *strm)
+ {
+     struct mem_zone *zone;
+ 
+-    zone = malloc(sizeof(struct mem_zone));
++    zone = static_cast<struct mem_zone *>(malloc(sizeof(struct mem_zone)));
+     assert(zone != NULL);
+     zone->first = NULL;
+     zone->total = 0;
+@@ -175,33 +190,33 @@ local void mem_setup(z_stream *strm)
+ /* set a limit on the total memory allocation, or 0 to remove the limit */
+ local void mem_limit(z_stream *strm, size_t limit)
+ {
+-    struct mem_zone *zone = strm->opaque;
++    struct mem_zone *zone = static_cast<struct mem_zone *>(strm->opaque);
+ 
+     zone->limit = limit;
+ }
+ 
+ /* show the current total requested allocations in bytes */
+-local void mem_used(z_stream *strm, char *prefix)
++local void mem_used(z_stream *strm, const char *prefix)
+ {
+-    struct mem_zone *zone = strm->opaque;
++    struct mem_zone *zone = static_cast<struct mem_zone *>(strm->opaque);
+ 
+-    fprintf(stderr, "%s: %lu allocated\n", prefix, zone->total);
++    std::cout << prefix << ": " << zone->total << " allocated" << std::endl;
+ }
+ 
+ /* show the high water allocation in bytes */
+-local void mem_high(z_stream *strm, char *prefix)
++local void mem_high(z_stream *strm, const char *prefix)
+ {
+-    struct mem_zone *zone = strm->opaque;
++    struct mem_zone *zone = static_cast<struct mem_zone *>(strm->opaque);
+ 
+-    fprintf(stderr, "%s: %lu high water mark\n", prefix, zone->highwater);
++    std::cout << prefix << ": " << zone->highwater << " high water mark" << std::endl;
+ }
+ 
+ /* release the memory allocation zone -- if there are any surprises, notify */
+-local void mem_done(z_stream *strm, char *prefix)
++local void mem_done(z_stream *strm, const char *prefix)
+ {
+     int count = 0;
+     struct mem_item *item, *next;
+-    struct mem_zone *zone = strm->opaque;
++    struct mem_zone *zone = static_cast<struct mem_zone *>(strm->opaque);
+ 
+     /* show high water mark */
+     mem_high(strm, prefix);
+@@ -218,13 +233,20 @@ local void mem_done(z_stream *strm, char *prefix)
+ 
+     /* issue alerts about anything unexpected */
+     if (count || zone->total)
+-        fprintf(stderr, "** %s: %lu bytes in %d blocks not freed\n",
+-                prefix, zone->total, count);
++        std::cout << "** " << prefix << ": "
++                  << zone->total << " bytes in "
++                  << count << " blocks not freed"
++                  << std::endl;
++
+     if (zone->notlifo)
+-        fprintf(stderr, "** %s: %d frees not LIFO\n", prefix, zone->notlifo);
++        std::cout << "** " << prefix << ": "
++                  << zone->notlifo << " frees not LIFO"
++                  << std::endl;
++
+     if (zone->rogue)
+-        fprintf(stderr, "** %s: %d frees not recognized\n",
+-                prefix, zone->rogue);
++        std::cout << "** " << prefix << ": "
++                  << zone->rogue << " frees not recognized"
++                  << std::endl;
+ 
+     /* free the zone and delete from the stream */
+     free(zone);
+@@ -247,7 +269,7 @@ local unsigned char *h2b(const char *hex, unsigned *len)
+     unsigned char *in, *re;
+     unsigned next, val;
+ 
+-    in = malloc((strlen(hex) + 1) >> 1);
++    in = static_cast<unsigned char *>(malloc((strlen(hex) + 1) >> 1));
+     if (in == NULL)
+         return NULL;
+     next = 0;
+@@ -268,7 +290,7 @@ local unsigned char *h2b(const char *hex, unsigned *len)
+     } while (*hex++);       /* go through the loop with the terminating null */
+     if (len != NULL)
+         *len = next;
+-    re = realloc(in, next);
++    re = static_cast<unsigned char *>(realloc(in, next));
+     return re == NULL ? in : re;
+ }
+ 
+@@ -281,7 +303,7 @@ local unsigned char *h2b(const char *hex, unsigned *len)
+    header information is collected with inflateGetHeader().  If a zlib stream
+    is looking for a dictionary, then an empty dictionary is provided.
+    inflate() is run until all of the input data is consumed. */
+-local void inf(char *hex, char *what, unsigned step, int win, unsigned len,
++local void inf(const char *hex, const char *what, unsigned step, int win, unsigned len,
+                int err)
+ {
+     int ret;
+@@ -298,7 +320,7 @@ local void inf(char *hex, char *what, unsigned step, int win, unsigned len,
+         mem_done(&strm, what);
+         return;
+     }
+-    out = malloc(len);                          assert(out != NULL);
++    out = static_cast<unsigned char *>(malloc(len));                          assert(out != NULL);
+     if (win == 47) {
+         head.extra = out;
+         head.extra_max = len;
+@@ -347,7 +369,7 @@ local void inf(char *hex, char *what, unsigned step, int win, unsigned len,
+ }
+ 
+ /* cover all of the lines in inflate.c up to inflate() */
+-local void cover_support(void)
++void cover_support(void)
+ {
+     int ret;
+     z_stream strm;
+@@ -381,11 +403,11 @@ local void cover_support(void)
+     strm.next_in = Z_NULL;
+     ret = inflateInit(&strm);                   assert(ret == Z_OK);
+     ret = inflateEnd(&strm);                    assert(ret == Z_OK);
+-    fputs("inflate built-in memory routines\n", stderr);
++    std::cout << "inflate built-in memory routines" << std::endl;;
+ }
+ 
+ /* cover all inflate() header and trailer cases and code after inflate() */
+-local void cover_wrap(void)
++void cover_wrap(void)
+ {
+     int ret;
+     z_stream strm, copy;
+@@ -394,7 +416,7 @@ local void cover_wrap(void)
+     ret = inflate(Z_NULL, 0);                   assert(ret == Z_STREAM_ERROR);
+     ret = inflateEnd(Z_NULL);                   assert(ret == Z_STREAM_ERROR);
+     ret = inflateCopy(Z_NULL, Z_NULL);          assert(ret == Z_STREAM_ERROR);
+-    fputs("inflate bad parameters\n", stderr);
++    std::cout << "inflate bad parameters" << std::endl;
+ 
+     inf("1f 8b 0 0", "bad gzip method", 0, 31, 0, Z_DATA_ERROR);
+     inf("1f 8b 8 80", "bad gzip flags", 0, 31, 0, Z_DATA_ERROR);
+@@ -415,9 +437,9 @@ local void cover_wrap(void)
+     strm.next_in = Z_NULL;
+     ret = inflateInit2(&strm, -8);
+     strm.avail_in = 2;
+-    strm.next_in = (void *)"\x63";
++    strm.next_in = (Bytef *)"\x63";
+     strm.avail_out = 1;
+-    strm.next_out = (void *)&ret;
++    strm.next_out = (Bytef *)&ret;
+     mem_limit(&strm, 1);
+     ret = inflate(&strm, Z_NO_FLUSH);           assert(ret == Z_MEM_ERROR);
+     ret = inflate(&strm, Z_NO_FLUSH);           assert(ret == Z_MEM_ERROR);
+@@ -428,11 +450,11 @@ local void cover_wrap(void)
+     mem_limit(&strm, (sizeof(struct inflate_state) << 1) + 256);
+     ret = inflatePrime(&strm, 16, 0);           assert(ret == Z_OK);
+     strm.avail_in = 2;
+-    strm.next_in = (void *)"\x80";
++    strm.next_in = (Bytef *)"\x80";
+     ret = inflateSync(&strm);                   assert(ret == Z_DATA_ERROR);
+     ret = inflate(&strm, Z_NO_FLUSH);           assert(ret == Z_STREAM_ERROR);
+     strm.avail_in = 4;
+-    strm.next_in = (void *)"\0\0\xff\xff";
++    strm.next_in = (Bytef *)"\0\0\xff\xff";
+     ret = inflateSync(&strm);                   assert(ret == Z_OK);
+     (void)inflateSyncPoint(&strm);
+     ret = inflateCopy(&copy, &strm);            assert(ret == Z_MEM_ERROR);
+@@ -454,7 +476,7 @@ local unsigned pull(void *desc, unsigned char **buf)
+         next = 0;
+         return 0;   /* no input (already provided at next_in) */
+     }
+-    state = (void *)((z_stream *)desc)->state;
++    state = reinterpret_cast<struct inflate_state *>(((z_stream *)desc)->state);
+     if (state != Z_NULL)
+         state->mode = SYNC;     /* force an otherwise impossible situation */
+     return next < sizeof(dat) ? (*buf = dat + next++, 1) : 0;
+@@ -467,7 +489,7 @@ local int push(void *desc, unsigned char *buf, unsigned len)
+ }
+ 
+ /* cover inflateBack() up to common deflate data cases and after those */
+-local void cover_back(void)
++void cover_back(void)
+ {
+     int ret;
+     z_stream strm;
+@@ -479,17 +501,17 @@ local void cover_back(void)
+     ret = inflateBack(Z_NULL, Z_NULL, Z_NULL, Z_NULL, Z_NULL);
+                                                 assert(ret == Z_STREAM_ERROR);
+     ret = inflateBackEnd(Z_NULL);               assert(ret == Z_STREAM_ERROR);
+-    fputs("inflateBack bad parameters\n", stderr);
++    std::cout << "inflateBack bad parameters" << std::endl;;
+ 
+     mem_setup(&strm);
+     ret = inflateBackInit(&strm, 15, win);      assert(ret == Z_OK);
+     strm.avail_in = 2;
+-    strm.next_in = (void *)"\x03";
++    strm.next_in = (Bytef *)"\x03";
+     ret = inflateBack(&strm, pull, Z_NULL, push, Z_NULL);
+                                                 assert(ret == Z_STREAM_END);
+         /* force output error */
+     strm.avail_in = 3;
+-    strm.next_in = (void *)"\x63\x00";
++    strm.next_in = (Bytef *)"\x63\x00";
+     ret = inflateBack(&strm, pull, Z_NULL, push, &strm);
+                                                 assert(ret == Z_BUF_ERROR);
+         /* force mode error by mucking with state */
+@@ -500,11 +522,11 @@ local void cover_back(void)
+ 
+     ret = inflateBackInit(&strm, 15, win);      assert(ret == Z_OK);
+     ret = inflateBackEnd(&strm);                assert(ret == Z_OK);
+-    fputs("inflateBack built-in memory routines\n", stderr);
++    std::cout << "inflateBack built-in memory routines" << std::endl;;
+ }
+ 
+ /* do a raw inflate of data in hexadecimal with both inflate and inflateBack */
+-local int try(char *hex, char *id, int err)
++local int try(const char *hex, const char *id, int err)
+ {
+     int ret;
+     unsigned len, size;
+@@ -518,11 +540,11 @@ local int try(char *hex, char *id, int err)
+ 
+     /* allocate work areas */
+     size = len << 3;
+-    out = malloc(size);
++    out = static_cast<unsigned char *>(malloc(size));
+     assert(out != NULL);
+-    win = malloc(32768);
++    win = static_cast<unsigned char *>(malloc(32768));
+     assert(win != NULL);
+-    prefix = malloc(strlen(id) + 6);
++    prefix = static_cast<char *>(malloc(strlen(id) + 6));
+     assert(prefix != NULL);
+ 
+     /* first with inflate */
+@@ -578,7 +600,7 @@ local int try(char *hex, char *id, int err)
+ }
+ 
+ /* cover deflate data cases in both inflate() and inflateBack() */
+-local void cover_inflate(void)
++void cover_inflate(void)
+ {
+     try("0 0 0 0 0", "invalid stored block lengths", 1);
+     try("3 0", "fixed", 0);
+@@ -613,32 +635,33 @@ local void cover_inflate(void)
+     inf("63 18 5 40 c 0", "window wrap", 3, -8, 300, Z_OK);
+ }
+ 
++/* XXX(cavalcantii): fix linking error due inflate_table. */
+ /* cover remaining lines in inftrees.c */
+-local void cover_trees(void)
+-{
+-    int ret;
+-    unsigned bits;
+-    unsigned short lens[16], work[16];
+-    code *next, table[ENOUGH_DISTS];
+-
+-    /* we need to call inflate_table() directly in order to manifest not-
+-       enough errors, since zlib insures that enough is always enough */
+-    for (bits = 0; bits < 15; bits++)
+-        lens[bits] = (unsigned short)(bits + 1);
+-    lens[15] = 15;
+-    next = table;
+-    bits = 15;
+-    ret = inflate_table(DISTS, lens, 16, &next, &bits, work);
+-                                                assert(ret == 1);
+-    next = table;
+-    bits = 1;
+-    ret = inflate_table(DISTS, lens, 16, &next, &bits, work);
+-                                                assert(ret == 1);
+-    fputs("inflate_table not enough errors\n", stderr);
+-}
++/* void cover_trees(void) */
++/* { */
++/*     int ret; */
++/*     unsigned bits; */
++/*     unsigned short lens[16], work[16]; */
++/*     code *next, table[ENOUGH_DISTS]; */
++
++/*     /\* we need to call inflate_table() directly in order to manifest not- */
++/*        enough errors, since zlib insures that enough is always enough *\/ */
++/*     for (bits = 0; bits < 15; bits++) */
++/*         lens[bits] = (unsigned short)(bits + 1); */
++/*     lens[15] = 15; */
++/*     next = table; */
++/*     bits = 15; */
++/*     ret = inflate_table(DISTS, lens, 16, &next, &bits, work); */
++/*                                                 assert(ret == 1); */
++/*     next = table; */
++/*     bits = 1; */
++/*     ret = inflate_table(DISTS, lens, 16, &next, &bits, work); */
++/*                                                 assert(ret == 1); */
++/*     fputs("inflate_table not enough errors\n", stderr); */
++/* } */
+ 
+ /* cover remaining inffast.c decoding and window copying */
+-local void cover_fast(void)
++void cover_fast(void)
+ {
+     inf("e5 e0 81 ad 6d cb b2 2c c9 01 1e 59 63 ae 7d ee fb 4d fd b5 35 41 68"
+         " ff 7f 0f 0 0 0", "fast length extra bits", 0, -8, 258, Z_DATA_ERROR);
+@@ -658,14 +681,4 @@ local void cover_fast(void)
+         Z_STREAM_END);
+ }
+ 
+-int main(void)
+-{
+-    fprintf(stderr, "%s\n", zlibVersion());
+-    cover_support();
+-    cover_wrap();
+-    cover_back();
+-    cover_inflate();
+-    cover_trees();
+-    cover_fast();
+-    return 0;
+-}
++// clang-format on
+-- 
+2.21.1 (Apple Git-122.3)
+
diff --git a/deps/zlib/patches/0006-fix-check_match.patch b/deps/zlib/patches/0006-fix-check_match.patch
new file mode 100644
index 000000000000000..b21c363b1ec1e72
--- /dev/null
+++ b/deps/zlib/patches/0006-fix-check_match.patch
@@ -0,0 +1,42 @@
+From 8304bdda5293ffd5b3efce8e4f54904b387029d6 Mon Sep 17 00:00:00 2001
+From: Hans Wennborg <hans@chromium.org>
+Date: Wed, 23 Sep 2020 16:36:38 +0200
+Subject: [PATCH] Avoid crashing in check_match when prev_match == -1
+
+prev_match can be set to -1 after sliding the window. In that case, the
+window has slid past the first byte of the last match, which means it
+cannot be compared in check_match.
+
+This would cause zlib to crash on some inputs to deflate when built
+with ZLIB_DEBUG enabled.
+
+Check for this situation and avoid crashing by not trying to compare
+the first byte.
+
+Bug: 1113142
+---
+ third_party/zlib/deflate.c | 8 +++++++-
+ 1 file changed, 7 insertions(+), 1 deletion(-)
+
+diff --git a/third_party/zlib/deflate.c b/third_party/zlib/deflate.c
+index cfdd2f46b230..d70732ec6fc2 100644
+--- a/third_party/zlib/deflate.c
++++ b/third_party/zlib/deflate.c
+@@ -2060,7 +2060,13 @@ local block_state deflate_slow(s, flush)
+             uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
+             /* Do not insert strings in hash table beyond this. */
+ 
+-            check_match(s, s->strstart-1, s->prev_match, s->prev_length);
++            if (s->prev_match == -1) {
++                /* The window has slid one byte past the previous match,
++                 * so the first byte cannot be compared. */
++                check_match(s, s->strstart, s->prev_match+1, s->prev_length-1);
++            } else {
++                check_match(s, s->strstart-1, s->prev_match, s->prev_length);
++            }
+ 
+             _tr_tally_dist(s, s->strstart -1 - s->prev_match,
+                            s->prev_length - MIN_MATCH, bflush);
+-- 
+2.28.0.681.g6f77f65b4e-goog
+
diff --git a/deps/zlib/simd_stub.c b/deps/zlib/simd_stub.c
deleted file mode 100644
index c6d46051498f369..000000000000000
--- a/deps/zlib/simd_stub.c
+++ /dev/null
@@ -1,35 +0,0 @@
-/* simd_stub.c -- stub implementations
-* Copyright (C) 2014 Intel Corporation
-* For conditions of distribution and use, see copyright notice in zlib.h
-*/
-#include <assert.h>
-
-#include "deflate.h"
-#include "x86.h"
-
-int ZLIB_INTERNAL x86_cpu_enable_simd = 0;
-
-void ZLIB_INTERNAL crc_fold_init(deflate_state *const s) {
-    assert(0);
-}
-
-void ZLIB_INTERNAL crc_fold_copy(deflate_state *const s,
-                                 unsigned char *dst,
-                                 const unsigned char *src,
-                                 long len) {
-    assert(0);
-}
-
-unsigned ZLIB_INTERNAL crc_fold_512to32(deflate_state *const s) {
-    assert(0);
-    return 0;
-}
-
-void ZLIB_INTERNAL fill_window_sse(deflate_state *s)
-{
-    assert(0);
-}
-
-void x86_check_features(void)
-{
-}
diff --git a/deps/zlib/x86.c b/deps/zlib/x86.c
deleted file mode 100644
index 7488ad08b976c89..000000000000000
--- a/deps/zlib/x86.c
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * x86 feature check
- *
- * Copyright (C) 2013 Intel Corporation. All rights reserved.
- * Author:
- *  Jim Kukunas
- *
- * For conditions of distribution and use, see copyright notice in zlib.h
- */
-
-#include "x86.h"
-#include "zutil.h"
-
-int ZLIB_INTERNAL x86_cpu_enable_ssse3 = 0;
-int ZLIB_INTERNAL x86_cpu_enable_simd = 0;
-
-#ifndef _MSC_VER
-#include <pthread.h>
-
-pthread_once_t cpu_check_inited_once = PTHREAD_ONCE_INIT;
-static void _x86_check_features(void);
-
-void x86_check_features(void)
-{
-  pthread_once(&cpu_check_inited_once, _x86_check_features);
-}
-
-static void _x86_check_features(void)
-{
-    int x86_cpu_has_sse2;
-    int x86_cpu_has_ssse3;
-    int x86_cpu_has_sse42;
-    int x86_cpu_has_pclmulqdq;
-    unsigned eax, ebx, ecx, edx;
-
-    eax = 1;
-#ifdef __i386__
-    __asm__ __volatile__ (
-        "xchg %%ebx, %1\n\t"
-        "cpuid\n\t"
-        "xchg %1, %%ebx\n\t"
-    : "+a" (eax), "=S" (ebx), "=c" (ecx), "=d" (edx)
-    );
-#else
-    __asm__ __volatile__ (
-        "cpuid\n\t"
-    : "+a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx)
-    );
-#endif  /* (__i386__) */
-
-    x86_cpu_has_sse2 = edx & 0x4000000;
-    x86_cpu_has_ssse3 = ecx & 0x000200;
-    x86_cpu_has_sse42 = ecx & 0x100000;
-    x86_cpu_has_pclmulqdq = ecx & 0x2;
-
-    x86_cpu_enable_ssse3 = x86_cpu_has_ssse3;
-
-    x86_cpu_enable_simd = x86_cpu_has_sse2 &&
-                          x86_cpu_has_sse42 &&
-                          x86_cpu_has_pclmulqdq;
-}
-#else
-#include <intrin.h>
-#include <windows.h>
-
-static BOOL CALLBACK _x86_check_features(PINIT_ONCE once,
-                                         PVOID param,
-                                         PVOID *context);
-static INIT_ONCE cpu_check_inited_once = INIT_ONCE_STATIC_INIT;
-
-void x86_check_features(void)
-{
-    InitOnceExecuteOnce(&cpu_check_inited_once, _x86_check_features,
-                        NULL, NULL);
-}
-
-static BOOL CALLBACK _x86_check_features(PINIT_ONCE once,
-                                         PVOID param,
-                                         PVOID *context)
-{
-    int x86_cpu_has_sse2;
-    int x86_cpu_has_ssse3;
-    int x86_cpu_has_sse42;
-    int x86_cpu_has_pclmulqdq;
-    int regs[4];
-
-    __cpuid(regs, 1);
-
-    x86_cpu_has_sse2 = regs[3] & 0x4000000;
-    x86_cpu_has_ssse3 = regs[2] & 0x000200;
-    x86_cpu_has_sse42 = regs[2] & 0x100000;
-    x86_cpu_has_pclmulqdq = regs[2] & 0x2;
-
-    x86_cpu_enable_ssse3 = x86_cpu_has_ssse3;
-
-    x86_cpu_enable_simd = x86_cpu_has_sse2 &&
-                          x86_cpu_has_sse42 &&
-                          x86_cpu_has_pclmulqdq;
-    return TRUE;
-}
-#endif  /* _MSC_VER */
diff --git a/deps/zlib/x86.h b/deps/zlib/x86.h
deleted file mode 100644
index 7205d50265c3566..000000000000000
--- a/deps/zlib/x86.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/* x86.h -- check for x86 CPU features
-* Copyright (C) 2013 Intel Corporation Jim Kukunas
-* For conditions of distribution and use, see copyright notice in zlib.h
-*/
-
-#ifndef X86_H
-#define X86_H
-
-#include "zlib.h"
-
-extern int x86_cpu_enable_ssse3;
-extern int x86_cpu_enable_simd;
-
-void x86_check_features(void);
-
-#endif  /* X86_H */
diff --git a/deps/zlib/zconf.h-- b/deps/zlib/zconf.h--
new file mode 100644
index 000000000000000..2d1d03ff951c92b
--- /dev/null
+++ b/deps/zlib/zconf.h--
@@ -0,0 +1,549 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+
+/*
+ * This library is also built as a part of AOSP, which does not need to include
+ * chromeconf.h. This config does not want chromeconf.h, so it can set this
+ * macro to opt out. While this works today, there's no guarantee that building
+ * zlib outside of Chromium keeps working in the future.
+ */
+#if !defined(CHROMIUM_ZLIB_NO_CHROMECONF)
+/* This include does prefixing as below, but with an updated set of names.  Also
+ * sets up export macros in component builds. */
+#include "chromeconf.h"
+#endif
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ * Even better than compiling with -DZ_PREFIX would be to use configure to set
+ * this permanently in zconf.h using "./configure --zprefix".
+ */
+#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
+#  define Z_PREFIX_SET
+
+/* all linked symbols and init macros */
+#  define _dist_code            z__dist_code
+#  define _length_code          z__length_code
+#  define _tr_align             z__tr_align
+#  define _tr_flush_bits        z__tr_flush_bits
+#  define _tr_flush_block       z__tr_flush_block
+#  define _tr_init              z__tr_init
+#  define _tr_stored_block      z__tr_stored_block
+#  define _tr_tally             z__tr_tally
+#  define adler32               z_adler32
+#  define adler32_combine       z_adler32_combine
+#  define adler32_combine64     z_adler32_combine64
+#  define adler32_z             z_adler32_z
+#  ifndef Z_SOLO
+#    define compress              z_compress
+#    define compress2             z_compress2
+#    define compressBound         z_compressBound
+#  endif
+#  define crc32                 z_crc32
+#  define crc32_combine         z_crc32_combine
+#  define crc32_combine64       z_crc32_combine64
+#  define crc32_z               z_crc32_z
+#  define deflate               z_deflate
+#  define deflateBound          z_deflateBound
+#  define deflateCopy           z_deflateCopy
+#  define deflateEnd            z_deflateEnd
+#  define deflateGetDictionary  z_deflateGetDictionary
+#  define deflateInit           z_deflateInit
+#  define deflateInit2          z_deflateInit2
+#  define deflateInit2_         z_deflateInit2_
+#  define deflateInit_          z_deflateInit_
+#  define deflateParams         z_deflateParams
+#  define deflatePending        z_deflatePending
+#  define deflatePrime          z_deflatePrime
+#  define deflateReset          z_deflateReset
+#  define deflateResetKeep      z_deflateResetKeep
+#  define deflateSetDictionary  z_deflateSetDictionary
+#  define deflateSetHeader      z_deflateSetHeader
+#  define deflateTune           z_deflateTune
+#  define deflate_copyright     z_deflate_copyright
+#  define get_crc_table         z_get_crc_table
+#  ifndef Z_SOLO
+#    define gz_error              z_gz_error
+#    define gz_intmax             z_gz_intmax
+#    define gz_strwinerror        z_gz_strwinerror
+#    define gzbuffer              z_gzbuffer
+#    define gzclearerr            z_gzclearerr
+#    define gzclose               z_gzclose
+#    define gzclose_r             z_gzclose_r
+#    define gzclose_w             z_gzclose_w
+#    define gzdirect              z_gzdirect
+#    define gzdopen               z_gzdopen
+#    define gzeof                 z_gzeof
+#    define gzerror               z_gzerror
+#    define gzflush               z_gzflush
+#    define gzfread               z_gzfread
+#    define gzfwrite              z_gzfwrite
+#    define gzgetc                z_gzgetc
+#    define gzgetc_               z_gzgetc_
+#    define gzgets                z_gzgets
+#    define gzoffset              z_gzoffset
+#    define gzoffset64            z_gzoffset64
+#    define gzopen                z_gzopen
+#    define gzopen64              z_gzopen64
+#    ifdef _WIN32
+#      define gzopen_w              z_gzopen_w
+#    endif
+#    define gzprintf              z_gzprintf
+#    define gzputc                z_gzputc
+#    define gzputs                z_gzputs
+#    define gzread                z_gzread
+#    define gzrewind              z_gzrewind
+#    define gzseek                z_gzseek
+#    define gzseek64              z_gzseek64
+#    define gzsetparams           z_gzsetparams
+#    define gztell                z_gztell
+#    define gztell64              z_gztell64
+#    define gzungetc              z_gzungetc
+#    define gzvprintf             z_gzvprintf
+#    define gzwrite               z_gzwrite
+#  endif
+#  define inflate               z_inflate
+#  define inflateBack           z_inflateBack
+#  define inflateBackEnd        z_inflateBackEnd
+#  define inflateBackInit       z_inflateBackInit
+#  define inflateBackInit_      z_inflateBackInit_
+#  define inflateCodesUsed      z_inflateCodesUsed
+#  define inflateCopy           z_inflateCopy
+#  define inflateEnd            z_inflateEnd
+#  define inflateGetDictionary  z_inflateGetDictionary
+#  define inflateGetHeader      z_inflateGetHeader
+#  define inflateInit           z_inflateInit
+#  define inflateInit2          z_inflateInit2
+#  define inflateInit2_         z_inflateInit2_
+#  define inflateInit_          z_inflateInit_
+#  define inflateMark           z_inflateMark
+#  define inflatePrime          z_inflatePrime
+#  define inflateReset          z_inflateReset
+#  define inflateReset2         z_inflateReset2
+#  define inflateResetKeep      z_inflateResetKeep
+#  define inflateSetDictionary  z_inflateSetDictionary
+#  define inflateSync           z_inflateSync
+#  define inflateSyncPoint      z_inflateSyncPoint
+#  define inflateUndermine      z_inflateUndermine
+#  define inflateValidate       z_inflateValidate
+#  define inflate_copyright     z_inflate_copyright
+#  define inflate_fast          z_inflate_fast
+#  define inflate_table         z_inflate_table
+#  ifndef Z_SOLO
+#    define uncompress            z_uncompress
+#    define uncompress2           z_uncompress2
+#  endif
+#  define zError                z_zError
+#  ifndef Z_SOLO
+#    define zcalloc               z_zcalloc
+#    define zcfree                z_zcfree
+#  endif
+#  define zlibCompileFlags      z_zlibCompileFlags
+#  define zlibVersion           z_zlibVersion
+
+/* all zlib typedefs in zlib.h and zconf.h */
+#  define Byte                  z_Byte
+#  define Bytef                 z_Bytef
+#  define alloc_func            z_alloc_func
+#  define charf                 z_charf
+#  define free_func             z_free_func
+#  ifndef Z_SOLO
+#    define gzFile                z_gzFile
+#  endif
+#  define gz_header             z_gz_header
+#  define gz_headerp            z_gz_headerp
+#  define in_func               z_in_func
+#  define intf                  z_intf
+#  define out_func              z_out_func
+#  define uInt                  z_uInt
+#  define uIntf                 z_uIntf
+#  define uLong                 z_uLong
+#  define uLongf                z_uLongf
+#  define voidp                 z_voidp
+#  define voidpc                z_voidpc
+#  define voidpf                z_voidpf
+
+/* all zlib structs in zlib.h and zconf.h */
+#  define gz_header_s           z_gz_header_s
+#  define internal_state        z_internal_state
+
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+#  define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+#  define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+#  ifndef WIN32
+#    define WIN32
+#  endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#    ifndef SYS16BIT
+#      define SYS16BIT
+#    endif
+#  endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+#  ifndef STDC
+#    define STDC
+#  endif
+#  if __STDC_VERSION__ >= 199901L
+#    ifndef STDC99
+#      define STDC99
+#    endif
+#  endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+#  define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
+#  define STDC
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const       /* note: need a more gentle solution here */
+#  endif
+#endif
+
+#if defined(ZLIB_CONST) && !defined(z_const)
+#  define z_const const
+#else
+#  define z_const
+#endif
+
+#ifdef Z_SOLO
+   typedef unsigned long z_size_t;
+#else
+#  define z_longlong long long
+#  if defined(NO_SIZE_T)
+     typedef unsigned NO_SIZE_T z_size_t;
+#  elif defined(STDC)
+#    include <stddef.h>
+     typedef size_t z_size_t;
+#  else
+     typedef unsigned long z_size_t;
+#  endif
+#  undef z_longlong
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+#ifndef Z_ARG /* function prototypes for stdarg */
+#  if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#    define Z_ARG(args)  args
+#  else
+#    define Z_ARG(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+#  if defined(M_I86SM) || defined(M_I86MM)
+     /* MSC small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef _MSC_VER
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#  if (defined(__SMALL__) || defined(__MEDIUM__))
+     /* Turbo C small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef __BORLANDC__
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+   /* If building or using zlib as a DLL, define ZLIB_DLL.
+    * This is not mandatory, but it offers a little performance increase.
+    */
+#  ifdef ZLIB_DLL
+#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#      ifdef ZLIB_INTERNAL
+#        define ZEXTERN extern __declspec(dllexport)
+#      else
+#        define ZEXTERN extern __declspec(dllimport)
+#      endif
+#    endif
+#  endif  /* ZLIB_DLL */
+   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+    * define ZLIB_WINAPI.
+    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+    */
+#  ifdef ZLIB_WINAPI
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+     /* No need for _export, use ZLIB.DEF instead. */
+     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#    define ZEXPORT WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA WINAPIV
+#    else
+#      define ZEXPORTVA FAR CDECL
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  ifdef ZLIB_DLL
+#    ifdef ZLIB_INTERNAL
+#      define ZEXPORT   __declspec(dllexport)
+#      define ZEXPORTVA __declspec(dllexport)
+#    else
+#      define ZEXPORT   __declspec(dllimport)
+#      define ZEXPORTVA __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+
+#ifndef FAR
+#  define FAR
+#endif
+#ifndef far
+#  define far
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void const *voidpc;
+   typedef void FAR   *voidpf;
+   typedef void       *voidp;
+#else
+   typedef Byte const *voidpc;
+   typedef Byte FAR   *voidpf;
+   typedef Byte       *voidp;
+#endif
+
+#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
+#  include <limits.h>
+#  if (UINT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned
+#  elif (ULONG_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned long
+#  elif (USHRT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned short
+#  endif
+#endif
+
+#ifdef Z_U4
+   typedef Z_U4 z_crc_t;
+#else
+   typedef unsigned long z_crc_t;
+#endif
+
+#if !defined(_WIN32)
+#  define Z_HAVE_UNISTD_H
+#endif
+
+#ifdef HAVE_STDARG_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_STDARG_H
+#endif
+
+#ifdef STDC
+#  ifndef Z_SOLO
+#    include <sys/types.h>      /* for off_t */
+#  endif
+#endif
+
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#  ifndef Z_SOLO
+#    include <stdarg.h>         /* for va_list */
+#  endif
+#endif
+
+#ifdef _WIN32
+#  ifndef Z_SOLO
+#    include <stddef.h>         /* for wchar_t */
+#  endif
+#endif
+
+/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
+ * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
+ * though the former does not conform to the LFS document), but considering
+ * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
+ * equivalently requesting no 64-bit operations
+ */
+#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
+#  undef _LARGEFILE64_SOURCE
+#endif
+
+#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
+#  define Z_HAVE_UNISTD_H
+#endif
+#ifndef Z_SOLO
+#  if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
+#    include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
+#    ifdef VMS
+#      include <unixio.h>       /* for off_t */
+#    endif
+#    ifndef z_off_t
+#      define z_off_t off_t
+#    endif
+#  endif
+#endif
+
+#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
+#  define Z_LFS64
+#endif
+
+#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
+#  define Z_LARGE64
+#endif
+
+#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
+#  define Z_WANT64
+#endif
+
+#if !defined(SEEK_SET) && !defined(Z_SOLO)
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+
+#ifndef z_off_t
+#  define z_off_t long
+#endif
+
+#if !defined(_WIN32) && defined(Z_LARGE64)
+#  define z_off64_t off64_t
+#else
+#  if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
+#    define z_off64_t __int64
+#  else
+#    define z_off64_t z_off_t
+#  endif
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+  #pragma map(deflateInit_,"DEIN")
+  #pragma map(deflateInit2_,"DEIN2")
+  #pragma map(deflateEnd,"DEEND")
+  #pragma map(deflateBound,"DEBND")
+  #pragma map(inflateInit_,"ININ")
+  #pragma map(inflateInit2_,"ININ2")
+  #pragma map(inflateEnd,"INEND")
+  #pragma map(inflateSync,"INSY")
+  #pragma map(inflateSetDictionary,"INSEDI")
+  #pragma map(compressBound,"CMBND")
+  #pragma map(inflate_table,"INTABL")
+  #pragma map(inflate_fast,"INFA")
+  #pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */
diff --git a/deps/zlib/zlib.gyp b/deps/zlib/zlib.gyp
index b77bb6107cf6028..777c82b215a112e 100644
--- a/deps/zlib/zlib.gyp
+++ b/deps/zlib/zlib.gyp
@@ -181,17 +181,6 @@
               'defines': [ 'CPU_NO_SIMD' ],
               'sources': [ '<(ZLIB_ROOT)/inflate.c', ],
             }],
-            ['target_arch in "ia32 x64 x32" and OS!="ios"', {
-              'dependencies': [
-                'zlib_crc32_simd',
-                'zlib_x86_simd',
-              ],
-              'sources': [
-                '<(ZLIB_ROOT)/x86.c',
-              ],
-            },{
-              'sources': [ '<(ZLIB_ROOT)/simd_stub.c' ],
-            }],
             ['arm_fpu=="neon"', {
               'dependencies': [ 'zlib_arm_crc32' ],
               'sources': [