Adds asynchronous unzip functions to ZipReader

third_party/zlib/google/zip_reader.cc

 // Copyright (c) 2012 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.
 
 #include "third_party/zlib/google/zip_reader.h"
 
 #include "base/file_util.h"
+#include "base/location.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/file_stream.h"
 #include "third_party/zlib/google/zip_internal.h"
 
 #if defined(USE_SYSTEM_MINIZIP)
 #include <minizip/unzip.h>
 #else
 #include "third_party/zlib/contrib/minizip/unzip.h"
 #if defined(OS_WIN)
 #include "third_party/zlib/contrib/minizip/iowin32.h"
 #endif  // defined(OS_WIN)
 #endif  // defined(USE_SYSTEM_MINIZIP)
 
 namespace zip {
 
+namespace {
+
+// A listener that will close a PlatformFile when the operation is complete,
+// with a delegate to pass events to.  This is used by some asynchronous
+// functions to ensure a PlatformFile is closed when done.
+class FileClosingListener : public ZipReader::Listener {
+ public:
+  FileClosingListener(scoped_refptr<ZipReader::Listener> delegate,
+                      base::PlatformFile platform_file) 
+      : delegate_(delegate),
+        platform_file_(platform_file) {
+  }
+
+  virtual void OnUnzipProgress(int progress) OVERRIDE {
+    delegate_->OnUnzipProgress(progress);
+  }
+
+  virtual void OnUnzipSuccess() OVERRIDE {
+    base::ClosePlatformFile(platform_file_);
+    delegate_->OnUnzipSuccess();
+  }
+
+  virtual void OnUnzipFailed() OVERRIDE {
+    base::ClosePlatformFile(platform_file_);
+    delegate_->OnUnzipFailed();
+  }
+
+ private:
+  scoped_refptr<ZipReader::Listener> delegate_;
+  base::PlatformFile platform_file_;
+};
+
+} // namespace
+
 // TODO(satorux): The implementation assumes that file names in zip files
 // are encoded in UTF-8. This is true for zip files created by Zip()
 // function in zip.h, but not true for user-supplied random zip files.
 ZipReader::EntryInfo::EntryInfo(const std::string& file_name_in_zip,
                                 const unz_file_info& raw_file_info)
     : file_path_(base::FilePath::FromUTF8Unsafe(file_name_in_zip)),
       is_directory_(false) {
   original_size_ = raw_file_info.uncompressed_size;
 
   // Directory entries in zip files end with "/".
@@ skipping 27 matching lines @@
   exploded_time.second = raw_file_info.tmu_date.tm_sec;
   exploded_time.millisecond = 0;
   if (exploded_time.HasValidValues()) {
     last_modified_ = base::Time::FromLocalExploded(exploded_time);
   } else {
     // Use Unix time epoch if the time stamp data is invalid.
     last_modified_ = base::Time::UnixEpoch();
   }
 }
 
-ZipReader::ZipReader() {
+ZipReader::ZipReader()
+    : weak_factory_(this) {
   Reset();
 }
 
 ZipReader::~ZipReader() {
   Close();
 }
 
 bool ZipReader::Open(const base::FilePath& zip_file_path) {
   DCHECK(!zip_file_);
 
@@ skipping 145 matching lines @@
         success = false;
         break;
       }
     }
   }
 
   unzCloseCurrentFile(zip_file_);
   return success;
 }
 
+void ZipReader::ExtractCurrentEntryToFilePathAsync(
+    const base::FilePath& output_file_path,
+    scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+    scoped_refptr<Listener> listener) {
+  DCHECK(zip_file_);
+  DCHECK(current_entry_info_.get());
+
+  // If this is a directory, just create it and return.
+  if (current_entry_info()->is_directory()) {
+    if (file_util::CreateDirectory(output_file_path)) {
+      listener->OnUnzipSuccess();
+    } else {
+      DVLOG(1) << "Unzip failed: unable to create directory.";
+      listener->OnUnzipFailed();
+    }
+    return;
+  }
+
+  base::FilePath output_dir_path = output_file_path.DirName();
+  if (!file_util::CreateDirectory(output_dir_path)) {
+    DVLOG(1) << "Unzip failed: unable to create containing directory.";
+    listener->OnUnzipFailed();
+    return;
+  }
+
+  const int flags = (base::PLATFORM_FILE_CREATE_ALWAYS |
+                     base::PLATFORM_FILE_WRITE);
+  bool created = false;
+  base::PlatformFileError platform_file_error;
+  base::PlatformFile output_file = CreatePlatformFile(output_file_path,
+                                                      flags,
+                                                      &created,
+                                                      &platform_file_error);
+
+  if (platform_file_error != base::PLATFORM_FILE_OK) {
+    DVLOG(1) << "Unzip failed: unable to create platform file at "
+             << output_file_path.value();
+    listener->OnUnzipFailed();
+    return;
+  }
+
+  ExtractCurrentEntryToPlatformFileAsync(output_file,
+                                         message_loop_proxy,
+                                         new FileClosingListener(listener,
+                                                                 output_file));
+}
+
 bool ZipReader::ExtractCurrentEntryIntoDirectory(
     const base::FilePath& output_directory_path) {
   DCHECK(current_entry_info_.get());
 
   base::FilePath output_file_path = output_directory_path.Append(
       current_entry_info()->file_path());
   return ExtractCurrentEntryToFilePath(output_file_path);
 }
 
