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 312 matching lines @@
         file_system_id_, request_id, volume_archive_->error_message());
     ClearJob();
     delete volume_archive_;
     volume_archive_ = NULL;
     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;
       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();

[mtomasz, 2017/04/10 07:15:09]

Please check performance of opening large files. I usually try linux hernel
here:

https://github.com/torvalds/linux/archive/master.zip

How does it compare with libarchive?

[takise, 2017/04/11 06:00:51]

I compared the time to open
https://github.com/torvalds/linux/archive/master.zip. 
libarchive takes about 8~10sec, while minizip takes about 20 sec.

I'm not sure this regression is endurable.

I don't think we can make this operation faster with minizip anymore.
I investigated how minizip requests data carefully and optimize it as much as we
can so that it runs efficiently even for large zip files.
(Please look at my comment in volume_archive_libarchive.h to see how it works.)

wdyt?

[mtomasz, 2017/04/11 06:36:45]

Thanks for checking. 2 times slower on such a large archive is not terrible. I'm
curious why it's slower though. Maybe the entire central directory doesn't fit
in static cache? Is there any easy way to check it?


Note, that we don't have to fix it in this CL.

+    if (return_value == VolumeArchive::RESULT_FAIL) {
+      message_sender_->SendFileSystemError(file_system_id_, request_id,
+                                           volume_archive_->error_message());
+      ClearJob();
+      delete volume_archive_;
+      volume_archive_ = NULL;
+      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 73 matching lines @@
   }
   volume_archive_->MaybeDecompressAhead();
 }
 
 
 void Volume::ClearJob() {
   job_lock_.Acquire();
   reader_request_id_ = "";
   job_lock_.Release();
 }