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/logging.h"
+#include "base/message_loop/message_loop.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)
@@ skipping 43 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_ptr_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,
+    SuccessCallback success_callback,
+    FailureCallback failure_callback,
+    ProgressCallback progress_callback) {
+  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 (base::CreateDirectory(output_file_path)) {
+      base::MessageLoopProxy::current()->PostTask(FROM_HERE, success_callback);
+    } else {
+      DVLOG(1) << "Unzip failed: unable to create directory.";
+      base::MessageLoopProxy::current()->PostTask(FROM_HERE, failure_callback);
+    }
+    return;
+  }
+
+  if (current_entry_info()->is_directory()) {
+    DVLOG(1) << "Unzip failed: Cannot unzip a directory to an open file.";
+    base::MessageLoopProxy::current()->PostTask(FROM_HERE, failure_callback);
+  }
+
+  if (unzOpenCurrentFile(zip_file_) != UNZ_OK) {
+    DVLOG(1) << "Unzip failed: unable to open current zip entry.";
+    base::MessageLoopProxy::current()->PostTask(FROM_HERE, failure_callback);
+    return;
+  }
+
+  base::FilePath output_dir_path = output_file_path.DirName();
+  if (!base::CreateDirectory(output_dir_path)) {
+    DVLOG(1) << "Unzip failed: unable to create containing directory.";
+    base::MessageLoopProxy::current()->PostTask(FROM_HERE, failure_callback);
+    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();
+    base::MessageLoopProxy::current()->PostTask(FROM_HERE, failure_callback);
+    return;
+  }
+
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE,
+      base::Bind(&ZipReader::ExtractChunk,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 output_file,
+                 success_callback,
+                 failure_callback,
+                 progress_callback,
+                 0 /* initial offset */));
+}
+
 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);
 }
 
 #if defined(OS_POSIX)
@@ skipping 52 matching lines @@
   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,
+                             SuccessCallback success_callback,
+                             FailureCallback failure_callback,
+                             ProgressCallback progress_callback,
+                             const int64 offset) {
+  char buffer[internal::kZipBufSize];
+
+  const int num_bytes_read = unzReadCurrentFile(zip_file_,
+                                                buffer,
+                                                internal::kZipBufSize);
+
+  if (num_bytes_read == 0) {
+    unzCloseCurrentFile(zip_file_);
+    base::ClosePlatformFile(output_file);
+    base::MessageLoopProxy::current()->PostTask(FROM_HERE, success_callback);

[satorux1, 2013/12/12 08:13:01]

ExtractChunk() was called asynchronously, so it's fine to run
success_callback.Run() here directly

[Drew Haven, 2013/12/12 22:06:17]

Oh, you're completely right. Done.  I didn't even change progress_callback
below, accidentally.

+  } else if (num_bytes_read < 0) {
+    DVLOG(1) << "Unzip failed: error while reading zipfile "
+             << "(" << num_bytes_read << ")";
+    base::ClosePlatformFile(output_file);
+    base::MessageLoopProxy::current()->PostTask(FROM_HERE, failure_callback);
+  } else {
+    if (num_bytes_read != base::WritePlatformFileAtCurrentPos(output_file,
+                                                              buffer,
+                                                              num_bytes_read)) {
+      DVLOG(1) << "Unzip failed: unable to write all bytes to target.";
+      base::ClosePlatformFile(output_file);
+      base::MessageLoopProxy::current()->PostTask(FROM_HERE, failure_callback);
+      return;
+    }
+
+    int64 curr_progress = offset + num_bytes_read;
+
+    progress_callback.Run(curr_progress);
+
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&ZipReader::ExtractChunk,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   output_file,
+                   success_callback,
+                   failure_callback,
+                   progress_callback,
+                   curr_progress));
+
+  }
+}
+
+
 }  // namespace zip