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

ui/file_manager/zip_archiver/cpp/volume_reader_javascript_stream.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_reader_javascript_stream.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "third_party/zlib/contrib/minizip/unzip.h"
@@ skipping 53 matching lines @@
   // true then the second read ahead data is the same as the first read ahead
   // data so we can just ignore it.
 
   // TODO(mtomasz): We don't need to discard everything. Sometimes part of the
   // buffer can still be used. In such case we should use it. That can greatly
   // improve traversing headers for archives with small files!
 
   pthread_mutex_lock(&shared_state_lock_);
   if (read_offset == offset_ && !available_data_ && !read_error_) {
     // Signal VolumeReaderJavaScriptStream::Read to continue execution. Copies
-    // buffer locally so libarchive has the buffer in memory when working with
+    // buffer locally so minizip has the buffer in memory when working with
     // it. Though we acquire a lock here this call is blocking only for a few
     // moments as VolumeReaderJavaScriptStream::Read will release the lock with
     // pthread_cond_wait. So we cannot arrive at a deadlock that will block the
     // main thread.
 
     *read_ahead_array_buffer_ptr_ = array_buffer;  // Copy operation.
     available_data_ = true;
 
     pthread_cond_signal(&available_data_cond_);
   }
@@ skipping 49 matching lines @@
       }
       pthread_cond_wait(&available_data_cond_, &shared_state_lock_);
     }
   }
 
   if (read_error_) {  // Read ahead failed.
     pthread_mutex_unlock(&shared_state_lock_);
     return -1;
   }
 
-  // Make data available for libarchive custom read. No need to lock this part.
+  // Make data available for minizip custom read. No need to lock this part.
   // The reason is that VolumeReaderJavaScriptStream::RequestChunk is the only
   // function that can set available_data_ back to false and let
   // VolumeReaderJavaScriptStream::SetBufferAndSignal overwrite the buffer. But
   // reading ahead is done only at the end of this function after the buffers
   // are switched.
   *destination_buffer = read_ahead_array_buffer_ptr_->Map();
   int64_t bytes_read =
       std::min(static_cast<int64_t>(read_ahead_array_buffer_ptr_->ByteLength()),
                bytes_to_read);
 
   offset_ += bytes_read;
   last_read_chunk_offset_ = offset_;
 
   // Ask for more data from JavaScript in the other buffer. This is the only
-  // time when we switch buffers. The reason is that libarchive must
+  // time when we switch buffers. The reason is that minizip must
   // always work on valid data and that data must be available until next
   // VolumeReaderJavaScriptStream::Read call, and as the data can be received
   // at any time from JavaScript, we need a buffer to store it in case of
   // reading ahead.
   read_ahead_array_buffer_ptr_ =
       read_ahead_array_buffer_ptr_ != &first_array_buffer_
           ? &first_array_buffer_
           : &second_array_buffer_;
 
   // Unmap old buffer. Only Read and constructor can Map the buffers so Read and
@@ skipping 78 matching lines @@
   // Read next chunk only if not at the end of archive.
   if (archive_size_ <= offset_)
     return;
 
   int64_t bytes_to_read =
       std::min(length, archive_size_ - offset_ /* Positive check above. */);
   available_data_ = false;
 
   requestor_->RequestFileChunk(request_id_, offset_, bytes_to_read);
 }