Replace Libarchive with MiniZip.

ui/file_manager/zip_archiver/cpp/volume.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.h"
 
 #include <cstring>
 #include <sstream>
 
 #include "request.h"
@@ skipping 164 matching lines @@
                                        archive_size(archive_size) {}
   const std::string request_id;
   const int64_t index;
   const std::string encoding;
   const int64_t archive_size;
 };
 
 Volume::Volume(const pp::InstanceHandle& instance_handle,
                const std::string& file_system_id,
                JavaScriptMessageSenderInterface* message_sender)
-    : volume_archive_(NULL),
+    : volume_archive_(nullptr),
       file_system_id_(file_system_id),
       message_sender_(message_sender),
       worker_(instance_handle),
       callback_factory_(this) {
   requestor_ = new JavaScriptRequestor(this);
   volume_archive_factory_ = new VolumeArchiveFactory();
   volume_reader_factory_ = new VolumeReaderFactory(this);
   // Delegating constructors only from c++11.
 }
 
 Volume::Volume(const pp::InstanceHandle& instance_handle,
                const std::string& file_system_id,
                JavaScriptMessageSenderInterface* message_sender,
                VolumeArchiveFactoryInterface* volume_archive_factory,
                VolumeReaderFactoryInterface* volume_reader_factory)
