Revert of Significantly cleans up the ImageWriter Operation class and subclasses.

chrome/browser/extensions/api/image_writer_private/operation_chromeos.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 "chrome/browser/extensions/api/image_writer_private/error_messages.h"
 #include "chrome/browser/extensions/api/image_writer_private/operation.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/image_burner_client.h"
 #include "content/public/browser/browser_thread.h"
 
@@ skipping 13 matching lines @@
     return;
   }
 
   chromeos::DBusThreadManager::Get()->
       GetImageBurnerClient()->
       ResetEventHandlers();
 }
 
 }  // namespace
 
-void Operation::Write(const base::Closure& continuation) {
+void Operation::WriteStart() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   SetStage(image_writer_api::STAGE_WRITE);
 
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&Operation::StartWriteOnUIThread, this, continuation));
+  BrowserThread::PostTask(BrowserThread::UI,
+                          FROM_HERE,
+                          base::Bind(&Operation::StartWriteOnUIThread, this));
 
   AddCleanUpFunction(base::Bind(&ClearImageBurner));
 }
 
-void Operation::VerifyWrite(const base::Closure& continuation) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-
-  // No verification is available in Chrome OS currently.
-  continuation.Run();
-}
-
-void Operation::StartWriteOnUIThread(const base::Closure& continuation) {
+void Operation::StartWriteOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DVLOG(1) << "Starting burn.";
 
   ImageBurnerClient* burner =
       chromeos::DBusThreadManager::Get()->GetImageBurnerClient();
 
   burner->SetEventHandlers(
-      base::Bind(&Operation::OnBurnFinished, this, continuation),
+      base::Bind(&Operation::OnBurnFinished, this),
       base::Bind(&Operation::OnBurnProgress, this));
 
   burner->BurnImage(image_path_.value(),
-                    device_path_.value(),
+                    storage_unit_id_,
                     base::Bind(&Operation::OnBurnError, this));
 }
 
-void Operation::OnBurnFinished(const base::Closure& continuation,
-                               const std::string& target_path,
-                               bool success,
-                               const std::string& error) {
+void Operation::OnBurnFinished(const std::string& target_path,
+                    bool success,
+                    const std::string& error) {
+  DVLOG(1) << "Burn finished: " << success;
+
   if (success) {
     SetProgress(kProgressComplete);
-    BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, continuation);
+    Finish();
   } else {
-    DLOG(ERROR) << "Error encountered while burning: " << error;
-    Error(error::kChromeOSImageBurnerError);
+    Error(error);
   }
 }
 
 void Operation::OnBurnProgress(const std::string& target_path,
-                               int64 num_bytes_burnt,
-                               int64 total_size) {
+                    int64 num_bytes_burnt,
+                    int64 total_size) {
   int progress = kProgressComplete * num_bytes_burnt / total_size;
   SetProgress(progress);
 }
 
 void Operation::OnBurnError() {
   Error(error::kChromeOSImageBurnerError);
 }
 
 }  // namespace image_writer
 }  // namespace extensions