Import Cobalt 20.master.0.234144

Includes the following patches:
  https://cobalt-review.googlesource.com/c/cobalt/+/5590
  by n1214.hwang@samsung.com

  https://cobalt-review.googlesource.com/c/cobalt/+/5530
  by errong.leng@samsung.com

  https://cobalt-review.googlesource.com/c/cobalt/+/5570
  by devin.cai@mediatek.com

src/third_party/zlib2/google/compression_utils.cc

diff --git a/src/third_party/zlib2/google/compression_utils.cc b/src/third_party/zlib2/google/compression_utils.cc
new file mode 100644
index 0000000..6af42f3
--- /dev/null
+++ b/src/third_party/zlib2/google/compression_utils.cc
@@ -0,0 +1,122 @@
+// Copyright 2014 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 "third_party/zlib/google/compression_utils.h"
+
+#include "base/bit_cast.h"
+#include "base/logging.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,
+                  char* output_buffer,
+                  size_t output_buffer_size,
+                  size_t* compressed_size,
+                  void* (*malloc_fn)(size_t),
+                  void (*free_fn)(void*)) {
+  static_assert(sizeof(Bytef) == 1, "");
+
+  // uLongf can be larger than size_t.
+  uLongf compressed_size_long = static_cast<uLongf>(output_buffer_size);
+  if (zlib_internal::GzipCompressHelper(
+          bit_cast<Bytef*>(output_buffer), &compressed_size_long,
+          bit_cast<const Bytef*>(input.data()),
+          static_cast<uLongf>(input.size()), malloc_fn, free_fn) != Z_OK) {
+    return false;
+  }
+  // No overflow, as compressed_size_long <= output.size() which is a size_t.
+  *compressed_size = static_cast<size_t>(compressed_size_long);
+  return true;
+}
+
+bool GzipCompress(base::StringPiece input, std::string* output) {
+  // Not using std::vector<> because allocation failures are recoverable,
+  // which is hidden by std::vector<>.
+  static_assert(sizeof(Bytef) == 1, "");
+  const uLongf input_size = static_cast<uLongf>(input.size());
+
+  uLongf compressed_data_size =
+      zlib_internal::GZipExpectedCompressedSize(input_size);
+
+  Bytef* compressed_data;
+  if (!base::UncheckedMalloc(compressed_data_size,
+                             reinterpret_cast<void**>(&compressed_data))) {
+    return false;
+  }
+
+  if (zlib_internal::GzipCompressHelper(compressed_data, &compressed_data_size,
+                                        bit_cast<const Bytef*>(input.data()),
+                                        input_size, nullptr, nullptr) != Z_OK) {
+    free(compressed_data);
+    return false;
+  }
+
+  Bytef* resized_data =
+      reinterpret_cast<Bytef*>(realloc(compressed_data, compressed_data_size));
+  if (!resized_data) {
+    free(compressed_data);
+    return false;
+  }
+  output->assign(resized_data, resized_data + compressed_data_size);
+  DCHECK_EQ(input_size, GetUncompressedSize(*output));
+
+  free(resized_data);
+  return true;
+}
+
+bool GzipUncompress(const std::string& input, std::string* output) {
+  std::string uncompressed_output;
+  uLongf uncompressed_size = static_cast<uLongf>(GetUncompressedSize(input));
+  if (uncompressed_size > uncompressed_output.max_size())
+    return false;
+
+  uncompressed_output.resize(uncompressed_size);
+  if (zlib_internal::GzipUncompressHelper(
+          bit_cast<Bytef*>(uncompressed_output.data()), &uncompressed_size,
+          bit_cast<const Bytef*>(input.data()),
+          static_cast<uLongf>(input.length())) == Z_OK) {
+    output->swap(uncompressed_output);
+    return true;
+  }
+  return false;
+}
+
+bool GzipUncompress(base::StringPiece input, base::StringPiece 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;
+}
+
+bool GzipUncompress(base::StringPiece input, std::string* output) {
+  // Disallow in-place usage, i.e., |input| using |*output| as underlying data.
+  DCHECK_NE(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;
+}
+
+uint32_t GetUncompressedSize(base::StringPiece compressed_data) {
+  // The uncompressed size is stored in the last 4 bytes of |input| in LE.
+  uint32_t size;
+  if (compressed_data.length() < sizeof(size))
+    return 0;
+  memcpy(&size,
+         &compressed_data.data()[compressed_data.length() - sizeof(size)],
+         sizeof(size));
+  return base::ByteSwapToLE32(size);
+}
+
+}  // namespace compression