Adds imageWriterPrivate support for Windows

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/files/scoped_temp_dir.h"
 #include "base/md5.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/weak_ptr.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/timer/timer.h"
+#include "chrome/browser/extensions/api/image_writer_private/image_writer_utility_client.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 {
@@ skipping 38 matching lines @@
   // all callbacks have completed.
   void Cancel();
 
   // Aborts the operation, cancelling it and generating an error.
   void Abort();
 
   // Informational getters.
   int GetProgress();
   image_writer_api::Stage GetStage();
 
+#if !defined(OS_CHROMEOS)
+  // Set an ImageWriterClient to use.  Should be called only when testing.
+  void SetUtilityClientForTesting(
+      scoped_refptr<ImageWriterUtilityClient> client);
+#endif
+
  protected:
   virtual ~Operation();
 
   // This function should be overriden by subclasses to set up the work of the
   // operation.  It will be called from Start().
   virtual void StartImpl() = 0;
 
   // Unzips the current file if it ends in ".zip".  The current_file will be set
   // to the unzipped file.
   void Unzip(const base::Closure& continuation);
@@ skipping 20 matching lines @@
   void SetStage(image_writer_api::Stage stage);
 
   // Can be queried to safely determine if the operation has been cancelled.
   bool IsCancelled();
 
   // Adds a callback that will be called during clean-up, whether the operation
   // is aborted, encounters and error, or finishes successfully.  These
   // functions will be run on the FILE thread.
   void AddCleanUpFunction(const base::Closure& callback);
 
+  // Completes the current operation (progress set to 100) and runs the
+  // continuation.
+  void CompleteAndContinue(const base::Closure& continuation);
+
   // If |file_size| is non-zero, only |file_size| bytes will be read from file,
   // otherwise the entire file will be read.
   // |progress_scale| is a percentage to which the progress will be scale, e.g.
   // a scale of 50 means it will increment from 0 to 50 over the course of the
   // sum.  |progress_offset| is an percentage that will be added to the progress
   // of the MD5 sum before updating |progress_| but after scaling.
   void GetMD5SumOfFile(
       const base::FilePath& file,
       int64 file_size,
       int progress_offset,
       int progress_scale,
       const base::Callback<void(const std::string&)>& callback);
 
   base::WeakPtr<OperationManager> manager_;
   const ExtensionId extension_id_;
 
   base::FilePath image_path_;
   base::FilePath device_path_;
 
   // Temporary directory to store files as we go.
   base::ScopedTempDir temp_dir_;
 
  private:
   friend class base::RefCountedThreadSafe<Operation>;
 
-  // TODO(haven): Clean up these switches. http://crbug.com/292956
-#if defined(OS_LINUX) && !defined(CHROMEOS)
-  void WriteChunk(const int64& bytes_written,
-                  const int64& total_size,
-                  const base::Closure& continuation);
-  void WriteComplete(const base::Closure& continuation);
+#if !defined(OS_CHROMEOS)
+  // Ensures the client is started.  This may be called many times but will only
+  // instantiate one client which should exist for the lifetime of the
+  // Operation.
+  void StartUtilityClient();
 
-  void VerifyWriteChunk(const int64& bytes_written,
-                        const int64& total_size,
-                        const base::Closure& continuation);
-  void VerifyWriteComplete(const base::Closure& continuation);
+  // Stops the client.  This must be called to ensure the utility process can
+  // shutdown.
+  void StopUtilityClient();
 
-  base::PlatformFile image_file_;
-  base::PlatformFile device_file_;
+  // Reports progress from the client, transforming from bytes to percentage.
+  virtual void WriteImageProgress(int64 total_bytes, int64 curr_bytes);
+
+  scoped_refptr<ImageWriterUtilityClient> image_writer_client_;
 #endif
 
 #if defined(OS_CHROMEOS)
   void StartWriteOnUIThread(const base::Closure& continuation);
 
   void OnBurnFinished(const base::Closure& continuation,
                       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(const base::PlatformFile& file,
                 int64 bytes_processed,
                 int64 bytes_total,
                 int progress_offset,
                 int progress_scale,
                 const base::Callback<void(const std::string&)>& callback);
 
   // Callbacks for zip::ZipReader.
-  void OnUnzipSuccess(const base::Closure& continuation);
   void OnUnzipFailure();
   void OnUnzipProgress(int64 total_bytes, int64 progress_bytes);
 
   // 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_