Add ZipReader::ExtractCurrentEntry with a delegate interface.

third_party/zlib/google/zip_reader.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // 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_READER_H_
 #define THIRD_PARTY_ZLIB_GOOGLE_ZIP_READER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 
 #if defined(USE_SYSTEM_MINIZIP)
 #include <minizip/unzip.h>
 #else
 #include "third_party/zlib/contrib/minizip/unzip.h"
 #endif
 
 namespace zip {
 
+// A delegate interface used to stream out an entry; see
+// ZipReader::ExtractCurrentEntry.
+class WriterDelegate {
+ public:
+  virtual ~WriterDelegate() {}
+
+  // Invoked once before any data is streamed out to pave the way (e.g., to open
+  // the output file). Return false on failure to cancel extraction.
+  virtual bool PrepareOutput() = 0;
+
+  // Invoked to write the next chunk of data. Return false on failure to cancel
+  // extraction.
+  virtual bool WriteBytes(const char* data, int num_bytes) = 0;
+};
+
 // This class is used for reading zip files. A typical use case of this
 // class is to scan entries in a zip file and extract them. The code will
 // look like:
 //
 //   ZipReader reader;
 //   reader.Open(zip_file_path);
 //   while (reader.HasMore()) {
 //     reader.OpenCurrentEntryInZip();
 //     reader.ExtractCurrentEntryToDirectory(output_directory_path);
 //     reader.AdvanceToNextEntry();
@@ skipping 98 matching lines @@
   //
   // Note that there is no CloseCurrentEntryInZip(). The the current entry
   // state is reset automatically as needed.
   bool OpenCurrentEntryInZip();
 
   // Locates an entry in the zip file and opens it. Returns true on
   // success. This function internally calls OpenCurrentEntryInZip() on
   // success. On failure, current_entry_info() becomes NULL.
   bool LocateAndOpenEntry(const base::FilePath& path_in_zip);
 
+  // Extracts the current entry in chunks to |delegate|.
+  bool ExtractCurrentEntry(WriterDelegate* delegate) const;
+
   // Extracts the current entry to the given output file path. If the
   // current file is a directory, just creates a directory
   // instead. Returns true on success. OpenCurrentEntryInZip() must be
   // called beforehand.
   //
   // This function preserves the timestamp of the original entry. If that
   // timestamp is not valid, the timestamp will be set to the current time.
-  bool ExtractCurrentEntryToFilePath(const base::FilePath& output_file_path);
+  bool ExtractCurrentEntryToFilePath(
+      const base::FilePath& output_file_path) const;
 
   // Asynchronously extracts the current entry to the given output file path.
   // If the current entry is a directory it just creates the directory
   // synchronously instead.  OpenCurrentEntryInZip() must be called beforehand.
   // success_callback will be called on success and failure_callback will be
   // called on failure.  progress_callback will be called at least once.
   // Callbacks will be posted to the current MessageLoop in-order.
   void ExtractCurrentEntryToFilePathAsync(
       const base::FilePath& output_file_path,
       const SuccessCallback& success_callback,
       const FailureCallback& failure_callback,
       const ProgressCallback& progress_callback);
 
   // Extracts the current entry to the given output directory path using
   // ExtractCurrentEntryToFilePath(). Sub directories are created as needed
   // based on the file path of the current entry. For example, if the file
   // path in zip is "foo/bar.txt", and the output directory is "output",
   // "output/foo/bar.txt" will be created.
   //
   // Returns true on success. OpenCurrentEntryInZip() must be called
   // beforehand.
   //
   // This function preserves the timestamp of the original entry. If that
   // timestamp is not valid, the timestamp will be set to the current time.
   bool ExtractCurrentEntryIntoDirectory(
-      const base::FilePath& output_directory_path);
+      const base::FilePath& output_directory_path) const;
 
-#if defined(OS_POSIX)
-  // Extracts the current entry by writing directly to a file descriptor.
-  // Does not close the file descriptor. Returns true on success.
-  bool ExtractCurrentEntryToFd(int fd);
-#endif
+  // Extracts the current entry by writing directly to a platform file.
+  // Does not close the file. Returns true on success.
+  bool ExtractCurrentEntryToFile(base::File* file) const;
 
   // Extracts the current entry into memory. If the current entry is a directory
   // the |output| parameter is set to the empty string. If the current entry is
   // a file, the |output| parameter is filled with its contents. Returns true on
   // success. OpenCurrentEntryInZip() must be called beforehand.
   // Note: the |output| parameter can be filled with a big amount of data, avoid
   // passing it around by value, but by reference or pointer.
   // Note: the value returned by EntryInfo::original_size() cannot be
   // trusted, so the real size of the uncompressed contents can be different.
   // Use max_read_bytes to limit the ammount of memory used to carry the entry.
@@ skipping 31 matching lines @@
   unzFile zip_file_;
   int num_entries_;
   bool reached_end_;
   scoped_ptr<EntryInfo> current_entry_info_;
 
   base::WeakPtrFactory<ZipReader> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ZipReader);
 };
 
+// A writer delegate that writes to a given File.
+class FileWriterDelegate : public WriterDelegate {
+ public:
+  explicit FileWriterDelegate(base::File* file);
+
+  // Truncates the file to the number of bytes written.
+  ~FileWriterDelegate() override;
+
+  // WriterDelegate methods:
+
+  // Seeks to the beginning of the file, returning false if the seek fails.
+  bool PrepareOutput() override;
+
+  // Writes |num_bytes| bytes of |data| to the file, returning false on error or
+  // if not all bytes could be written.
+  bool WriteBytes(const char* data, int num_bytes) override;
+
+ private:
+  base::File* file_;
+  int64_t file_length_;
+
+  DISALLOW_COPY_AND_ASSIGN(FileWriterDelegate);
+};
+
 }  // namespace zip
 
 #endif  // THIRD_PARTY_ZLIB_GOOGLE_ZIP_READER_H_