Adds asynchronous unzip functions to ZipReader

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/file_util.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "base/platform_file.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 {
@@ skipping 11 matching lines @@
 //   }
 //
 // For simplicty, error checking is omitted in the example code above. The
 // production code should check return values from all of these functions.
 //
 // This calls can also be used for random access of contents in a zip file
 // using LocateAndOpenEntry().
 //
 class ZipReader {
  public:
+  // A callback that is called when the operation is successful.
+  typedef base::Closure SuccessCallback;
+  // A callback that is called when the operation fails.
+  typedef base::Closure FailureCallback;
+  // A callback that is called periodically during the operation with the number
+  // of bytes that have been processed so far.
+  typedef base::Callback<void(int64)> ProgressCallback;
+
   // This class represents information of an entry (file or directory) in
   // a zip file.
   class EntryInfo {
    public:
     EntryInfo(const std::string& filename_in_zip,
               const unz_file_info& raw_file_info);
 
     // Returns the file path. The path is usually relative like
     // "foo/bar.txt", but if it's absolute, is_unsafe() returns true.
     const base::FilePath& file_path() const { return file_path_; }
@@ skipping 77 matching lines @@
 
   // 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);
 
+  // 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
@@ skipping 17 matching lines @@
   // Open() must be called beforehand.
   int num_entries() const { return num_entries_; }
 
  private:
   // Common code used both in Open and OpenFromFd.
   bool OpenInternal();
 
   // Resets the internal state.
   void Reset();
 
+  // Extracts a chunk of the file to the target.  Will post a task for the next
+  // chunk and success/failure/progress callbacks as necessary.
+  void ExtractChunk(base::PlatformFile target_file,
+                    const SuccessCallback& success_callback,
+                    const FailureCallback& failure_callback,
+                    const ProgressCallback& progress_callback,
+                    const int64 offset);
+
   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);
 };
 
 }  // namespace zip
 
 #endif  // THIRD_PARTY_ZLIB_GOOGLE_ZIP_READER_H_