Adds asynchronous unzip functions to ZipReader

chrome/browser/extensions/api/image_writer_private/operation.cc

+//

[satorux1, 2013/12/13 07:55:09]

remove this

[Drew Haven, 2013/12/13 18:36:11]

Done.

 // Copyright 2013 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 "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/threading/worker_pool.h"
 #include "chrome/browser/extensions/api/image_writer_private/error_messages.h"
 #include "chrome/browser/extensions/api/image_writer_private/operation.h"
 #include "chrome/browser/extensions/api/image_writer_private/operation_manager.h"
 #include "content/public/browser/browser_thread.h"
-#include "third_party/zlib/google/zip.h"
 
 namespace extensions {
 namespace image_writer {
 
 using content::BrowserThread;
 
 namespace {
 
 const int kMD5BufferSize = 1024;
 
@@ skipping 148 matching lines @@
 void Operation::CleanUp() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   for (std::vector<base::Closure>::iterator it = cleanup_functions_.begin();
        it != cleanup_functions_.end();
        ++it) {
     it->Run();
   }
   cleanup_functions_.clear();
 }
 
-void Operation::UnzipStart(scoped_ptr<base::FilePath> zip_file) {
+void Operation::UnzipStart(scoped_ptr<base::FilePath> zip_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (IsCancelled()) {
     return;
   }
 
-  DVLOG(1) << "Starting unzip stage for " << zip_file->value();
+  DVLOG(1) << "Starting unzip stage for " << zip_path->value();
 
   SetStage(image_writer_api::STAGE_UNZIP);
 
   base::FilePath tmp_dir;
-  if (!base::CreateTemporaryDirInDir(zip_file->DirName(),
+  if (!base::CreateTemporaryDirInDir(zip_path->DirName(),
                                      FILE_PATH_LITERAL("image_writer"),
                                      &tmp_dir)) {
+    DLOG(ERROR) << "Failed to create temporary directory.";
     Error(error::kTempDir);
     return;
   }
 
   AddCleanUpFunction(base::Bind(&RemoveTempDirectory, tmp_dir));
 
-  if (!zip::Unzip(*zip_file, tmp_dir)) {
+  if (!base::CreateTemporaryFileInDir(tmp_dir, &image_path_)) {
+    DLOG(ERROR) << "Failed create temporary unzip target in "
+                << tmp_dir.value();
+    Error(error::kTempDir);
+    return;
+  }
+
+  if (!(zip_reader_.Open(*zip_path) &&
+        zip_reader_.AdvanceToNextEntry() &&
+        zip_reader_.OpenCurrentEntryInZip())) {
+    DLOG(ERROR) << "Failed to open zip file.";
     Error(error::kUnzip);
     return;
   }
 
-  base::FileEnumerator file_enumerator(tmp_dir,
-                                       false,
-                                       base::FileEnumerator::FILES);
-
-  scoped_ptr<base::FilePath> unzipped_file(
-      new base::FilePath(file_enumerator.Next()));
-
-  if (unzipped_file->empty()) {
-    Error(error::kEmptyUnzip);
-    return;
-  }
-
-  if (!file_enumerator.Next().empty()) {
-    Error(error::kMultiFileZip);
-    return;
-  }
-
-  DVLOG(1) << "Successfully unzipped as " << unzipped_file->value();
-
-  SetProgress(kProgressComplete);
-
-  image_path_ = *unzipped_file;
-
-  BrowserThread::PostTask(
-      BrowserThread::FILE,
-      FROM_HERE,
-      base::Bind(&Operation::WriteStart,
-                 this));
+  zip_reader_.ExtractCurrentEntryToFilePathAsync(
+      image_path_,
+      base::Bind(&Operation::OnUnzipSuccess, this),
+      base::Bind(&Operation::OnUnzipFailure, this),
+      base::Bind(&Operation::OnUnzipProgress,
+                 this,
+                 zip_reader_.current_entry_info()->original_size()));
 }
 
 void Operation::GetMD5SumOfFile(
     scoped_ptr<base::FilePath> file_path,
     int64 file_size,
     int progress_offset,
     int progress_scale,
     const base::Callback<void(scoped_ptr<std::string>)>& callback) {
   if (IsCancelled()) {
     return;
@@ skipping 75 matching lines @@
       scoped_ptr<std::string> hash(
           new std::string(base::MD5DigestToBase16(digest)));
       callback.Run(hash.Pass());
     }
   } else {  // len < 0
     reader->Close();
     Error(error::kReadImage);
   }
 }
 
+void Operation::OnUnzipSuccess() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  SetProgress(kProgressComplete);
+
+  if (zip_reader_.HasMore()) {
+    Error(error::kMultiFileZip);
+  } else {
+    WriteStart();
+  }
+}
+
+void Operation::OnUnzipFailure() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  Error(error::kUnzip);
+}
+
+void Operation::OnUnzipProgress(int64 total_bytes, int64 progress_bytes) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+
+  int progress_percent = 100 * progress_bytes / total_bytes;
+  SetProgress(progress_percent);
+}
+
 }  // namespace image_writer
 }  // namespace extensions