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 18 matching lines @@
                      const ExtensionId& extension_id,
                      const std::string& storage_unit_id)
     : manager_(manager),
       extension_id_(extension_id),
       storage_unit_id_(storage_unit_id),
       verify_write_(true),
       stage_(image_writer_api::STAGE_UNKNOWN),
       progress_(0) {
 }
 
-Operation::~Operation() {
-}
+Operation::~Operation() {}
 
 void Operation::Cancel() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
-  DVLOG(1) << "Cancelling image writing operation for ext: " << extension_id_;
-
   stage_ = image_writer_api::STAGE_NONE;
 
   CleanUp();
 }
 
 void Operation::Abort() {
   Error(error::kAborted);
 }
 
 int Operation::GetProgress() {
@@ skipping 33 matching lines @@
         base::Bind(&Operation::SetProgress,
                    this,
                    progress));
     return;
   }
 
   if (IsCancelled()) {
     return;
   }
 
-  progress_ = progress;
+  if (progress > progress_) {
+    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 17 matching lines @@
                  progress_));
 }
 
 void Operation::Finish() {
   if (!BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
     BrowserThread::PostTask(BrowserThread::FILE,
                             FROM_HERE,
                             base::Bind(&Operation::Finish, this));
     return;
   }
-  DVLOG(1) << "Write operation complete.";
 
   CleanUp();
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&OperationManager::OnComplete,
                  manager_,
                  extension_id_));
 }
@@ skipping 13 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::StartImageWriterClient() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  if (!image_writer_client_) {
+    image_writer_client_ = new ImageWriterClient();
+
+    AddCleanUpFunction(base::Bind(&Operation::StopImageWriterClient, this));
+  }
+}
+
+void Operation::StopImageWriterClient() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&ImageWriterClient::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;

[Lei Zhang, 2014/02/15 00:26:59]

Can this overflow? Same with line 338.

[Drew Haven, 2014/02/15 01:23:58]

My understanding is that kProgressComplete * curr_bytes will be in64.  Since
kProgressComplete is 100 this shouldn't overflow for any file size we'd
realistically encounter.  Then we divide by the total_bytes, with curr_bytes <
total_bytes (though maybe that should be asserted in some way) and so the result
should always been in [0,100].

[Lei Zhang, 2014/02/15 01:41:50]

Do you trust the utility process to send you a valid |curr_bytes| ? If yes, then
ok. For some utility processes, such as parsers, we certainly don't trust them
because the parser code may have bugs. In this case,  I think you are separating
the code into the utility mostly for privilege escalation, so otherwise this
would be browser code that you' d trust.

[Jorge Lucangeli Obes, 2014/02/15 01:43:19]

I would add CHECKS for both values to be positive, and curr_bytes < total_bytes.

+
+  if (progress > GetProgress()) {
+    SetProgress(progress);
+  }
+}
+
 void Operation::UnzipStart(scoped_ptr<base::FilePath> zip_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (IsCancelled()) {
     return;
   }
 
-  DVLOG(1) << "Starting unzip stage for " << zip_path->value();
-
   SetStage(image_writer_api::STAGE_UNZIP);
 
   base::FilePath tmp_dir;
   if (!base::CreateTemporaryDirInDir(zip_path->DirName(),
                                      FILE_PATH_LITERAL("image_writer"),
                                      &tmp_dir)) {
     Error(error::kTempDirError);
     return;
   }
 
@@ skipping 129 matching lines @@
 }
 
 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);
 }
 
 }  // namespace image_writer
 }  // namespace extensions