Split non UI part of browser/ui/webui/imageburner/imageburner_ui.cc as burn_controller.cc

BUG=chromium-os:16553
TEST=chrome://imageburner works

Review URL: https://chromiumcodereview.appspot.com/9235028

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@119651 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 710 insertions, 525 deletions

diff --git a/chrome/browser/chromeos/imageburner/burn_controller.cc b/chrome/browser/chromeos/imageburner/burn_controller.cc
new file mode 100644
index 0000000..58388a4
--- /dev/null
+++ b/chrome/browser/chromeos/imageburner/burn_controller.cc
@@ -0,0 +1,535 @@
+// Copyright (c) 2012 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/chromeos/imageburner/burn_controller.h"
+
+#include "base/bind.h"
+#include "base/file_path.h"
+#include "base/memory/weak_ptr.h"
+#include "chrome/browser/chromeos/cros/burn_library.h"
+#include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chromeos/cros/network_library.h"
+#include "chrome/browser/chromeos/imageburner/burn_manager.h"
+#include "chrome/browser/chromeos/system/statistics_provider.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/download_item.h"
+#include "content/public/browser/download_manager.h"
+#include "content/public/browser/web_contents.h"
+#include "grit/generated_resources.h"
+#include "googleurl/src/gurl.h"
+
+using content::BrowserThread;
+using content::DownloadItem;
+
+namespace chromeos {
+namespace imageburner {
+
+namespace {
+
+// Name for hwid in machine statistics.
+const char kHwidStatistic[] = "hardware_class";
+
+const char kImageZipFileName[] = "chromeos_image.bin.zip";
+
+// 3.9GB. It is less than 4GB because true device size ussually varies a little.
+const uint64 kMinDeviceSize = static_cast<uint64>(3.9 * 1000 * 1000 * 1000);
+
+// Returns true when |disk| is a device on which we can burn recovery image.
+bool IsBurnableDevice(const disks::DiskMountManager::Disk& disk) {
+  return disk.is_parent() && !disk.on_boot_device();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// BurnControllerTaskProxy
+//
+////////////////////////////////////////////////////////////////////////////////
+
+class BurnControllerTaskProxy
+    : public base::RefCountedThreadSafe<BurnControllerTaskProxy> {
+ public:
+  class Delegate : public base::SupportsWeakPtr<Delegate> {
+   public:
+    virtual void CreateImageDirOnFileThread() = 0;
+    virtual void ImageDirCreatedOnUIThread(bool success) = 0;
+  };
+
+  explicit BurnControllerTaskProxy(Delegate* delegate) {
+    delegate_ = delegate->AsWeakPtr();
+    delegate_->DetachFromThread();
+  }
+
+  void CreateImageDir() {
+    if (delegate_)
+      delegate_->CreateImageDirOnFileThread();
+  }
+
+  void OnImageDirCreated(bool success) {
+    if (delegate_)
+      delegate_->ImageDirCreatedOnUIThread(success);
+  }
+
+ private:
+  base::WeakPtr<Delegate> delegate_;
+
+  friend class base::RefCountedThreadSafe<BurnControllerTaskProxy>;
+  ~BurnControllerTaskProxy() {
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(BurnControllerTaskProxy);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// BurnController
+//
+////////////////////////////////////////////////////////////////////////////////
+
+class BurnControllerImpl
+    : public BurnController,
+      public disks::DiskMountManager::Observer,
+      public BurnLibrary::Observer,
+      public NetworkLibrary::NetworkManagerObserver,
+      public DownloadItem::Observer,
+      public content::DownloadManager::Observer,
+      public Downloader::Listener,
+      public StateMachine::Observer,
+      public BurnControllerTaskProxy::Delegate,
+      public BurnManager::Delegate {
+ public:
+  explicit BurnControllerImpl(content::WebContents* contents,
+                              BurnController::Delegate* delegate)
+      : web_contents_(contents),
+        download_manager_(NULL),
+        active_download_item_(NULL),
+        burn_manager_(NULL),
+        state_machine_(NULL),
+        observing_burn_lib_(false),
+        working_(false),
+        delegate_(delegate) {
+    disks::DiskMountManager::GetInstance()->AddObserver(this);
+    CrosLibrary::Get()->GetNetworkLibrary()->AddNetworkManagerObserver(this);
+    burn_manager_ = BurnManager::GetInstance();
+    state_machine_ = burn_manager_->state_machine();
+    state_machine_->AddObserver(this);
+  }
+
+  virtual ~BurnControllerImpl() {
+    disks::DiskMountManager::GetInstance()->RemoveObserver(this);
+    CrosLibrary::Get()->GetBurnLibrary()->RemoveObserver(this);
+    CrosLibrary::Get()->GetNetworkLibrary()->RemoveNetworkManagerObserver(this);
+    CleanupDownloadObjects();
+    if (state_machine_)
+      state_machine_->RemoveObserver(this);
+  }
+
+  // disks::DiskMountManager::Observer interface.
+  virtual void DiskChanged(disks::DiskMountManagerEventType event,
+                           const disks::DiskMountManager::Disk* disk)
+      OVERRIDE {
+    if (!IsBurnableDevice(*disk))
+      return;
+    if (event == disks::MOUNT_DISK_ADDED) {
+      delegate_->OnDeviceAdded(*disk);
+    } else if (event == disks::MOUNT_DISK_REMOVED) {
+      delegate_->OnDeviceRemoved(*disk);
+      if (burn_manager_->target_device_path().value() == disk->device_path())
+        ProcessError(IDS_IMAGEBURN_DEVICE_NOT_FOUND_ERROR);
+    }
+  }
+
+  virtual void DeviceChanged(disks::DiskMountManagerEventType event,
+                             const std::string& device_path) OVERRIDE {
+  }
+
+  virtual void MountCompleted(
+      disks::DiskMountManager::MountEvent event_type,
+      MountError error_code,
+      const disks::DiskMountManager::MountPointInfo& mount_info)
+      OVERRIDE {
+  }
+
+  // BurnLibrary::Observer interface.
+  virtual void BurnProgressUpdated(BurnLibrary* object,
+                                   BurnEvent evt,
+                                   const ImageBurnStatus& status) OVERRIDE {
+    switch (evt) {
+      case(BURN_SUCCESS):
+        FinalizeBurn();
+        break;
+      case(BURN_FAIL):
+        ProcessError(IDS_IMAGEBURN_BURN_ERROR);
+        break;
+      case(BURN_UPDATE):
+        delegate_->OnProgress(BURNING, status.amount_burnt, status.total_size);
+        break;
+      case(UNZIP_STARTED):
+        delegate_->OnProgress(UNZIPPING, 0, 0);
+        break;
+      case(UNZIP_FAIL):
+        ProcessError(IDS_IMAGEBURN_EXTRACTING_ERROR);
+        break;
+      case(UNZIP_COMPLETE):
+        // We ignore this.
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
+  }
+
+  // NetworkLibrary::NetworkManagerObserver interface.
+  virtual void OnNetworkManagerChanged(NetworkLibrary* obj) OVERRIDE {
+    if (state_machine_->state() == StateMachine::INITIAL && CheckNetwork())
+      delegate_->OnNetworkDetected();
+
+    if (state_machine_->state() == StateMachine::DOWNLOADING &&
+        !CheckNetwork())
+      ProcessError(IDS_IMAGEBURN_NETWORK_ERROR);
+  }
+
+  // DownloadItem::Observer interface.
+  virtual void OnDownloadUpdated(DownloadItem* download) OVERRIDE {
+    if (download->IsCancelled()) {
+      DownloadCompleted(false);
+      DCHECK(!active_download_item_);
+    } else if (download->IsComplete()) {
+      burn_manager_->set_final_zip_file_path(download->GetFullPath());
+      DownloadCompleted(true);
+      DCHECK(!active_download_item_);
+    } else if (download->IsPartialDownload() &&
+               state_machine_->state() == StateMachine::DOWNLOADING) {
+      base::TimeDelta remaining_time;
+      download->TimeRemaining(&remaining_time);
+      delegate_->OnProgressWithRemainingTime(
+          DOWNLOADING, download->GetReceivedBytes(), download->GetTotalBytes(),
+          remaining_time);
+    }
+  }
+
+  virtual void OnDownloadOpened(DownloadItem* download) OVERRIDE {
+    if (download->GetSafetyState() == DownloadItem::DANGEROUS)
+      download->DangerousDownloadValidated();
+  }
+
+  // DownloadManager::Observer interface.
+  virtual void ModelChanged() OVERRIDE {
+    // Find our item and observe it.
+    std::vector<DownloadItem*> downloads;
+    download_manager_->GetTemporaryDownloads(
+        burn_manager_->GetImageDir(), &downloads);
+    if (active_download_item_)
+      return;
+    for (std::vector<DownloadItem*>::const_iterator it = downloads.begin();
+         it != downloads.end();
+         ++it) {
+      if ((*it)->GetOriginalUrl() == image_download_url_) {
+        (*it)->AddObserver(this);
+        active_download_item_ = *it;
+        break;
+      }
+    }
+  }
+
+  // Downloader::Listener interface.
+  virtual void OnBurnDownloadStarted(bool success) OVERRIDE {
+    if (success)
+      state_machine_->OnDownloadStarted();
+    else
+      DownloadCompleted(false);
+  }
+
+  // StateMachine::Observer interface.
+  virtual void OnBurnStateChanged(StateMachine::State state) OVERRIDE {
+    if (state == StateMachine::CANCELLED) {
+      ProcessError(IDS_IMAGEBURN_USER_ERROR);
+    } else if (state != StateMachine::INITIAL && !working_) {
+      // User has started burn process, so let's start observing.
+      StartBurnImage(FilePath(), FilePath());
+    }
+  }
+
+  virtual void OnError(int error_message_id) OVERRIDE {
+    delegate_->OnFail(error_message_id);
+    working_ = false;
+  }
+
+  // Part of BurnControllerTaskProxy::Delegate interface.
+  virtual void CreateImageDirOnFileThread() OVERRIDE {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+    burn_manager_->CreateImageDir(this);
+  }
+
+  // Part of BurnManager::Delegate interface.
+  virtual void OnImageDirCreated(bool success) OVERRIDE {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+    // Transfer to UI thread.
+    scoped_refptr<BurnControllerTaskProxy> task(
+        new BurnControllerTaskProxy(this));
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&BurnControllerTaskProxy::OnImageDirCreated,
+                   task.get(), success));
+  }
+
+  // Part of BurnControllerTaskProxy::Delegate interface.
+  virtual void ImageDirCreatedOnUIThread(bool success) OVERRIDE {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    if (success) {
+      zip_image_file_path_ =
+          burn_manager_->GetImageDir().Append(kImageZipFileName);
+      burn_manager_->FetchConfigFile(web_contents_, this);
+    } else {
+      DownloadCompleted(success);
+    }
+  }
+
+  // Part of BurnManager::Delegate interface.
+  virtual void OnConfigFileFetched(const ConfigFile& config_file, bool success)
+      OVERRIDE {
+    if (!success || !ExtractInfoFromConfigFile(config_file)) {
+      DownloadCompleted(false);
+      return;
+    }
+
+    if (state_machine_->download_finished()) {
+      BurnImage();
+      return;
+    }
+
+    if (!download_manager_) {
+      download_manager_ =
+          web_contents_->GetBrowserContext()->GetDownloadManager();
+      download_manager_->AddObserver(this);
+    }
+    if (!state_machine_->download_started()) {
+      burn_manager_->downloader()->AddListener(this, image_download_url_);
+      if (!state_machine_->image_download_requested()) {
+        state_machine_->OnImageDownloadRequested();
+        burn_manager_->downloader()->DownloadFile(image_download_url_,
+                                                  zip_image_file_path_,
+                                                  web_contents_);
+      }
+    }
+  }
+
+  // BurnController override.
+  virtual void Init() OVERRIDE {
+    if (state_machine_->state() == StateMachine::BURNING) {
+      // There is nothing else left to do but observe burn progress.
+      BurnImage();
+    } else if (state_machine_->state() != StateMachine::INITIAL) {
+      // User has started burn process, so let's start observing.
+      StartBurnImage(FilePath(), FilePath());
+    }
+  }
+
+  // BurnController override.
+  virtual std::vector<disks::DiskMountManager::Disk> GetBurnableDevices()
+      OVERRIDE {
+    const disks::DiskMountManager::DiskMap& disks =
+        disks::DiskMountManager::GetInstance()->disks();
+    std::vector<disks::DiskMountManager::Disk> result;
+    for (disks::DiskMountManager::DiskMap::const_iterator iter = disks.begin();
+         iter != disks.end();
+         ++iter) {
+      const disks::DiskMountManager::Disk& disk = *iter->second;
+      if (IsBurnableDevice(disk))
+        result.push_back(disk);
+    }
+    return result;
+  }
+
+  // BurnController override.
+  virtual void CancelBurnImage() OVERRIDE {
+    state_machine_->OnCancelation();
+  }
+
+  // BurnController override.
+  // May be called with empty values if there is a handler that has started
+  // burning, and thus set the target paths.
+  virtual void StartBurnImage(const FilePath& target_device_path,
+                              const FilePath& target_file_path) OVERRIDE {
+    if (!target_device_path.empty() && !target_file_path.empty() &&
+        state_machine_->new_burn_posible()) {
+      if (!CheckNetwork()) {
+        delegate_->OnNoNetwork();
+        return;
+      }
+      burn_manager_->set_target_device_path(target_device_path);
+      burn_manager_->set_target_file_path(target_file_path);
+      uint64 device_size = GetDeviceSize(
+          burn_manager_->target_device_path().value());
+      if (device_size < kMinDeviceSize) {
+        delegate_->OnDeviceTooSmall(device_size);
+        return;
+      }
+    }
+    if (working_)
+      return;
+    working_ = true;
+    // Send progress signal now so ui doesn't hang in intial state until we get
+    // config file
+    delegate_->OnProgress(DOWNLOADING, 0, 0);
+    if (burn_manager_->GetImageDir().empty()) {
+      // Create image dir on File thread.
+      scoped_refptr<BurnControllerTaskProxy> task =
+          new BurnControllerTaskProxy(this);
+      BrowserThread::PostTask(
+          BrowserThread::FILE, FROM_HERE,
+          base::Bind(&BurnControllerTaskProxy::CreateImageDir, task.get()));
+    } else {
+      ImageDirCreatedOnUIThread(true);
+    }
+  }
+
+ private:
+  void DownloadCompleted(bool success) {
+    CleanupDownloadObjects();
+    if (success) {
+      state_machine_->OnDownloadFinished();
+      BurnImage();
+    } else {
+      ProcessError(IDS_IMAGEBURN_DOWNLOAD_ERROR);
+    }
+  }
+
+  void BurnImage() {
+    if (!observing_burn_lib_) {
+      CrosLibrary::Get()->GetBurnLibrary()->AddObserver(this);
+      observing_burn_lib_ = true;
+    }
+    if (state_machine_->state() == StateMachine::BURNING)
+      return;
+    state_machine_->OnBurnStarted();
+
+    CrosLibrary::Get()->GetBurnLibrary()->DoBurn(
+        zip_image_file_path_,
+        image_file_name_, burn_manager_->target_file_path(),
+        burn_manager_->target_device_path());
+  }
+
+  void FinalizeBurn() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    state_machine_->OnSuccess();
+    burn_manager_->ResetTargetPaths();
+    CrosLibrary::Get()->GetBurnLibrary()->RemoveObserver(this);
+    observing_burn_lib_ = false;
+    delegate_->OnSuccess();
+    working_ = false;
+  }
+
+  // Error is ussually detected by all existing Burn handlers, but only first
+  // one that calls ProcessError should actually process it.
+  void ProcessError(int message_id) {
+    // If we are in intial state, error has already been dispached.
+    if (state_machine_->state() == StateMachine::INITIAL) {
+      // We don't need burn library since we are not the ones doing the cleanup.
+      if (observing_burn_lib_) {
+        CrosLibrary::Get()->GetBurnLibrary()->RemoveObserver(this);
+        observing_burn_lib_ = false;
+      }
+      return;
+    }
+
+    // Remember burner state, since it will be reset after OnError call.
+    StateMachine::State state = state_machine_->state();
+
+    // Dispach error. All hadlers' OnError event will be called before returning
+    // from this. This includes us, too.
+    state_machine_->OnError(message_id);
+
+    // Do cleanup.
+    if (state  == StateMachine::DOWNLOADING) {
+      if (active_download_item_) {
+        // This will trigger Download canceled event. As a response to that
+        // event, handlers will remove themselves as observers from download
+        // manager and item.
+        // We don't want to process Download Cancelled signal.
+        active_download_item_->RemoveObserver(this);
+        if (active_download_item_->IsPartialDownload())
+          active_download_item_->Cancel(true);
+        active_download_item_->Delete(DownloadItem::DELETE_DUE_TO_USER_DISCARD);
+        active_download_item_ = NULL;
+        CleanupDownloadObjects();
+      }
+    } else if (state == StateMachine::BURNING) {
+      DCHECK(observing_burn_lib_);
+      // Burn library doesn't send cancelled signal upon CancelBurnImage
+      // invokation.
+      CrosLibrary::Get()->GetBurnLibrary()->CancelBurnImage();
+      CrosLibrary::Get()->GetBurnLibrary()->RemoveObserver(this);
+      observing_burn_lib_ = false;
+    }
+    burn_manager_->ResetTargetPaths();
+  }
+
+  bool ExtractInfoFromConfigFile(const ConfigFile& config_file) {
+    std::string hwid;
+    if (!system::StatisticsProvider::GetInstance()->
+        GetMachineStatistic(kHwidStatistic, &hwid))
+      return false;
+
+    image_file_name_ = config_file.GetProperty(kFileName, hwid);
+    if (image_file_name_.empty())
+      return false;
+
+    image_download_url_ = GURL(config_file.GetProperty(kUrl, hwid));
+    if (image_download_url_.is_empty()) {
+      image_file_name_.clear();
+      return false;
+    }
+
+    return true;
+  }
+
+  void CleanupDownloadObjects() {
+    if (active_download_item_) {
+      active_download_item_->RemoveObserver(this);
+      active_download_item_ = NULL;
+    }
+    if (download_manager_) {
+      download_manager_->RemoveObserver(this);
+      download_manager_ = NULL;
+    }
+  }
+
+  int64 GetDeviceSize(const std::string& device_path) {
+    disks::DiskMountManager* disk_mount_manager =
+        disks::DiskMountManager::GetInstance();
+    const disks::DiskMountManager::DiskMap& disks = disk_mount_manager->disks();
+    return disks.find(device_path)->second->total_size_in_bytes();
+  }
+
+  bool CheckNetwork() {
+    return CrosLibrary::Get()->GetNetworkLibrary()->Connected();
+  }
+
+  FilePath zip_image_file_path_;
+  GURL image_download_url_;
+  std::string image_file_name_;
+  content::WebContents* web_contents_;
+  content::DownloadManager* download_manager_;
+  DownloadItem*  active_download_item_;
+  BurnManager* burn_manager_;
+  StateMachine* state_machine_;
+  bool observing_burn_lib_;
+  bool working_;
+  BurnController::Delegate* delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(BurnControllerImpl);
+};
+
+}  // namespace
+
+// static
+BurnController* BurnController::CreateBurnController(
+    content::WebContents* web_contents,
+    Delegate* delegate) {
+  return new BurnControllerImpl(web_contents, delegate);
+}
+
+}  // namespace imageburner
+}  // namespace chromeos
diff --git a/chrome/browser/chromeos/imageburner/burn_controller.h b/chrome/browser/chromeos/imageburner/burn_controller.h
new file mode 100644
index 0000000..e34c861
--- /dev/null
+++ b/chrome/browser/chromeos/imageburner/burn_controller.h
@@ -0,0 +1,90 @@
+// Copyright (c) 2012 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_CHROMEOS_IMAGEBURNER_BURN_CONTROLLER_H_
+#define CHROME_BROWSER_CHROMEOS_IMAGEBURNER_BURN_CONTROLLER_H_
+
+#include <vector>
+
+#include "base/basictypes.h"
+#include "chrome/browser/chromeos/disks/disk_mount_manager.h"
+
+class FilePath;
+
+namespace base {
+class TimeDelta;
+}
+
+namespace content {
+class WebContents;
+}
+
+namespace chromeos {
+namespace imageburner {
+
+// An enum used to describe what type of progress is being made.
+enum ProgressType {
+  DOWNLOADING,
+  UNZIPPING,
+  BURNING
+};
+
+// A class to control recovery media creating process.
+class BurnController {
+ public:
+  class Delegate {
+   public:
+    // Called when recovery image is successfully burnt.
+    virtual void OnSuccess() = 0;
+    // Called when something goes wrong.
+    virtual void OnFail(int error_message_id) = 0;
+    // Called when a burnable device is added.
+    virtual void OnDeviceAdded(const disks::DiskMountManager::Disk& disk) = 0;
+    // Called when a burnable device is removed.
+    virtual void OnDeviceRemoved(const disks::DiskMountManager::Disk& disk) = 0;
+    // Called when device is too small.
+    virtual void OnDeviceTooSmall(int64 device_size) = 0;
+    // Called when some progress is made.
+    virtual void OnProgress(ProgressType progress_type,
+                            int64 amount_finished,
+                            int64 amount_total) = 0;
+    // Called when some progress is made and remaining time estimation is
+    // available.
+    virtual void OnProgressWithRemainingTime(
+        ProgressType progress_type,
+        int64 amount_finished,
+        int64 amount_total,
+        const base::TimeDelta& time_remaining) = 0;
+    // Called when network is connected.
+    virtual void OnNetworkDetected() = 0;
+    // Called when an error occurs because there is no network connection.
+    virtual void OnNoNetwork() = 0;
+  };
+
+  virtual ~BurnController() {}
+
+  // Initializes the instance.
+  virtual void Init() = 0;
+  // Returns devices on which we can burn recovery image.
+  virtual std::vector<disks::DiskMountManager::Disk> GetBurnableDevices() = 0;
+  // Starts burning process.
+  virtual void StartBurnImage(const FilePath& target_device_path,
+                              const FilePath& target_file_path) = 0;
+  // Cancels burning process.
+  virtual void CancelBurnImage() = 0;
+  // Creates a new instance of BurnController.
+  static BurnController* CreateBurnController(
+      content::WebContents* web_contents, Delegate* delegate);
+
+ protected:
+  BurnController() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(BurnController);
+};
+
+}  // namespace imageburner
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_IMAGEBURNER_BURN_CONTROLLER_H_
diff --git a/chrome/browser/ui/webui/chromeos/imageburner/imageburner_ui.cc b/chrome/browser/ui/webui/chromeos/imageburner/imageburner_ui.cc
index 6401b54..2796dc6 100644
--- a/chrome/browser/ui/webui/chromeos/imageburner/imageburner_ui.cc
+++ b/chrome/browser/ui/webui/chromeos/imageburner/imageburner_ui.cc
@@ -4,71 +4,35 @@
 
 #include "chrome/browser/ui/webui/chromeos/imageburner/imageburner_ui.h"
 
-#include <string>
-#include <vector>
-
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/i18n/rtl.h"
-#include "base/memory/weak_ptr.h"
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
-#include "chrome/browser/chromeos/cros/burn_library.h"
-#include "chrome/browser/chromeos/cros/cros_library.h"
-#include "chrome/browser/chromeos/cros/network_library.h"
-#include "chrome/browser/chromeos/disks/disk_mount_manager.h"
-#include "chrome/browser/chromeos/imageburner/burn_manager.h"
-#include "chrome/browser/chromeos/system/statistics_provider.h"
+#include "chrome/browser/chromeos/imageburner/burn_controller.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_data_source.h"
-#include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/time_format.h"
 #include "chrome/common/url_constants.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/browser/download_item.h"
-#include "content/public/browser/download_manager.h"
-#include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_message_handler.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
-#include "grit/locale_settings.h"
 #include "googleurl/src/gurl.h"
 #include "ui/base/l10n/l10n_util.h"
-#include "ui/base/resource/resource_bundle.h"
 #include "ui/base/text/bytes_formatting.h"
 
-
-using content::BrowserThread;
-using content::DownloadItem;
-using content::WebContents;
-
 namespace chromeos {
 namespace imageburner {
 
 namespace {
 
-// An enum used to describe what type of progress is made.
-enum ProgressType {
-  DOWNLOAD,
-  UNZIP,
-  BURN
-};
-
 const char kPropertyDevicePath[] = "devicePath";
 const char kPropertyFilePath[] = "filePath";
 const char kPropertyLabel[] = "label";
 const char kPropertyPath[] = "path";
 
-// Name for hwid in machine statistics.
-const char kHwidStatistic[] = "hardware_class";
-
-const char kImageZipFileName[] = "chromeos_image.bin.zip";
-
-// 3.9GB. It is less than 4GB because true device size ussually varies a little.
-const uint64 kMinDeviceSize = static_cast<uint64>(3.9 * 1000 * 1000 * 1000);
-
 // Link displayed on imageburner ui.
 const char kMoreInfoLink[] =
     "http://www.chromium.org/chromium-os/chromiumos-design-docs/recovery-mode";
@@ -120,97 +84,15 @@ ChromeWebUIDataSource* CreateImageburnerUIHTMLSource() {
   return source;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-//
-// WebUIHandlerTaskProxy
-//
-////////////////////////////////////////////////////////////////////////////////
-
-class WebUIHandlerTaskProxy
-    : public base::RefCountedThreadSafe<WebUIHandlerTaskProxy> {
- public:
-  class Delegate : public base::SupportsWeakPtr<Delegate> {
-   public:
-    virtual void CreateImageDirOnFileThread() = 0;
-    virtual void ImageDirCreatedOnUIThread(bool success) = 0;
-  };
-
-  explicit WebUIHandlerTaskProxy(Delegate* delegate) {
-    delegate_ = delegate->AsWeakPtr();
-    delegate_->DetachFromThread();
-  }
-
-  void CreateImageDir() {
-    if (delegate_)
-      delegate_->CreateImageDirOnFileThread();
-  }
-
-  void OnImageDirCreated(bool success) {
-    if (delegate_)
-      delegate_->ImageDirCreatedOnUIThread(success);
-  }
-
-  // WebUIHandlerTaskProxy is created on the UI thread, so in some cases,
-  // we need to post back to the UI thread for destruction.
-  void DeleteOnUIThread() {
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                            base::Bind(&base::DoNothing));
-  }
-
- private:
-  base::WeakPtr<Delegate> delegate_;
-
-  friend class base::RefCountedThreadSafe<WebUIHandlerTaskProxy>;
-  ~WebUIHandlerTaskProxy() {
-  }
-
-  DISALLOW_COPY_AND_ASSIGN(WebUIHandlerTaskProxy);
-};
-
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// WebUIHandler
-//
-////////////////////////////////////////////////////////////////////////////////
-
 class WebUIHandler
     : public content::WebUIMessageHandler,
-      public chromeos::disks::DiskMountManager::Observer,
-      public chromeos::BurnLibrary::Observer,
-      public chromeos::NetworkLibrary::NetworkManagerObserver,
-      public content::DownloadItem::Observer,
-      public content::DownloadManager::Observer,
-      public Downloader::Listener,
-      public StateMachine::Observer,
-      public WebUIHandlerTaskProxy::Delegate,
-      public BurnManager::Delegate {
+      public BurnController::Delegate {
  public:
   explicit WebUIHandler(content::WebContents* contents)
-      : web_contents_(contents),
-        download_manager_(NULL),
-        active_download_item_(NULL),
-        burn_manager_(NULL),
-        state_machine_(NULL),
-        observing_burn_lib_(false),
-        working_(false) {
-    chromeos::disks::DiskMountManager::GetInstance()->AddObserver(this);
-    chromeos::CrosLibrary::Get()->GetNetworkLibrary()->
-        AddNetworkManagerObserver(this);
-    burn_manager_ = BurnManager::GetInstance();
-    state_machine_ = burn_manager_->state_machine();
-    state_machine_->AddObserver(this);
+      : burn_controller_(BurnController::CreateBurnController(contents, this)){
   }
 
   virtual ~WebUIHandler() {
-    chromeos::disks::DiskMountManager::GetInstance()->
-        RemoveObserver(this);
-    chromeos::CrosLibrary::Get()->GetBurnLibrary()->RemoveObserver(this);
-    chromeos::CrosLibrary::Get()->GetNetworkLibrary()->
-        RemoveNetworkManagerObserver(this);
-    CleanupDownloadObjects();
-    if (state_machine_)
-      state_machine_->RemoveObserver(this);
   }
 
   // WebUIMessageHandler implementation.
@@ -231,205 +113,77 @@ class WebUIHandler
                    base::Unretained(this)));
   }
 
-  // chromeos::disks::DiskMountManager::Observer interface.
-  virtual void DiskChanged(chromeos::disks::DiskMountManagerEventType event,
-                           const chromeos::disks::DiskMountManager::Disk* disk)
-      OVERRIDE {
-    if (!disk->is_parent() || disk->on_boot_device())
-      return;
-    if (event == chromeos::disks::MOUNT_DISK_ADDED) {
-      DictionaryValue disk_value;
-      CreateDiskValue(*disk, &disk_value);
-      web_ui()->CallJavascriptFunction("browserBridge.deviceAdded", disk_value);
-    } else if (event == chromeos::disks::MOUNT_DISK_REMOVED) {
-      StringValue device_path_value(disk->device_path());
-      web_ui()->CallJavascriptFunction("browserBridge.deviceRemoved",
-                                       device_path_value);
-      if (burn_manager_->target_device_path().value() ==
-          disk->device_path()) {
-        ProcessError(IDS_IMAGEBURN_DEVICE_NOT_FOUND_ERROR);
-      }
-    }
+  // BurnController::Delegate override.
+  virtual void OnSuccess() OVERRIDE {
+    web_ui()->CallJavascriptFunction("browserBridge.reportSuccess");
   }
 
-  virtual void DeviceChanged(chromeos::disks::DiskMountManagerEventType event,
-                             const std::string& device_path) OVERRIDE {
+  // BurnController::Delegate override.
+  virtual void OnFail(int error_message_id) OVERRIDE {
+    StringValue error_message(l10n_util::GetStringUTF16(error_message_id));
+    web_ui()->CallJavascriptFunction("browserBridge.reportFail", error_message);
   }
 
-  virtual void MountCompleted(
-      chromeos::disks::DiskMountManager::MountEvent event_type,
-      chromeos::MountError error_code,
-      const chromeos::disks::DiskMountManager::MountPointInfo& mount_info)
+  // BurnController::Delegate override.
+  virtual void OnDeviceAdded(const disks::DiskMountManager::Disk& disk)
       OVERRIDE {
+    DictionaryValue disk_value;
+    CreateDiskValue(disk, &disk_value);
+    web_ui()->CallJavascriptFunction("browserBridge.deviceAdded", disk_value);
   }
 
-  // chromeos::BurnLibrary::Observer interface.
-  virtual void BurnProgressUpdated(chromeos::BurnLibrary* object,
-                                   chromeos::BurnEvent evt,
-                                   const ImageBurnStatus& status) OVERRIDE {
-    switch (evt) {
-      case(chromeos::BURN_SUCCESS):
-        FinalizeBurn();
-        break;
-      case(chromeos::BURN_FAIL):
-        ProcessError(IDS_IMAGEBURN_BURN_ERROR);
-        break;
-      case(chromeos::BURN_UPDATE):
-        SendProgressSignal(BURN, status.amount_burnt, status.total_size, NULL);
-        break;
-      case(chromeos::UNZIP_STARTED):
-        SendProgressSignal(UNZIP, 0, 0, NULL);
-        break;
-      case(chromeos::UNZIP_FAIL):
-        ProcessError(IDS_IMAGEBURN_EXTRACTING_ERROR);
-        break;
-      case(chromeos::UNZIP_COMPLETE):
-        // We ignore this.
-        break;
-      default:
-        NOTREACHED();
-        break;
-    }
-  }
-
-  // chromeos::NetworkLibrary::NetworkManagerObserver interface.
-  virtual void OnNetworkManagerChanged(chromeos::NetworkLibrary* obj) OVERRIDE {
-    if (state_machine_->state() == StateMachine::INITIAL && CheckNetwork()) {
-      web_ui()->CallJavascriptFunction("browserBridge.reportNetworkDetected");
-    }
-    if (state_machine_->state() == StateMachine::DOWNLOADING &&
-        !CheckNetwork()) {
-      ProcessError(IDS_IMAGEBURN_NETWORK_ERROR);
-    }
-  }
-
-  // DownloadItem::Observer interface.
-  virtual void OnDownloadUpdated(content::DownloadItem* download) OVERRIDE {
-    if (download->IsCancelled()) {
-      DownloadCompleted(false);
-      DCHECK(!active_download_item_);
-    } else if (download->IsComplete()) {
-      burn_manager_->set_final_zip_file_path(download->GetFullPath());
-      DownloadCompleted(true);
-      DCHECK(!active_download_item_);
-    } else if (download->IsPartialDownload() &&
-               state_machine_->state() == StateMachine::DOWNLOADING) {
-      base::TimeDelta remaining_time;
-      download->TimeRemaining(&remaining_time);
-      SendProgressSignal(DOWNLOAD, download->GetReceivedBytes(),
-                         download->GetTotalBytes(), &remaining_time);
-    }
-  }
-
-  virtual void OnDownloadOpened(content::DownloadItem* download) OVERRIDE {
-    if (download->GetSafetyState() == DownloadItem::DANGEROUS)
-      download->DangerousDownloadValidated();
-  }
-
-  // DownloadManager::Observer interface.
-  virtual void ModelChanged() OVERRIDE {
-    // Find our item and observe it.
-    std::vector<DownloadItem*> downloads;
-    download_manager_->GetTemporaryDownloads(
-        burn_manager_->GetImageDir(), &downloads);
-    if (active_download_item_)
-      return;
-    for (std::vector<DownloadItem*>::const_iterator it = downloads.begin();
-         it != downloads.end();
-         ++it) {
-      if ((*it)->GetOriginalUrl() == image_download_url_) {
-        (*it)->AddObserver(this);
-        active_download_item_ = *it;
-        break;
-      }
-    }
-  }
-
-  // Downloader::Listener interface.
-  virtual void OnBurnDownloadStarted(bool success) OVERRIDE {
-    if (success)
-      state_machine_->OnDownloadStarted();
-    else
-      DownloadCompleted(false);
-  }
-
-  // StateMachine::Observer interface.
-  virtual void OnBurnStateChanged(StateMachine::State state)
+  // BurnController::Delegate override.
+  virtual void OnDeviceRemoved(const disks::DiskMountManager::Disk& disk)
       OVERRIDE {
-    if (state == StateMachine::CANCELLED) {
-      ProcessError(IDS_IMAGEBURN_USER_ERROR);
-    } else if (state != StateMachine::INITIAL && !working_) {
-      // User has started burn process, so let's start observing.
-      HandleBurnImage(NULL);
-    }
+    StringValue device_path_value(disk.device_path());
+    web_ui()->CallJavascriptFunction("browserBridge.deviceRemoved",
+                                     device_path_value);
   }
 
-  virtual void OnError(int error_message_id) OVERRIDE {
-    StringValue error_message(l10n_util::GetStringUTF16(error_message_id));
-    web_ui()->CallJavascriptFunction("browserBridge.reportFail", error_message);
-    working_ = false;
+  // BurnController::Delegate override.
+  virtual void OnDeviceTooSmall(int64 device_size) OVERRIDE {
+    string16 size;
+    GetDataSizeText(device_size, &size);
+    StringValue device_size_text(size);
+    web_ui()->CallJavascriptFunction("browserBridge.reportDeviceTooSmall",
+                                     device_size_text);
   }
 
-  // Part of WebUIHandlerTaskProxy::Delegate interface.
-  virtual void CreateImageDirOnFileThread() OVERRIDE {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-    burn_manager_->CreateImageDir(this);
+  // BurnController::Delegate override.
+  virtual void OnProgress(ProgressType progress_type,
+                          int64 amount_finished,
+                          int64 amount_total) OVERRIDE {
+    const string16 time_remaining_text =
+        l10n_util::GetStringUTF16(IDS_IMAGEBURN_PROGRESS_TIME_UNKNOWN);
+    SendProgressSignal(progress_type, amount_finished, amount_total,
+                       time_remaining_text);
   }
 
-  // Part of BurnManager::Delegate interface.
-  virtual void OnImageDirCreated(bool success) OVERRIDE {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-    // Transfer to UI thread.
-    scoped_refptr<WebUIHandlerTaskProxy> task = new WebUIHandlerTaskProxy(this);
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(&WebUIHandlerTaskProxy::OnImageDirCreated,
-                   task.get(), success));
+  // BurnController::Delegate override.
+  virtual void OnProgressWithRemainingTime(
+      ProgressType progress_type,
+      int64 amount_finished,
+      int64 amount_total,
+      const base::TimeDelta& time_remaining) OVERRIDE {
+    const string16 time_remaining_text = l10n_util::GetStringFUTF16(
+        IDS_IMAGEBURN_DOWNLOAD_TIME_REMAINING,
+        TimeFormat::TimeRemaining(time_remaining));
+    SendProgressSignal(progress_type, amount_finished, amount_total,
+                       time_remaining_text);
   }
 
-  // Part of WebUIHandlerTaskProxy::Delegate interface.
-  virtual void ImageDirCreatedOnUIThread(bool success) OVERRIDE {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    if (success) {
-      zip_image_file_path_ =
-          burn_manager_->GetImageDir().Append(kImageZipFileName);
-      burn_manager_->FetchConfigFile(web_contents_, this);
-    } else {
-      DownloadCompleted(success);
-    }
+  // BurnController::Delegate override.
+  virtual void OnNetworkDetected() OVERRIDE {
+    web_ui()->CallJavascriptFunction("browserBridge.reportNetworkDetected");
   }
 
-  // Part of BurnManager::Delegate interface.
-  virtual void OnConfigFileFetched(const ConfigFile& config_file, bool success)
-      OVERRIDE {
-    if (!success || !ExtractInfoFromConfigFile(config_file)) {
-      DownloadCompleted(false);
-      return;
-    }
-
-    if (state_machine_->download_finished()) {
-      BurnImage();
-      return;
-    }
-
-    if (!download_manager_) {
-      download_manager_ =
-          web_contents_->GetBrowserContext()->GetDownloadManager();
-      download_manager_->AddObserver(this);
-    }
-    if (!state_machine_->download_started()) {
-      burn_manager_->downloader()->AddListener(this, image_download_url_);
-      if (!state_machine_->image_download_requested()) {
-        state_machine_->OnImageDownloadRequested();
-        burn_manager_->downloader()->DownloadFile(image_download_url_,
-                                                  zip_image_file_path_,
-                                                  web_contents_);
-      }
-    }
+  // BurnController::Delegate override.
+  virtual void OnNoNetwork() OVERRIDE {
+    web_ui()->CallJavascriptFunction("browserBridge.reportNoNetwork");
   }
 
  private:
-  void CreateDiskValue(const chromeos::disks::DiskMountManager::Disk& disk,
+  void CreateDiskValue(const disks::DiskMountManager::Disk& disk,
                        DictionaryValue* disk_value) {
     string16 label = ASCIIToUTF16(disk.drive_label());
     base::i18n::AdjustStringForLocaleDirection(&label);
@@ -438,23 +192,15 @@ class WebUIHandler
     disk_value->SetString(std::string(kPropertyDevicePath), disk.device_path());
   }
 
-  // Callback for the "getRoots" message.
+  // Callback for the "getDevices" message.
   void HandleGetDevices(const ListValue* args) {
-    chromeos::disks::DiskMountManager* disk_mount_manager =
-        chromeos::disks::DiskMountManager::GetInstance();
-    const chromeos::disks::DiskMountManager::DiskMap& disks =
-        disk_mount_manager->disks();
+    const std::vector<disks::DiskMountManager::Disk> disks
+        = burn_controller_->GetBurnableDevices();
     ListValue results_value;
-    for (chromeos::disks::DiskMountManager::DiskMap::const_iterator iter =
-             disks.begin();
-         iter != disks.end();
-         ++iter) {
-      chromeos::disks::DiskMountManager::Disk* disk = iter->second;
-      if (disk->is_parent() && !disk->on_boot_device()) {
-        DictionaryValue* disk_value = new DictionaryValue();
-        CreateDiskValue(*disk, disk_value);
-        results_value.Append(disk_value);
-      }
+    for (size_t i = 0; i != disks.size(); ++i) {
+      DictionaryValue* disk_value = new DictionaryValue();
+      CreateDiskValue(disks[i], disk_value);
+      results_value.Append(disk_value);
     }
     web_ui()->CallJavascriptFunction("browserBridge.getDevicesCallback",
                                      results_value);
@@ -462,197 +208,43 @@ class WebUIHandler
 
   // Callback for the webuiInitialized message.
   void HandleWebUIInitialized(const ListValue* args) {
-    if (state_machine_->state() == StateMachine::BURNING) {
-      // There is nothing else left to do but observe burn progress.
-      BurnImage();
-    } else if (state_machine_->state() != StateMachine::INITIAL) {
-      // User has started burn process, so let's start observing.
-      HandleBurnImage(NULL);
-    }
+    burn_controller_->Init();
   }
 
   // Callback for the "cancelBurnImage" message.
   void HandleCancelBurnImage(const ListValue* args) {
-    state_machine_->OnCancelation();
+    burn_controller_->CancelBurnImage();
   }
 
   // Callback for the "burnImage" message.
   // It may be called with NULL if there is a handler that has started burning,
   // and thus set the target paths.
   void HandleBurnImage(const ListValue* args) {
-    if (args && state_machine_->new_burn_posible()) {
-      if (!CheckNetwork()) {
-        web_ui()->CallJavascriptFunction("browserBridge.reportNoNetwork");
-        return;
-      }
-      FilePath target_device_path;
-      ExtractTargetedDevicePath(*args, 0, &target_device_path);
-      burn_manager_->set_target_device_path(target_device_path);
-
-      FilePath target_file_path;
-      ExtractTargetedDevicePath(*args, 1, &target_file_path);
-      burn_manager_->set_target_file_path(target_file_path);
-
-      uint64 device_size = GetDeviceSize(
-          burn_manager_->target_device_path().value());
-      if (device_size < kMinDeviceSize) {
-        SendDeviceTooSmallSignal(device_size);
-        return;
-      }
-    }
-    if (working_)
-      return;
-    working_ = true;
-    // Send progress signal now so ui doesn't hang in intial state until we get
-    // config file
-    SendProgressSignal(DOWNLOAD, 0, 0, NULL);
-    if (burn_manager_->GetImageDir().empty()) {
-      // Create image dir on File thread.
-      scoped_refptr<WebUIHandlerTaskProxy> task =
-          new WebUIHandlerTaskProxy(this);
-      BrowserThread::PostTask(
-          BrowserThread::FILE, FROM_HERE,
-          base::Bind(&WebUIHandlerTaskProxy::CreateImageDir, task.get()));
-    } else {
-      ImageDirCreatedOnUIThread(true);
-    }
-  }
-
- private:
-  void DownloadCompleted(bool success) {
-    CleanupDownloadObjects();
-    if (success) {
-      state_machine_->OnDownloadFinished();
-      BurnImage();
-    } else {
-      ProcessError(IDS_IMAGEBURN_DOWNLOAD_ERROR);
-    }
-  }
-
-  void BurnImage() {
-    if (!observing_burn_lib_) {
-      chromeos::CrosLibrary::Get()->GetBurnLibrary()->AddObserver(this);
-      observing_burn_lib_ = true;
-    }
-    if (state_machine_->state() == StateMachine::BURNING)
-      return;
-    state_machine_->OnBurnStarted();
-
-    chromeos::CrosLibrary::Get()->GetBurnLibrary()->DoBurn(
-        zip_image_file_path_,
-        image_file_name_, burn_manager_->target_file_path(),
-        burn_manager_->target_device_path());
-  }
-
-  void FinalizeBurn() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    state_machine_->OnSuccess();
-    burn_manager_->ResetTargetPaths();
-    chromeos::CrosLibrary::Get()->GetBurnLibrary()->RemoveObserver(this);
-    observing_burn_lib_ = false;
-    web_ui()->CallJavascriptFunction("browserBridge.reportSuccess");
-    working_ = false;
-  }
-
-  // Error is ussually detected by all existing Burn handlers, but only first
-  // one that calls ProcessError should actually process it.
-  void ProcessError(int message_id) {
-    // If we are in intial state, error has already been dispached.
-    if (state_machine_->state() == StateMachine::INITIAL) {
-      // We don't need burn library since we are not the ones doing the cleanup.
-      if (observing_burn_lib_) {
-        chromeos::CrosLibrary::Get()->GetBurnLibrary()->RemoveObserver(this);
-        observing_burn_lib_ = false;
-      }
-      return;
-    }
-
-    // Remember burner state, since it will be reset after OnError call.
-    StateMachine::State state = state_machine_->state();
-
-    // Dispach error. All hadlers' OnError event will be called before returning
-    // from this. This includes us, too.
-    state_machine_->OnError(message_id);
-
-    // Do cleanup.
-    if (state  == StateMachine::DOWNLOADING) {
-      if (active_download_item_) {
-        // This will trigger Download canceled event. As a response to that
-        // event, handlers will remove themselves as observers from download
-        // manager and item.
-        // We don't want to process Download Cancelled signal.
-        active_download_item_->RemoveObserver(this);
-        if (active_download_item_->IsPartialDownload())
-          active_download_item_->Cancel(true);
-        active_download_item_->Delete(DownloadItem::DELETE_DUE_TO_USER_DISCARD);
-        active_download_item_ = NULL;
-        CleanupDownloadObjects();
-      }
-    } else if (state == StateMachine::BURNING) {
-      DCHECK(observing_burn_lib_);
-      // Burn library doesn't send cancelled signal upon CancelBurnImage
-      // invokation.
-      chromeos::CrosLibrary::Get()->GetBurnLibrary()->CancelBurnImage();
-      chromeos::CrosLibrary::Get()->GetBurnLibrary()->RemoveObserver(this);
-      observing_burn_lib_ = false;
-    }
-    burn_manager_->ResetTargetPaths();
-  }
-
-  bool ExtractInfoFromConfigFile(const ConfigFile& config_file) {
-    std::string hwid;
-    if (!chromeos::system::StatisticsProvider::GetInstance()->
-        GetMachineStatistic(kHwidStatistic, &hwid))
-      return false;
-
-    image_file_name_ = config_file.GetProperty(kFileName, hwid);
-    if (image_file_name_.empty())
-      return false;
-
-    image_download_url_ = GURL(config_file.GetProperty(kUrl, hwid));
-    if (image_download_url_.is_empty()) {
-      image_file_name_.clear();
-      return false;
-    }
-
-    return true;
-  }
+    FilePath target_device_path;
+    ExtractTargetedDevicePath(*args, 0, &target_device_path);
 
-  void CleanupDownloadObjects() {
-    if (active_download_item_) {
-      active_download_item_->RemoveObserver(this);
-      active_download_item_ = NULL;
-    }
-    if (download_manager_) {
-      download_manager_->RemoveObserver(this);
-      download_manager_ = NULL;
-    }
-  }
+    FilePath target_file_path;
+    ExtractTargetedDevicePath(*args, 1, &target_file_path);
 
-  void SendDeviceTooSmallSignal(int64 device_size) {
-    string16 size;
-    GetDataSizeText(device_size, &size);
-    StringValue device_size_text(size);
-    web_ui()->CallJavascriptFunction("browserBridge.reportDeviceTooSmall",
-                                     device_size_text);
+    burn_controller_->StartBurnImage(target_device_path, target_file_path);
   }
 
-  void SendProgressSignal(ProgressType progress_type, int64 amount_finished,
-                          int64 amount_total, const base::TimeDelta* time) {
+  // Reports update to UI
+  void SendProgressSignal(ProgressType progress_type,
+                          int64 amount_finished,
+                          int64 amount_total,
+                          const string16& time_remaining_text) {
     DictionaryValue progress;
     int progress_message_id = 0;
-    int time_left_message_id = IDS_IMAGEBURN_PROGRESS_TIME_UNKNOWN;
-    if (time)
-      time_left_message_id = IDS_IMAGEBURN_DOWNLOAD_TIME_REMAINING;
     switch (progress_type) {
-      case(DOWNLOAD):
+      case DOWNLOADING:
         progress.SetString("progressType", "download");
         progress_message_id = IDS_IMAGEBURN_DOWNLOAD_PROGRESS_TEXT;
         break;
-      case(UNZIP):
+      case UNZIPPING:
         progress.SetString("progressType", "unzip");
         break;
-      case(BURN):
+      case BURNING:
         progress.SetString("progressType", "burn");
         progress_message_id = IDS_IMAGEBURN_BURN_PROGRESS_TEXT;
         break;
@@ -670,27 +262,11 @@ class WebUIHandler
     } else {
       progress.SetString("progressText", "");
     }
-
-    string16 time_left_text;
-    GetProgressTimeLeftText(time_left_message_id, time, &time_left_text);
-    progress.SetString("timeLeftText", time_left_text);
+    progress.SetString("timeLeftText", time_remaining_text);
 
     web_ui()->CallJavascriptFunction("browserBridge.updateProgress", progress);
   }
 
-  // time_left_text should be previously created.
-  void GetProgressTimeLeftText(int message_id,
-                               const base::TimeDelta* time_left,
-                               string16* time_left_text) {
-    if (time_left) {
-      string16 time_remaining_str = TimeFormat::TimeRemaining(*time_left);
-      *time_left_text =
-          l10n_util::GetStringFUTF16(message_id, time_remaining_str);
-    } else {
-      *time_left_text = l10n_util::GetStringUTF16(message_id);
-    }
-  }
-
   // size_text should be previously created.
   void GetDataSizeText(int64 size, string16* size_text) {
     *size_text = ui::FormatBytes(size);
@@ -698,8 +274,10 @@ class WebUIHandler
   }
 
   // progress_text should be previously created.
-  void GetProgressText(int message_id, int64 amount_finished,
-                       int64 amount_total, string16* progress_text) {
+  void GetProgressText(int message_id,
+                       int64 amount_finished,
+                       int64 amount_total,
+                       string16* progress_text) {
     string16 finished;
     GetDataSizeText(amount_finished, &finished);
     string16 total;
@@ -708,7 +286,8 @@ class WebUIHandler
   }
 
   // device_path has to be previously created.
-  void ExtractTargetedDevicePath(const ListValue& list_value, int index,
+  void ExtractTargetedDevicePath(const ListValue& list_value,
+                                 int index,
                                  FilePath* device_path) {
     Value* list_member;
     if (list_value.Get(index, &list_member) &&
@@ -724,28 +303,7 @@ class WebUIHandler
     }
   }
 
-  int64 GetDeviceSize(const std::string& device_path) {
-    chromeos::disks::DiskMountManager* disk_mount_manager =
-        chromeos::disks::DiskMountManager::GetInstance();
-    const chromeos::disks::DiskMountManager::DiskMap& disks =
-        disk_mount_manager->disks();
-    return disks.find(device_path)->second->total_size_in_bytes();
-  }
-
-  bool CheckNetwork() {
-    return chromeos::CrosLibrary::Get()->GetNetworkLibrary()->Connected();
-  }
-
-  FilePath zip_image_file_path_;
-  GURL image_download_url_;
-  std::string image_file_name_;
-  content::WebContents* web_contents_;
-  content::DownloadManager* download_manager_;
-  content::DownloadItem*  active_download_item_;
-  BurnManager* burn_manager_;
-  StateMachine* state_machine_;
-  bool observing_burn_lib_;
-  bool working_;
+  scoped_ptr<BurnController> burn_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(WebUIHandler);
 };
diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi
index 2f1a5b3..de2238b 100644
--- a/chrome/chrome_browser.gypi
+++ b/chrome/chrome_browser.gypi
@@ -503,6 +503,8 @@
         'browser/chromeos/gdata/gdata_parser.h',
         'browser/chromeos/gview_request_interceptor.cc',
         'browser/chromeos/gview_request_interceptor.h',
+        'browser/chromeos/imageburner/burn_controller.cc',
+        'browser/chromeos/imageburner/burn_controller.h',
         'browser/chromeos/imageburner/burn_manager.cc',
         'browser/chromeos/imageburner/burn_manager.h',
         'browser/chromeos/input_method/candidate_window.cc',