Rename variable, class, function, etc from libarchive to minizip.

ui/file_manager/zip_archiver/cpp/compressor_archive_libarchive.cc

 // Copyright 2017 The Chromium OS 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 "compressor_archive_libarchive.h"
 
 #include <cerrno>
 #include <cstring>
 
 #include "base/time/time.h"
@@ skipping 14 matching lines @@
   return 0 /* Success */;
 }
 
 // Called when data chunk must be written on the archive. It copies data
 // from the given buffer processed by minizip to an array buffer and passes
 // it to compressor_stream.
 uLong CustomArchiveWrite(void* compressor,
                          void* /*stream*/,
                          const void* zip_buffer,
                          uLong zip_length) {
-  CompressorArchiveLibarchive* compressor_libarchive =
-      static_cast<CompressorArchiveLibarchive*>(compressor);
+  CompressorArchiveMinizip* compressor_minizip =
+      static_cast<CompressorArchiveMinizip*>(compressor);
 
-  int64_t written_bytes = compressor_libarchive->compressor_stream()->Write(
-      compressor_libarchive->offset_, zip_length,
+  int64_t written_bytes = compressor_minizip->compressor_stream()->Write(
+      compressor_minizip->offset_, zip_length,
       static_cast<const char*>(zip_buffer));
 
   if (written_bytes != zip_length)
     return 0 /* Error */;
 
   // Update offset_ and length_.
-  compressor_libarchive->offset_ += written_bytes;
-  if (compressor_libarchive->offset_ > compressor_libarchive->length_)
-    compressor_libarchive->length_ = compressor_libarchive->offset_;
+  compressor_minizip->offset_ += written_bytes;
+  if (compressor_minizip->offset_ > compressor_minizip->length_)
+    compressor_minizip->length_ = compressor_minizip->offset_;
   return static_cast<uLong>(written_bytes);
 }
 
 // Returns the offset from the beginning of the data.
 long CustomArchiveTell(void* compressor, void* /*stream*/) {
-  CompressorArchiveLibarchive* compressor_libarchive =
-      static_cast<CompressorArchiveLibarchive*>(compressor);
-  return static_cast<long>(compressor_libarchive->offset_);
+  CompressorArchiveMinizip* compressor_minizip =
+      static_cast<CompressorArchiveMinizip*>(compressor);
+  return static_cast<long>(compressor_minizip->offset_);
 }
 
 // Moves the current offset to the specified position.
 long CustomArchiveSeek(void* compressor,
                        void* /*stream*/,
                        uLong offset,
                        int origin) {
-  CompressorArchiveLibarchive* compressor_libarchive =
-      static_cast<CompressorArchiveLibarchive*>(compressor);
+  CompressorArchiveMinizip* compressor_minizip =
+      static_cast<CompressorArchiveMinizip*>(compressor);
 
   if (origin == ZLIB_FILEFUNC_SEEK_CUR) {
-    compressor_libarchive->offset_ =
-        std::min(compressor_libarchive->offset_ + static_cast<int64_t>(offset),
-                 compressor_libarchive->length_);
+    compressor_minizip->offset_ =
+        std::min(compressor_minizip->offset_ + static_cast<int64_t>(offset),
+                 compressor_minizip->length_);
     return 0 /* Success */;
   }
   if (origin == ZLIB_FILEFUNC_SEEK_END) {
-    compressor_libarchive->offset_ =
-        std::max(compressor_libarchive->length_ - static_cast<int64_t>(offset),
+    compressor_minizip->offset_ =
+        std::max(compressor_minizip->length_ - static_cast<int64_t>(offset),
                  0LL);
     return 0 /* Success */;
   }
   if (origin == ZLIB_FILEFUNC_SEEK_SET) {
-    compressor_libarchive->offset_ =
-        std::min(static_cast<int64_t>(offset), compressor_libarchive->length_);
+    compressor_minizip->offset_ =
+        std::min(static_cast<int64_t>(offset), compressor_minizip->length_);
     return 0 /* Success */;
   }
   return -1 /* Error */;
 }
 
-// Releases all used resources. compressor points to compressor_libarchive and
+// Releases all used resources. compressor points to compressor_minizip and
 // it is deleted in the destructor of Compressor, so we don't need to delete
 // it here.
 int CustomArchiveClose(void* /*compressor*/, void* /*stream*/) {
   return 0 /* Success */;
 }
 
 // Returns the last error that happened when writing data. This function always
 // returns zero, which means there are no errors.
 int CustomArchiveError(void* /*compressor*/, void* /*stream*/) {
   return 0 /* Success */;
 }
 
 } // compressor_archive_functions
 
-CompressorArchiveLibarchive::CompressorArchiveLibarchive(
+CompressorArchiveMinizip::CompressorArchiveMinizip(
     CompressorStream* compressor_stream)
     : CompressorArchive(compressor_stream),
       compressor_stream_(compressor_stream),
       zip_file_(nullptr),
       offset_(0),
       length_(0) {
   destination_buffer_ =
       new char[compressor_stream_constants::kMaximumDataChunkSize];
 }
 
-CompressorArchiveLibarchive::~CompressorArchiveLibarchive() {
+CompressorArchiveMinizip::~CompressorArchiveMinizip() {
   delete destination_buffer_;
 }
 
-bool CompressorArchiveLibarchive::CreateArchive() {
+bool CompressorArchiveMinizip::CreateArchive() {
   // Set up archive object.
   zlib_filefunc_def zip_funcs;
   zip_funcs.zopen_file = compressor_archive_functions::CustomArchiveOpen;
   zip_funcs.zread_file = compressor_archive_functions::CustomArchiveRead;
   zip_funcs.zwrite_file = compressor_archive_functions::CustomArchiveWrite;
   zip_funcs.ztell_file = compressor_archive_functions::CustomArchiveTell;
   zip_funcs.zseek_file = compressor_archive_functions::CustomArchiveSeek;
   zip_funcs.zclose_file = compressor_archive_functions::CustomArchiveClose;
   zip_funcs.zerror_file = compressor_archive_functions::CustomArchiveError;
   zip_funcs.opaque = this;
 
   zip_file_ = zipOpen2(nullptr /* pathname */,
                        APPEND_STATUS_CREATE,
                        nullptr /* globalcomment */,
                        &zip_funcs);
   if (!zip_file_) {
     set_error_message(compressor_archive_constants::kCreateArchiveError);
     return false /* Error */;
   }
   return true /* Success */;
 }
 
-bool CompressorArchiveLibarchive::AddToArchive(const std::string& filename,
+bool CompressorArchiveMinizip::AddToArchive(const std::string& filename,
                                                int64_t file_size,
                                                int64_t modification_time,
                                                bool is_directory) {
   // Minizip takes filenames that end with '/' as directories.
   std::string normalized_filename = filename;
   if (is_directory)
     normalized_filename += "/";
 
   // Fill zipfileMetadata with modification_time.
   zip_fileinfo zipfileMetadata;
@@ skipping 70 matching lines @@
 
   if (has_error) {
     CloseArchive(true /* has_error */);
     set_error_message(compressor_archive_constants::kAddToArchiveError);
     return false /* Error */;
   }
 
   return true /* Success */;
 }
 
-bool CompressorArchiveLibarchive::CloseArchive(bool has_error) {
+bool CompressorArchiveMinizip::CloseArchive(bool has_error) {
   if (zipClose(zip_file_, nullptr /* global_comment */) != ZIP_OK) {
     set_error_message(compressor_archive_constants::kCloseArchiveError);
     return false /* Error */;
   }
   if (!has_error) {
     if (compressor_stream()->Flush() < 0) {
       set_error_message(compressor_archive_constants::kCloseArchiveError);
       return false /* Error */;
     }
   }
   return true /* Success */;
 }