Replace Libarchive with 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 "archive.h"
+#include "third_party/zlib/contrib/minizip/unzip.h"
+
 #include "ppapi/cpp/logging.h"
 
 VolumeReaderJavaScriptStream::VolumeReaderJavaScriptStream(
     int64_t archive_size,
     JavaScriptRequestorInterface* requestor)
     : archive_size_(archive_size),
       requestor_(requestor),
       available_data_(false),
       read_error_(false),
       passphrase_error_(false),
       offset_(0),
       last_read_chunk_offset_(-1) /* For first call -1 will force a chunk
                                      request from JavaScript as offset
                                      parameter is 0. */,
       read_ahead_array_buffer_ptr_(&first_array_buffer_) {
-  pthread_mutex_init(&shared_state_lock_, NULL);
-  pthread_cond_init(&available_data_cond_, NULL);
-  pthread_cond_init(&available_passphrase_cond_, NULL);
+  pthread_mutex_init(&shared_state_lock_, nullptr);
+  pthread_cond_init(&available_data_cond_, nullptr);
+  pthread_cond_init(&available_passphrase_cond_, nullptr);
 
   // Dummy Map the second buffer as first buffer is used for read ahead by
   // read_ahead_array_buffer_ptr_. This operation is required in order for Unmap
   // to correctly work in the destructor and VolumeReaderJavaScriptStream::Read.
   second_array_buffer_.Map();
 }
 
 VolumeReaderJavaScriptStream::~VolumeReaderJavaScriptStream() {
   pthread_mutex_destroy(&shared_state_lock_);
   pthread_cond_destroy(&available_data_cond_);
@@ skipping 74 matching lines @@
 
   pthread_mutex_lock(&shared_state_lock_);
 
   // No more data, so signal end of reading.
   if (offset_ >= archive_size_) {
     pthread_mutex_unlock(&shared_state_lock_);
     return 0;
   }
 
   // Call in case of first read or read after Seek and Skip.
-  if (last_read_chunk_offset_ != offset_)
+  if (last_read_chunk_offset_ != offset_ || !available_data_)
     RequestChunk(bytes_to_read);
 
   if (!available_data_) {
     // Wait for data from JavaScript.
     while (!available_data_) {  // Check again available data as first call
                                 // was done outside guarded zone.
       if (read_error_) {
         pthread_mutex_unlock(&shared_state_lock_);
-        return ARCHIVE_FATAL;
+        return -1;
       }
       pthread_cond_wait(&available_data_cond_, &shared_state_lock_);
     }
   }
 
   if (read_error_) {  // Read ahead failed.
     pthread_mutex_unlock(&shared_state_lock_);
-    return ARCHIVE_FATAL;
+    return -1;
   }
 
   // Make data available for libarchive 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 =
@@ skipping 29 matching lines @@
   pthread_mutex_unlock(&shared_state_lock_);
 
   return bytes_read;
 }
 
 int64_t VolumeReaderJavaScriptStream::Seek(int64_t offset, int whence) {
   pthread_mutex_lock(&shared_state_lock_);
 
   int64_t new_offset = offset_;
   switch (whence) {
-    case SEEK_SET:
+    case ZLIB_FILEFUNC_SEEK_SET:
       new_offset = offset;
       break;
-    case SEEK_CUR:
+    case ZLIB_FILEFUNC_SEEK_CUR:
       new_offset += offset;
       break;
-    case SEEK_END:
+    case ZLIB_FILEFUNC_SEEK_END:
       new_offset = archive_size_ + offset;
       break;
     default:
       PP_NOTREACHED();
       pthread_mutex_unlock(&shared_state_lock_);
-      return ARCHIVE_FATAL;
+      return -1;
   }
 
-  if (new_offset < 0 || new_offset > archive_size_) {
+  if (new_offset < 0) {
     pthread_mutex_unlock(&shared_state_lock_);
-    return ARCHIVE_FATAL;
+    return -1;
   }
 
   offset_ = new_offset;
   pthread_mutex_unlock(&shared_state_lock_);
 
   return new_offset;
 }
 
-int64_t VolumeReaderJavaScriptStream::Skip(int64_t bytes_to_skip) {
-  pthread_mutex_lock(&shared_state_lock_);
-  // Invalid bytes_to_skip. This "if" can be triggered for corrupted archives.
-  // We return 0 instead of ARCHIVE_FATAL in order for libarchive to use normal
-  // Read and return the correct error. In case we return ARCHIVE_FATAL here
-  // then libarchive just stops without telling us why it wasn't able to
-  // process the archive.
-  if (archive_size_ - offset_ < bytes_to_skip || bytes_to_skip < 0) {
-    pthread_mutex_unlock(&shared_state_lock_);
-    return 0;
-  }
-
-  offset_ += bytes_to_skip;
-  pthread_mutex_unlock(&shared_state_lock_);
-
-  return bytes_to_skip;
-}
-
 void VolumeReaderJavaScriptStream::SetRequestId(const std::string& request_id) {
   // No lock necessary, as request_id is used by one thread only.
   request_id_ = request_id;
 }
 
 const char* VolumeReaderJavaScriptStream::Passphrase() {
   // The error is not recoverable. Once passphrase fails to be provided, it is
   // never asked again. Note, that still users are able to retry entering the
   // password, unless they click Cancel.
   pthread_mutex_lock(&shared_state_lock_);
   if (passphrase_error_) {
     pthread_mutex_unlock(&shared_state_lock_);
-    return NULL;
+    return nullptr;
   }
   pthread_mutex_unlock(&shared_state_lock_);
 
   // Request the passphrase outside of the lock.
   requestor_->RequestPassphrase(request_id_);
 
   pthread_mutex_lock(&shared_state_lock_);
   // Wait for the passphrase from JavaScript.
   pthread_cond_wait(&available_passphrase_cond_, &shared_state_lock_);
-  const char* result = NULL;
+  const char* result = nullptr;
   if (!passphrase_error_)
     result = strdup(available_passphrase_.c_str());
   pthread_mutex_unlock(&shared_state_lock_);
 
   return result;
 }
 
 void VolumeReaderJavaScriptStream::RequestChunk(int64_t length) {
   // 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);
 }