1 files changed, 28 insertions, 11 deletions

diff --git a/google/compression_utils.cc b/google/compression_utils.cc
index 9f63a84..781c805 100644
--- a/google/compression_utils.cc
+++ b/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