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

ui/file_manager/zip_archiver/cpp/volume_archive_libarchive.cc

 // Copyright 2014 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 "volume_archive_libarchive.h"
 
 #include <algorithm>
 #include <cerrno>
 #include <cstring>
 #include <limits>
 #include <time.h>
 
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "ppapi/cpp/logging.h"
 
 namespace volume_archive_functions {
 void* CustomArchiveOpen(void* archive,
                         const char* /* filename */,
                         int /* mode */) {
   return archive;
 }
 
-int64_t DynamicCache(VolumeArchiveLibarchive* archive, int64_t unzip_size) {
+int64_t DynamicCache(VolumeArchiveMinizip* archive, int64_t unzip_size) {
   int64_t offset = archive->reader()->offset();
   if (archive->reader()->Seek(static_cast<int64_t>(offset),
                               ZLIB_FILEFUNC_SEEK_SET) < 0) {
     return -1 /* Error */;
   }
 
   int64_t bytes_to_read =
       std::min(volume_archive_constants::kMaximumDataChunkSize,
                archive->reader()->archive_size() - offset);
   PP_DCHECK(bytes_to_read > 0);
@@ skipping 21 matching lines @@
   archive->dynamic_cache_size_ = bytes_to_read - left_length;
   archive->dynamic_cache_offset_ = offset;
 
   return unzip_size - left_length;
 }
 
 uLong CustomArchiveRead(void* archive,
                         void* /* stream */,
                         void* buffer,
                         uLong size) {
-  VolumeArchiveLibarchive* archive_minizip =
-      static_cast<VolumeArchiveLibarchive*>(archive);
+  VolumeArchiveMinizip* archive_minizip =
+      static_cast<VolumeArchiveMinizip*>(archive);
   int64_t offset = archive_minizip->reader()->offset();
 
   // When minizip requests a chunk in static_cache_.
   if (offset >= archive_minizip->static_cache_offset_) {
     // Relative offset in the central directory.
     int64_t offset_in_cache = offset - archive_minizip->static_cache_offset_;
     memcpy(buffer, archive_minizip->static_cache_ + offset_in_cache, size);
     if (archive_minizip->reader()->Seek(static_cast<int64_t>(size),
                                         ZLIB_FILEFUNC_SEEK_CUR) < 0) {
       return -1 /* Error */;
@@ skipping 36 matching lines @@
 }
 
 uLong CustomArchiveWrite(void* /*archive*/,
                          void* /*stream*/,
                          const void* /*buffer*/,
                          uLong /*length*/) {
   return 0 /* Success */;
 }
 
 long CustomArchiveTell(void* archive, void* /*stream*/) {
-  VolumeArchiveLibarchive* archive_minizip =
-      static_cast<VolumeArchiveLibarchive*>(archive);
+  VolumeArchiveMinizip* archive_minizip =
+      static_cast<VolumeArchiveMinizip*>(archive);
   return static_cast<long>(archive_minizip->reader()->offset());
 }
 
 long CustomArchiveSeek(void* archive,
                        void* /*stream*/,
                        uLong offset,
                        int origin) {
-  VolumeArchiveLibarchive* archive_minizip =
-      static_cast<VolumeArchiveLibarchive*>(archive);
+  VolumeArchiveMinizip* archive_minizip =
+      static_cast<VolumeArchiveMinizip*>(archive);
 
   long return_value = static_cast<long>(archive_minizip->reader()->Seek(
       static_cast<int64_t>(offset), static_cast<int64_t>(origin)));
   if (return_value >= 0)
     return 0 /* Success */;
   return -1 /* Error */;
 }
 
 int CustomArchiveClose(void* /*opaque*/, void* /*stream*/) {
   return 0;
 }
 
 int CustomArchiveError(void* /*opaque*/, void* /*stream*/) {
   return 0;
 }
 
-const char* GetPassphrase(VolumeArchiveLibarchive* archive_minizip) {
+const char* GetPassphrase(VolumeArchiveMinizip* archive_minizip) {
   const char* password = archive_minizip->reader()->Passphrase();
   return password;
 }
 
 }  // volume_archive_functions
 
-VolumeArchiveLibarchive::VolumeArchiveLibarchive(VolumeReader* reader)
+VolumeArchiveMinizip::VolumeArchiveMinizip(VolumeReader* reader)
     : VolumeArchive(reader),
       reader_data_size_(volume_archive_constants::kMinimumDataChunkSize),
       zip_file_(nullptr),
       dynamic_cache_offset_(0),
       dynamic_cache_size_(0),
       static_cache_offset_(0),
       static_cache_size_(0),
       last_read_data_offset_(0),
       last_read_data_length_(0),
       decompressed_data_(nullptr),
       decompressed_data_size_(0),
       decompressed_error_(false) {}
 
-VolumeArchiveLibarchive::~VolumeArchiveLibarchive() {
+VolumeArchiveMinizip::~VolumeArchiveMinizip() {
   Cleanup();
 }
 
-bool VolumeArchiveLibarchive::Init(const std::string& encoding) {
+bool VolumeArchiveMinizip::Init(const std::string& encoding) {
   // Set up minizip object.
   zlib_filefunc_def zip_funcs;
   zip_funcs.zopen_file = volume_archive_functions::CustomArchiveOpen;
   zip_funcs.zread_file = volume_archive_functions::CustomArchiveRead;
   zip_funcs.zwrite_file = volume_archive_functions::CustomArchiveWrite;
   zip_funcs.ztell_file = volume_archive_functions::CustomArchiveTell;
   zip_funcs.zseek_file = volume_archive_functions::CustomArchiveSeek;
   zip_funcs.zclose_file = volume_archive_functions::CustomArchiveClose;
   zip_funcs.zerror_file = volume_archive_functions::CustomArchiveError;
   zip_funcs.opaque = static_cast<void*>(this);
@@ skipping 28 matching lines @@
 
   zip_file_ = unzOpen2(nullptr /* filename */, &zip_funcs);
   if (!zip_file_) {
     set_error_message(volume_archive_constants::kArchiveOpenError);
     return false;
   }
 
   return true;
 }
 
-VolumeArchive::Result VolumeArchiveLibarchive::GetCurrentFileInfo(
+VolumeArchive::Result VolumeArchiveMinizip::GetCurrentFileInfo(
     std::string* pathname,
     int64_t* size,
     bool* is_directory,
     time_t* modification_time) {
 
   // Headers are being read from the central directory (in the ZIP format), so
   // use a large block size to save on IPC calls. The headers in EOCD are
   // grouped one by one.
   reader_data_size_ = volume_archive_constants::kMaximumDataChunkSize;
 
@@ skipping 45 matching lines @@
   base::Time local_time;
   // If the modification time is not available, we set the value to the current
   // local time.
   if (!base::Time::FromLocalExploded(exploded_time, &local_time))
     local_time = base::Time::UnixEpoch();
   *modification_time = local_time.ToTimeT();
 
   return VolumeArchive::RESULT_SUCCESS;
 }
 
-VolumeArchive::Result VolumeArchiveLibarchive::GoToNextFile() {
+VolumeArchive::Result VolumeArchiveMinizip::GoToNextFile() {
   int return_value = unzGoToNextFile(zip_file_);
   if (return_value == UNZ_END_OF_LIST_OF_FILE) {
     return VolumeArchive::RESULT_EOF;
   }
   if (return_value == UNZ_OK)
     return VolumeArchive::RESULT_SUCCESS;
 
   set_error_message(volume_archive_constants::kArchiveNextHeaderError);
   return VolumeArchive::RESULT_FAIL;
 }
 
-bool VolumeArchiveLibarchive::SeekHeader(const std::string& path_name) {
+bool VolumeArchiveMinizip::SeekHeader(const std::string& path_name) {
   // Reset to 0 for new VolumeArchive::ReadData operation.
   last_read_data_offset_ = 0;
   decompressed_data_size_ = 0;
 
   const int kDefaultCaseSensivityOfOS = 0;
   if (unzLocateFile(zip_file_, path_name.c_str(), kDefaultCaseSensivityOfOS) !=
       UNZ_OK) {
     set_error_message(volume_archive_constants::kArchiveNextHeaderError);
     return false;
   }
@@ skipping 31 matching lines @@
   }
 
   if (open_result != UNZ_OK) {
     set_error_message(volume_archive_constants::kArchiveNextHeaderError);
     return false;
   }
 
   return true;
 }
 
-void VolumeArchiveLibarchive::DecompressData(int64_t offset, int64_t length) {
+void VolumeArchiveMinizip::DecompressData(int64_t offset, int64_t length) {
   // TODO(cmihail): As an optimization consider using archive_read_data_block
   // which avoids extra copying in case offset != last_read_data_offset_.
   // The logic will be more complicated because archive_read_data_block offset
   // will not be aligned with the offset of the read request from JavaScript.
 
   // Requests with offset smaller than last read offset are not supported.
   if (offset < last_read_data_offset_) {
     set_error_message(
         std::string(volume_archive_constants::kArchiveReadDataError));
     decompressed_error_ = true;
@@ skipping 59 matching lines @@
                               left_length);
     if (size < 0) {  // Error.
       set_error_message(volume_archive_constants::kArchiveReadDataError);
       decompressed_error_ = true;
       return;
     }
     bytes_read += size;
     left_length -= size;
   } while (left_length > 0 && size != 0);  // There is still data to read.
 
-  // VolumeArchiveLibarchive::DecompressData always stores the data from
-  // beginning of the buffer. VolumeArchiveLibarchive::ConsumeData is used
+  // VolumeArchiveMinizip::DecompressData always stores the data from
+  // beginning of the buffer. VolumeArchiveMinizip::ConsumeData is used
   // to preserve the bytes that are decompressed but not required by
-  // VolumeArchiveLibarchive::ReadData.
+  // VolumeArchiveMinizip::ReadData.
   decompressed_data_ = decompressed_data_buffer_;
   decompressed_data_size_ = bytes_read;
 }
 
-bool VolumeArchiveLibarchive::Cleanup() {
+bool VolumeArchiveMinizip::Cleanup() {
   bool returnValue = true;
   if (zip_file_) {
     if (unzClose(zip_file_) != UNZ_OK) {
       set_error_message(volume_archive_constants::kArchiveReadFreeError);
       returnValue = false;
     }
   }
   zip_file_ = nullptr;
 
   CleanupReader();
 
   return returnValue;
 }
 
-int64_t VolumeArchiveLibarchive::ReadData(int64_t offset,
+int64_t VolumeArchiveMinizip::ReadData(int64_t offset,
                                           int64_t length,
                                           const char** buffer) {
   PP_DCHECK(length > 0);              // Length must be at least 1.
   PP_DCHECK(current_archive_entry_);  // Check that GetNextHeader was called at
                                       // least once. In case it wasn't, this is
                                       // a programmer error.
   // In case of first read or no more available data in the internal buffer or
   // offset is different from the last_read_data_offset_, then force
-  // VolumeArchiveLibarchive::DecompressData as the decompressed data is
+  // VolumeArchiveMinizip::DecompressData as the decompressed data is
   // invalid.
   if (!decompressed_data_ || last_read_data_offset_ != offset ||
       decompressed_data_size_ == 0)
     DecompressData(offset, length);
 
   // Decompressed failed.
   if (decompressed_error_) {
     set_error_message(volume_archive_constants::kArchiveReadDataError);
     return -1 /* Error */;
   }
 
   last_read_data_length_ = length;  // Used for decompress ahead.
 
   // Assign the output *buffer parameter to the internal buffer.
   *buffer = decompressed_data_;
 
   // Advance internal buffer for next ReadData call.
   int64_t read_bytes = std::min(decompressed_data_size_, length);
   decompressed_data_ = decompressed_data_ + read_bytes;
   decompressed_data_size_ -= read_bytes;
   last_read_data_offset_ += read_bytes;
 
   PP_DCHECK(decompressed_data_ + decompressed_data_size_ <=
             decompressed_data_buffer_ +
                 volume_archive_constants::kDecompressBufferSize);
 
   return read_bytes;
 }
 
-void VolumeArchiveLibarchive::MaybeDecompressAhead() {
+void VolumeArchiveMinizip::MaybeDecompressAhead() {
   if (decompressed_data_size_ == 0)
     DecompressData(last_read_data_offset_, last_read_data_length_);
 }