Adds imageWriterPrivate support for Windows

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

 // 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"
@@ skipping 15 matching lines @@
 Operation::Operation(base::WeakPtr<OperationManager> manager,
                      const ExtensionId& extension_id,
                      const std::string& device_path)
     : manager_(manager),
       extension_id_(extension_id),
 #if defined(OS_WIN)
       device_path_(base::FilePath::FromUTF8Unsafe(device_path)),
 #else
       device_path_(device_path),
 #endif
-#if defined(OS_LINUX) && !defined(CHROMEOS)
-      image_file_(base::kInvalidPlatformFileValue),
-      device_file_(base::kInvalidPlatformFileValue),
-#endif
       stage_(image_writer_api::STAGE_UNKNOWN),
       progress_(0) {
 }
 
 Operation::~Operation() {}
 
 void Operation::Cancel() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   stage_ = image_writer_api::STAGE_NONE;
 
   CleanUp();
 }
 
 void Operation::Abort() {
   Error(error::kAborted);
 }
 
 int Operation::GetProgress() {
   return progress_;
 }
 
 image_writer_api::Stage Operation::GetStage() {
   return stage_;
 }
 
+#if !defined(OS_CHROMEOS)
+void Operation::SetUtilityClientForTesting(
+    scoped_refptr<ImageWriterUtilityClient> client) {
+  image_writer_client_ = client;
+}
+#endif
+
 void Operation::Start() {
 #if defined(OS_CHROMEOS)
   if (!temp_dir_.CreateUniqueTempDirUnderPath(
            base::FilePath(kChromeOSTempRoot))) {
 #else
   if (!temp_dir_.CreateUniqueTempDir()) {
 #endif
     Error(error::kTempDirError);
     return;
   }
@@ skipping 34 matching lines @@
   zip::ZipReader::EntryInfo* entry_info = zip_reader_.current_entry_info();
   if (entry_info) {
     image_path_ = temp_dir_.path().Append(entry_info->file_path().BaseName());
   } else {
     Error(error::kTempDirError);
     return;
   }
 
   zip_reader_.ExtractCurrentEntryToFilePathAsync(
       image_path_,
-      base::Bind(&Operation::OnUnzipSuccess, this, continuation),
+      base::Bind(&Operation::CompleteAndContinue, this, continuation),
       base::Bind(&Operation::OnUnzipFailure, this),
       base::Bind(&Operation::OnUnzipProgress,
                  this,
                  zip_reader_.current_entry_info()->original_size()));
 }
 
 void Operation::Finish() {
   if (!BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE, base::Bind(&Operation::Finish, this));
@@ skipping 43 matching lines @@
   if (progress <= progress_) {
     return;
   }
 
   if (IsCancelled()) {
     return;
   }
 
   progress_ = progress;
 
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&OperationManager::OnProgress,
-                 manager_,
-                 extension_id_,
-                 stage_,
-                 progress_));
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&OperationManager::OnProgress,
+                                     manager_,
+                                     extension_id_,
+                                     stage_,
+                                     progress_));
 }
 
 void Operation::SetStage(image_writer_api::Stage stage) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(&Operation::SetStage,
                    this,
                    stage));
@@ skipping 21 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   return stage_ == image_writer_api::STAGE_NONE;
 }
 
 void Operation::AddCleanUpFunction(const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   cleanup_functions_.push_back(callback);
 }
 
+void Operation::CompleteAndContinue(const base::Closure& continuation) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  SetProgress(kProgressComplete);
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, continuation);
+}
+
+#if !defined(OS_CHROMEOS)
+void Operation::StartUtilityClient() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  if (!image_writer_client_) {
+    image_writer_client_ = new ImageWriterUtilityClient();
+    AddCleanUpFunction(base::Bind(&Operation::StopUtilityClient, this));
+  }
+}
+
+void Operation::StopUtilityClient() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&ImageWriterUtilityClient::Shutdown, image_writer_client_));
+}
+
+void Operation::WriteImageProgress(int64 total_bytes, int64 curr_bytes) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  if (IsCancelled()) {
+    return;
+  }
+
+  int progress = kProgressComplete * curr_bytes / total_bytes;
+
+  if (progress > GetProgress()) {
+    SetProgress(progress);
+  }
+}
+#endif
+
 void Operation::GetMD5SumOfFile(
     const base::FilePath& file_path,
     int64 file_size,
     int progress_offset,
     int progress_scale,
     const base::Callback<void(const std::string&)>& callback) {
   if (IsCancelled()) {
     return;
   }
 
@@ skipping 76 matching lines @@
       // Skip closing the file.
       return;
     } else {
       // We didn't read the bytes we expected.
       Error(error::kHashReadError);
     }
   }
   base::ClosePlatformFile(file);
 }
 
-void Operation::OnUnzipSuccess(const base::Closure& continuation) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  SetProgress(kProgressComplete);
-  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, continuation);
-}
-
 void Operation::OnUnzipFailure() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   Error(error::kUnzipGenericError);
 }
 
 void Operation::OnUnzipProgress(int64 total_bytes, int64 progress_bytes) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
-  int progress_percent = 100 * progress_bytes / total_bytes;
+  int progress_percent = kProgressComplete * progress_bytes / total_bytes;
   SetProgress(progress_percent);
 }
 
 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();
 }
 
 }  // namespace image_writer
 }  // namespace extensions