Adds asynchronous unzip functions to ZipReader

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

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_API_IMAGE_WRITER_PRIVATE_OPERATION_H_
 #define CHROME_BROWSER_EXTENSIONS_API_IMAGE_WRITER_PRIVATE_OPERATION_H_
 
 #include "base/callback.h"
 #include "base/md5.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/weak_ptr.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/extensions/api/image_writer_private/image_writer_utils.h"
 #include "chrome/common/cancelable_task_tracker.h"
 #include "chrome/common/extensions/api/image_writer_private.h"
+#include "third_party/zlib/google/zip_reader.h"
 
 namespace image_writer_api = extensions::api::image_writer_private;
 
 namespace base {
 class FilePath;
 }  // namespace base
 
 namespace extensions {
 namespace image_writer {
 
 const int kProgressComplete = 100;
 
 class OperationManager;
 
 // Encapsulates an operation being run on behalf of the
 // OperationManager.  Construction of the operation does not start
 // anything.  The operation's Start method should be called to start it, and
 // then the Cancel method will stop it.  The operation will call back to the
 // OperationManager periodically or on any significant event.
 //
 // Each stage of the operation is generally divided into three phases: Start,
 // Run, Complete.  Start and Complete run on the UI thread and are responsible
 // for advancing to the next stage and other UI interaction.  The Run phase does
 // the work on the FILE thread and calls SendProgress or Error as appropriate.
 class Operation
-    : public base::RefCountedThreadSafe<Operation> {
+    : public zip::ZipReader::Listener {
  public:
   typedef base::Callback<void(bool, const std::string&)> StartWriteCallback;
   typedef base::Callback<void(bool, const std::string&)> CancelWriteCallback;
   typedef std::string ExtensionId;
 
   Operation(base::WeakPtr<OperationManager> manager,
             const ExtensionId& extension_id,
             const std::string& storage_unit_id);
 
   // Starts the operation.
@@ skipping 74 matching lines @@
 
   void OnBurnFinished(const std::string& target_path,
                       bool success,
                       const std::string& error);
   void OnBurnProgress(const std::string& target_path,
                       int64 num_bytes_burnt,
                       int64 total_size);
   void OnBurnError();
 #endif
 
+  // Incrementally calculates the MD5 sum of a file.
   void MD5Chunk(scoped_ptr<image_writer_utils::ImageReader> reader,
                 int64 bytes_processed,
                 int64 bytes_total,
                 int progress_offset,
                 int progress_scale,
                 const base::Callback<void(scoped_ptr<std::string>)>& callback);
 
+  // Implementation of zip::ZipReader::Listener
+  virtual void OnUnzipProgress(int progress) OVERRIDE;
+  virtual void OnUnzipSuccess() OVERRIDE;
+  virtual void OnUnzipFailed() OVERRIDE;
+
   // Runs all cleanup functions.
   void CleanUp();
 
   // |stage_| and |progress_| are owned by the FILE thread, use |SetStage| and
   // |SetProgress| to update.  Progress should be in the interval [0,100]
   image_writer_api::Stage stage_;
   int progress_;
 
   // MD5 contexts don't play well with smart pointers.  Just going to allocate
   // memory here.  This requires that we only do one MD5 sum at a time.
   base::MD5Context md5_context_;
 
+  // Zip reader for unzip operations.
+  zip::ZipReader zip_reader_;
+
   // CleanUp operations that must be run.  All these functions are run on the
   // FILE thread.
   std::vector<base::Closure> cleanup_functions_;
 };
 
 }  // namespace image_writer
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_IMAGE_WRITER_PRIVATE_OPERATION_H_