current/sdk/common_os/include/external/zlib/google/zip_writer.h

// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef THIRD_PARTY_ZLIB_GOOGLE_ZIP_WRITER_H_
#define THIRD_PARTY_ZLIB_GOOGLE_ZIP_WRITER_H_

#include <memory>
#include <vector>

#include "base/files/file_path.h"
#include "base/time/time.h"
#include "build/build_config.h"
#include "third_party/zlib/google/zip.h"

#if defined(USE_SYSTEM_MINIZIP)
#include <minizip/unzip.h>
#include <minizip/zip.h>
#else
#include "third_party/zlib/contrib/minizip/unzip.h"
#include "third_party/zlib/contrib/minizip/zip.h"
#endif

namespace zip {
namespace internal {

// A class used to write entries to a ZIP file and buffering the reading of
// files to limit the number of calls to the FileAccessor. This is for
// performance reasons as these calls may be expensive when IPC based).
// This class is so far internal and only used by zip.cc, but could be made
// public if needed.
//
// All methods returning a bool return true on success and false on error.
class ZipWriter {
 public:
// Creates a writer that will write a ZIP file to |zip_file_fd| or |zip_file|
// and which entries are relative to |file_accessor|'s source directory.
// All file reads are performed using |file_accessor|.
#if defined(OS_POSIX) || defined(OS_FUCHSIA)
  static std::unique_ptr<ZipWriter> CreateWithFd(int zip_file_fd,
                                                 FileAccessor* file_accessor);
#endif

  static std::unique_ptr<ZipWriter> Create(const base::FilePath& zip_file,
                                           FileAccessor* file_accessor);

  ZipWriter(const ZipWriter&) = delete;
  ZipWriter& operator=(const ZipWriter&) = delete;

  ~ZipWriter();

  // Sets the optional progress callback. The callback is called once for each
  // time |period|. The final callback is always called when the ZIP operation
  // completes.
  void SetProgressCallback(ProgressCallback callback, base::TimeDelta period) {
    progress_callback_ = std::move(callback);
    progress_period_ = std::move(period);
  }

  // Should ignore missing files and directories?
  void ContinueOnError(bool continue_on_error) {
    continue_on_error_ = continue_on_error;
  }

  // Sets the recursive flag, indicating whether the contents of subdirectories
  // should be included.
  void SetRecursive(bool b) { recursive_ = b; }

  // Sets the filter callback.
  void SetFilterCallback(FilterCallback callback) {
    filter_callback_ = std::move(callback);
  }

  // Adds the contents of a directory. If the recursive flag is set, the
  // contents of subdirectories are also added.
  bool AddDirectoryContents(const base::FilePath& path);

  // Adds the entries at |paths| to the ZIP file. These can be a mixed bag of
  // files and directories. If the recursive flag is set, the contents of
  // subdirectories is also added.
  bool AddMixedEntries(Paths paths);

  // Closes the ZIP file.
  bool Close();

 private:
  // Takes ownership of |zip_file|.
  ZipWriter(zipFile zip_file, FileAccessor* file_accessor);

  // Regularly called during processing to check whether zipping should continue
  // or should be cancelled.
  bool ShouldContinue();

  // Adds file content to currently open file entry.
  bool AddFileContent(const base::FilePath& path, base::File file);

  // Adds a file entry (including file contents).
  bool AddFileEntry(const base::FilePath& path, base::File file);

  // Adds file entries. All the paths should be existing files.
  bool AddFileEntries(Paths paths);

  // Adds a directory entry. If the recursive flag is set, the contents of this
  // directory are also added.
  bool AddDirectoryEntry(const base::FilePath& path);

  // Adds directory entries. All the paths should be existing directories. If
  // the recursive flag is set, the contents of these directories are also
  // added.
  bool AddDirectoryEntries(Paths paths);

  // Opens a file or directory entry.
  bool OpenNewFileEntry(const base::FilePath& path,
                        bool is_directory,
                        base::Time last_modified);

  // Closes the currently open entry.
  bool CloseNewFileEntry();

  // Filters entries.
  void Filter(std::vector<base::FilePath>* paths);

  // The actual zip file.
  zipFile zip_file_;

  // Abstraction over file access methods used to read files.
  FileAccessor* const file_accessor_;

  // Progress stats.
  Progress progress_;

  // Optional progress callback.
  ProgressCallback progress_callback_;

  // Optional progress reporting period.
  base::TimeDelta progress_period_;

  // Next time to report progress.
  base::TimeTicks next_progress_report_time_ = base::TimeTicks::Now();

  // Filter used to exclude files from the ZIP file.
  FilterCallback filter_callback_;

  // Should recursively add directories?
  bool recursive_ = false;

  // Should ignore missing files and directories?
  bool continue_on_error_ = false;
};

}  // namespace internal
}  // namespace zip

#endif  // THIRD_PARTY_ZLIB_GOOGLE_ZIP_WRITER_H_