-    : volume_archive_(NULL),
+    : volume_archive_(nullptr),
       file_system_id_(file_system_id),
       message_sender_(message_sender),
       worker_(instance_handle),
       callback_factory_(this),
       volume_archive_factory_(volume_archive_factory),
       volume_reader_factory_(volume_reader_factory) {
   requestor_ = new JavaScriptRequestor(this);
 }
 
 Volume::~Volume() {
@@ skipping 104 matching lines @@
   static_cast<VolumeReaderJavaScriptStream*>(volume_archive_->reader())->
       SetRequestId(request_id);
   reader_request_id_ = request_id;
   job_lock_.Release();
 
   if (!volume_archive_->Init(encoding)) {
     message_sender_->SendFileSystemError(
         file_system_id_, request_id, volume_archive_->error_message());
     ClearJob();
     delete volume_archive_;
-    volume_archive_ = NULL;
+    volume_archive_ = nullptr;
     return;
   }
 
   // Read and construct metadata.
   pp::VarDictionary root_metadata = CreateEntry(-1, "" /* name */, true, 0, 0);
 
-  const char* path_name = NULL;
+  std::string path_name;
   int64_t size = 0;
   bool is_directory = false;
   time_t modification_time = 0;
   int64_t index = 0;
 
   for (;;) {
-    VolumeArchive::Result ret = volume_archive_->GetNextHeader(
-        &path_name, &size, &is_directory, &modification_time);
-    if (ret == VolumeArchive::RESULT_FAIL) {
-      message_sender_->SendFileSystemError(
-          file_system_id_, request_id, volume_archive_->error_message());
+    path_name.clear();
+    if (volume_archive_->GetCurrentFileInfo(
+        &path_name,
+        &size,
+        &is_directory,
+        &modification_time) == VolumeArchive::RESULT_FAIL) {
+      message_sender_->SendFileSystemError(file_system_id_, request_id,
+                                           volume_archive_->error_message());
       ClearJob();
       delete volume_archive_;
-      volume_archive_ = NULL;
+      volume_archive_ = nullptr;
       return;
-    } else if (ret == VolumeArchive::RESULT_EOF)
+    }
+
+    if (path_name.empty())  // End of archive.
       break;
 
-    ConstructMetadata(index, path_name, size, is_directory, modification_time,
-        &root_metadata);
+    ConstructMetadata(index, path_name.c_str(), size, is_directory,
+                      modification_time, &root_metadata);
+
+    index_to_pathname_[index] = path_name;
 
     ++index;
+
+    int return_value = volume_archive_->GoToNextFile();
+    if (return_value == VolumeArchive::RESULT_FAIL) {
+      message_sender_->SendFileSystemError(file_system_id_, request_id,
+                                           volume_archive_->error_message());
+      ClearJob();
+      delete volume_archive_;
+      volume_archive_ = nullptr;
+      return;
+    }
+    if (return_value == VolumeArchive::RESULT_EOF)
+      break;
   }
 
   ClearJob();
 
   // Send metadata back to JavaScript.
-  message_sender_->SendReadMetadataDone(
-      file_system_id_, request_id, root_metadata);
+  message_sender_->SendReadMetadataDone(file_system_id_, request_id,
+                                        root_metadata);
 }
 
 void Volume::OpenFileCallback(int32_t /*result*/,
                               const OpenFileArgs& args) {
   if (!volume_archive_) {
      message_sender_->SendFileSystemError(
          file_system_id_, args.request_id, "NOT_OPENED");
      return;
   }
 
   job_lock_.Acquire();
   if (!reader_request_id_.empty()) {
     // It is illegal to open a file while another operation is in progress or
     // another file is opened.
     message_sender_->SendFileSystemError(
         file_system_id_, args.request_id, "ILLEGAL");
     job_lock_.Release();
     return;
   }
-  static_cast<VolumeReaderJavaScriptStream*>(volume_archive_->reader())->
-      SetRequestId(args.request_id);
+
+  static_cast<VolumeReaderJavaScriptStream*>(volume_archive_->reader())
+      ->SetRequestId(args.request_id);
   reader_request_id_ = args.request_id;
   job_lock_.Release();
 
-  if (!volume_archive_->SeekHeader(args.index)) {
-    message_sender_->SendFileSystemError(
-        file_system_id_, args.request_id, volume_archive_->error_message());
+  std::string path_name = index_to_pathname_[args.index];
+  int64_t size = 0;
+  bool is_directory = false;
+  time_t modification_time = 0;
+
+  if (!volume_archive_->SeekHeader(path_name)) {
+    message_sender_->SendFileSystemError(file_system_id_, args.request_id,
+                                         volume_archive_->error_message());
     ClearJob();
     return;
   }
 
-  if (volume_archive_->GetNextHeader() == VolumeArchive::RESULT_FAIL) {
-    message_sender_->SendFileSystemError(
-        file_system_id_, args.request_id, volume_archive_->error_message());
+  if (volume_archive_->GetCurrentFileInfo(
+      &path_name,
+      &size,
+      &is_directory,
+      &modification_time) != VolumeArchive::RESULT_SUCCESS) {
+    message_sender_->SendFileSystemError(file_system_id_, args.request_id,
+                                         volume_archive_->error_message());
     ClearJob();
     return;
   }
 
   // Send successful opened file response to NaCl.
   message_sender_->SendOpenFileDone(file_system_id_, args.request_id);
 }
 
 void Volume::CloseFileCallback(int32_t /*result*/,
                                const std::string& request_id,
@@ skipping 30 matching lines @@
         file_system_id_, request_id, "FILE_NOT_OPENED");
     job_lock_.Release();
     return;
   }
   job_lock_.Release();
 
   // Decompress data and send it to JavaScript. Sending data is done in chunks
   // depending on how many bytes VolumeArchive::ReadData returns.
   int64_t left_length = length;
   while (left_length > 0) {
-    const char* destination_buffer = NULL;
+    const char* destination_buffer = nullptr;
     int64_t read_bytes = volume_archive_->ReadData(
         offset, left_length, &destination_buffer);
 
     if (read_bytes < 0) {
       // Error messages should be sent to the read request (request_id), not
       // open request (open_request_id), as the last one has finished and this
       // is a read file.
       message_sender_->SendFileSystemError(
           file_system_id_, request_id, volume_archive_->error_message());
 
@@ skipping 22 matching lines @@
   }
   volume_archive_->MaybeDecompressAhead();
 }
 
 
 void Volume::ClearJob() {
   job_lock_.Acquire();
   reader_request_id_ = "";
   job_lock_.Release();
 }