+void ZipReader::ExtractCurrentEntryIntoDirectoryAsync(
+    const base::FilePath& output_directory_path,
+    scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+    scoped_refptr<Listener> listener) {
+  DCHECK(current_entry_info_.get());
+
+  base::FilePath output_file_path = output_directory_path.Append(
+      current_entry_info()->file_path());
+  ExtractCurrentEntryToFilePathAsync(output_file_path,
+                                     message_loop_proxy,
+                                     listener);
+}
+
+void ZipReader::ExtractCurrentEntryToPlatformFileAsync(
+    base::PlatformFile output_file,
+    scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+    scoped_refptr<Listener> listener) {
+  DCHECK(zip_file_);
+  DCHECK(current_entry_info_.get());
+
+  if (current_entry_info()->is_directory()) {
+    DVLOG(1) << "Unzip failed: Cannot unzip a directory to an open file.";
+    listener->OnUnzipFailed();
+  }
+
+  if (unzOpenCurrentFile(zip_file_) != UNZ_OK) {
+    DVLOG(1) << "Unzip failed: unable to open current zip entry.";
+    listener->OnUnzipFailed();
+    return;
+  }
+
+  message_loop_proxy->PostTask(
+      FROM_HERE,
+      base::Bind(&ZipReader::ExtractChunk,
+                 weak_factory_.GetWeakPtr(),

[satorux1, 2013/12/05 04:39:37]

this is worrisome. WeakPtr only works if you are posting to the same thread. If
|message_loop_proxy| is associated with other thread, this will crash with a
DCHECK().

Instead of taking message_loop_proxy, I think this function should just use
MessageLoopProxy::current()

[Drew Haven, 2013/12/09 23:33:12]

I left the weakptr in, but I'm using the current message loop now.  That should
mean that the weak pointer is safe.  We do need some way to deal with what
happens if the zipreader gets deleted, e.g. on shutdown.

+                 output_file,
+                 message_loop_proxy,
+                 listener,
+                 0,
+                 current_entry_info()->original_size()));
+}
+
+
 #if defined(OS_POSIX)
 bool ZipReader::ExtractCurrentEntryToFd(const int fd) {
   DCHECK(zip_file_);
 
   // If this is a directory, there's nothing to extract to the file descriptor,
   // so return false.
   if (current_entry_info()->is_directory())
     return false;
 
   const int open_result = unzOpenCurrentFile(zip_file_);
@@ skipping 18 matching lines @@
           file_util::WriteFileDescriptor(fd, buf, num_bytes_read)) {
         success = false;
         break;
       }
     }
   }
 
   unzCloseCurrentFile(zip_file_);
   return success;
 }
+
+void ZipReader::ExtractCurrentEntryToFdAsync(
+    int fd,
+    scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+    scoped_refptr<Listener> listener) {
+  // A POSIX PlatformFile is just an int, so we can use the same internal
+  // functions.
+  ExtractCurrentEntryToPlatformFileAsync(fd, message_loop_proxy, listener);
+}
 #endif  // defined(OS_POSIX)
 
 bool ZipReader::OpenInternal() {
   DCHECK(zip_file_);
 
   unz_global_info zip_info = {};  // Zero-clear.
   if (unzGetGlobalInfo(zip_file_, &zip_info) != UNZ_OK) {
     return false;
   }
   num_entries_ = zip_info.number_entry;
   if (num_entries_ < 0)
     return false;
 
   // We are already at the end if the zip file is empty.
   reached_end_ = (num_entries_ == 0);
   return true;
 }
 
 void ZipReader::Reset() {
   zip_file_ = NULL;
   num_entries_ = 0;
   reached_end_ = false;
   current_entry_info_.reset();
 }
 
+void ZipReader::ExtractChunk(base::PlatformFile output_file,
+                             scoped_refptr<base::MessageLoopProxy> message_loop_proxy,

[Drew Haven, 2013/12/09 23:33:12]

Done.

+                             scoped_refptr<Listener> listener,
+                             int offset,
+                             int size) {
+  char buffer[internal::kZipBufSize];
+
+  const int num_bytes_read = unzReadCurrentFile(zip_file_,
+                                                buffer,
+                                                internal::kZipBufSize);
+
+  if (num_bytes_read == 0) {
+    unzCloseCurrentFile(zip_file_);
+    listener->OnUnzipSuccess();
+  } else if (num_bytes_read < 0) {
+    DVLOG(1) << "Unzip failed: error while reading zipfile "
+             << "(" << num_bytes_read << ")";
+    listener->OnUnzipFailed();
+  } else {
+    if (num_bytes_read != base::WritePlatformFileAtCurrentPos(output_file,
+                                                              buffer,
+                                                              num_bytes_read)) {
+      DVLOG(1) << "Unzip failed: unable to write all bytes to target.";
+      listener->OnUnzipFailed();
+      return;
+    }
+
+    const int prev_progress = offset / size;
+    const int curr_progress = (offset + num_bytes_read) / size;
+
+    if (curr_progress > prev_progress) {
+      listener->OnUnzipProgress(curr_progress);
+    }
+
+    message_loop_proxy->PostTask(
+        FROM_HERE,
+        base::Bind(&ZipReader::ExtractChunk,
+                   weak_factory_.GetWeakPtr(),
+                   output_file,
+                   message_loop_proxy,
+                   listener,
+                   offset + num_bytes_read,
+                   size));
+
+  }
+}
+
+
 }  // namespace zip