Replace Libarchive with MiniZip.

ui/file_manager/zip_archiver/cpp/compressor.cc

 // Copyright 2017 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 "compressor.h"
 
 #include <cstring>
 #include <ctime>
 #include <sstream>
 
+#include "compressor_archive_libarchive.h"

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

Let's rename files in a separate CL.

+#include "compressor_io_javascript_stream.h"
 #include "request.h"
-#include "compressor_io_javascript_stream.h"
-#include "compressor_archive_libarchive.h"
 
 namespace {
 
 // An internal implementation of JavaScriptCompressorRequestorInterface.
 class JavaScriptCompressorRequestor : public JavaScriptCompressorRequestorInterface {
  public:
   explicit JavaScriptCompressorRequestor(Compressor* compressor) :
       compressor_(compressor) {}
 
-  virtual void WriteChunkRequest(int64_t length,
+  virtual void WriteChunkRequest(int64_t offset,
+                                 int64_t length,
                                  const pp::VarArrayBuffer& buffer) {
-    compressor_->message_sender()->SendWriteChunk(
-        compressor_->compressor_id(), buffer, length);
+    compressor_->message_sender()->SendWriteChunk(compressor_->compressor_id(),
+                                                  buffer, offset, length);
   }
 
   virtual void ReadFileChunkRequest(int64_t length) {
     compressor_->message_sender()->SendReadFileChunk(
         compressor_->compressor_id(), length);
   }
 
  private:
   Compressor* compressor_;
 };
@@ skipping 19 matching lines @@
   delete compressor_archive_;
   delete compressor_stream_;
   delete requestor_;
 }
 
 bool Compressor::Init() {
   return worker_.Start();
 }
 
 void Compressor::CreateArchive() {
-  compressor_archive_->CreateArchive();
+  if (!compressor_archive_->CreateArchive()) {
+    message_sender_->SendCompressorError(
+        compressor_id_,
+        compressor_archive_->error_message());
+    return;
+  }
   message_sender_->SendCreateArchiveDone(compressor_id_);
 }
 
 void Compressor::AddToArchive(const pp::VarDictionary& dictionary) {
   worker_.message_loop().PostWork(callback_factory_.NewCallback(
       &Compressor::AddToArchiveCallback, dictionary));
 }
 
 void Compressor::AddToArchiveCallback(int32_t,
                                       const pp::VarDictionary& dictionary) {
   PP_DCHECK(dictionary.Get(request::key::kPathname).is_string());
   std::string pathname =
       dictionary.Get(request::key::kPathname).AsString();
 
   PP_DCHECK(dictionary.Get(request::key::kFileSize).is_string());
   int64_t file_size =
       request::GetInt64FromString(dictionary, request::key::kFileSize);
   PP_DCHECK(file_size >= 0);
 
   PP_DCHECK(dictionary.Get(request::key::kIsDirectory).is_bool());
   bool is_directory =
       dictionary.Get(request::key::kIsDirectory).AsBool();
 
   PP_DCHECK(dictionary.Get(request::key::kModificationTime).is_string());
-  std::string strtime =
-      dictionary.Get(request::key::kModificationTime).AsString();
-  tm tm;
-  strptime(strtime.c_str(), "%m/%d/%Y %T", &tm);
-  time_t modification_time = mktime(&tm);
+  // Since modification_time is milliseconds, we hold the value in int64_t.
+  int64_t modification_time =
+      static_cast<int64_t>(request::GetInt64FromString(dictionary,
+                                               request::key::kModificationTime));
 
-  compressor_archive_->AddToArchive(
-      pathname, file_size, modification_time, is_directory);
+  if (!compressor_archive_->AddToArchive(
+      pathname, file_size, modification_time, is_directory)) {
+    message_sender_->SendCompressorError(
+        compressor_id_,
+        compressor_archive_->error_message());
+    return;
+  }
   message_sender_->SendAddToArchiveDone(compressor_id_);
 }
 
 void Compressor::ReadFileChunkDone(const pp::VarDictionary& dictionary) {
   PP_DCHECK(dictionary.Get(request::key::kLength).is_string());
   int64_t read_bytes =
       request::GetInt64FromString(dictionary, request::key::kLength);
 
   PP_DCHECK(dictionary.Get(request::key::kChunkBuffer).is_array_buffer());
   pp::VarArrayBuffer array_buffer(dictionary.Get(request::key::kChunkBuffer));
@@ skipping 10 matching lines @@
 }
 
 void Compressor::CloseArchive(const pp::VarDictionary& dictionary) {
   PP_DCHECK(dictionary.Get(request::key::kHasError).is_bool());
   bool has_error =
       dictionary.Get(request::key::kHasError).AsBool();
 
   // If an error has occurred, no more write chunk requests are sent and
   // CloseArchive() can be safely called in the main thread.
   if (has_error) {
-    compressor_archive_->CloseArchive(has_error);
+    if (!compressor_archive_->CloseArchive(has_error)) {
+      message_sender_->SendCompressorError(
+          compressor_id_,
+          compressor_archive_->error_message());
+      return;
+    }
     message_sender_->SendCloseArchiveDone(compressor_id_);
   } else {
     worker_.message_loop().PostWork(callback_factory_.NewCallback(
         &Compressor::CloseArchiveCallback, has_error));
   }
 }
 
 void Compressor::CloseArchiveCallback(int32_t, bool has_error) {
-  compressor_archive_->CloseArchive(has_error);
+  if (!compressor_archive_->CloseArchive(has_error)) {
+    message_sender_->SendCompressorError(
+        compressor_id_,
+        compressor_archive_->error_message());
+    return;
+  }
   message_sender_->SendCloseArchiveDone(compressor_id_);
 }