Code implements UI for downloading and burning Chrome OS images on SSD card...

Code implements UI for downloading and burning Chrome OS images on SSD card and USB key. Actual burning is not included in the change list.

BUG=chromium-os:5346

TEST=type in  chrome://imagebuner in browser. UI lists all media that image can be burnt to. After selecting burning target by clicking an image right to the target name, image download should start, and download progress should be displayed. After download ends alert should pop up asking user to confirm that he wants to burn image to selected device. Clicking both ok or cancel shouldn't do anything, since actual burning isn't stil included in CL.
Image should be downloaded to chrome_image folder in users Downloads directory. 
this folder is deleted during shutdown.
This is only visible in ChromeOS...

Review URL: http://codereview.chromium.org/2808100

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

chrome/app/generated_resources.grd

@@ -7925,7 +7925,60 @@ Keep your key file in a safe place. You will need it to create new versions of y
     <message name="IDS_FILEBROWSER_ERROR_UNKNOWN_FILE_TYPE" desc="Error message when user attempts to open a file of unknown type in file browser.">
       <ph name="FILENAME">$1</ph> - Unknown file type.
     </message>
-
+    <!-- Imageburn Strings -->
+    <if expr="pp_ifdef('chromeos')">
+      <message name="IDS_IMAGEBURN_CONFIM_BURN1" desc="Ask if user wants to burn image to stateful device (part one)">
+        Are you sure you want to burn image to folowing device:
+      </message>
+      <message name="IDS_IMAGEBURN_TITLE" desc="Image-burn html page title">
+        ChromiumOs Image Burn
+      </message>
+      <message name="IDS_IMAGEBURN_ROOT_LIST_TITLE" desc="Title of the list that shows partitions available for burning image to">
+        Available image targets
+      </message>
+      <message name="IDS_IMAGEBURN_CONFIM_BURN2" desc="Ask if user wants to burn image to stateful device (part two)">
+        ? All data on the device will be lost.
+      </message>
+      <message name="IDS_IMAGEBURN_BURN_UNSUCCESSFUL" desc="Inform user that burning operation ended unsuccessfully">
+        Image burn did not succeed!
+      </message>
+      <message name="IDS_IMAGEBURN_BURN_SUCCESSFUL" desc="Inform user that burning operation was successful">
+        Image burnt successfully!
+      </message>
+      <message name="IDS_IMAGEBURN_DOWNLOAD_UNSUCCESSFUL" desc="Inform user that image could not be downloaded">
+        Image download unsuccessful, burning aborted!
+      </message>
+      <message name="IDS_IMAGEBURN_BURN_PROGRESS" desc="Burnt byte counts (with total)">
+        <ph name="BURNT_AMOUNT">$1<ex>40kB</ex></ph> of <ph name="TOTAL_SIZE">$2<ex>250kB</ex></ph>
+      </message>
+      <message name="IDS_IMAGEBURN_BURN_PROGRESS_SIZE_UNKNOWN" desc="Burnt byte counts (without total)">
+        <ph name="BURNT_AMOUNT">$1<ex>40kB</ex></ph> of Unknown
+      </message>
+      <message name="IDS_IMAGEBURN_DOWNLOAD_STARTING_STATUS" desc="Progress message shown when image download is starting">
+        Waiting for download to start...
+      </message>
+      <message name="IDS_IMAGEBURN_DOWNLOAD_IN_PROGRESS_STATUS" desc="Progress message shown when image download is in progress">
+        Downloading image...
+      </message>
+      <message name="IDS_IMAGEBURN_DOWNLOAD_COMPLETE_STATUS" desc="Progress message shown when image download is finished">
+        Image downloaded.
+      </message>
+      <message name="IDS_IMAGEBURN_DOWNLOAD_CANCELED_STATUS" desc="Progress message shown when image download breaks">
+        Image downloaded has been terminated
+      </message>
+      <message name="IDS_IMAGEBURN_BURN_STARTING_STATUS" desc="Progress message shown when burning image is starting">
+        Initializing burn process...
+      </message>
+      <message name="IDS_IMAGEBURN_BURN_IN_PROGRESS_STATUS" desc="Progress message shown while actually burning the image">
+        Burning image...
+      </message>
+      <message name="IDS_IMAGEBURN_BURN_COMPLETE_STATUS" desc="Progress message shown when image burn is finished">
+        Image burn complete.
+      </message>
+      <message name="IDS_IMAGEBURN_BURN_CANCELED_STATUS" desc="Progress message shown when burning image breaks">
+        Image burning has been terminated
+      </message>
+    </if>
     <!-- Chrome OS Strings -->
     <if expr="pp_ifdef('chromeos')">
       <message name="IDS_NETWORK_CONNECTION_ERROR_TITLE" desc="Title for network connection error notification">

chrome/browser/browser_resources.grd

 <?xml version="1.0" encoding="UTF-8"?>
 <!-- This comment is only here because changes to resources are not picked up
-without changes to the corresponding grd file. eadee -->
+without changes to the corresponding grd file. eadeae-->
 <grit latest_public_release="0" current_release="1">
   <outputs>
     <output filename="grit/browser_resources.h" type="rc_header">
@@ -66,6 +66,7 @@ without changes to the corresponding grd file. eadee -->
         <include name="IDR_ABOUT_SYS_HTML" file="resources\about_sys.html" flattenhtml="true" type="BINDATA" />
         <include name="IDR_FILEBROWSE_HTML" file="resources\filebrowse.html" flattenhtml="true" type="BINDATA" />
         <include name="IDR_HOST_REGISTRATION_PAGE_HTML" file="resources\host_registration_page.html" flattenhtml="true" type="BINDATA" />
+        <include name="IDR_IMAGEBURNER_HTML" file="resources\imageburner.html" flattenhtml="true" type="BINDATA" />
         <include name="IDR_MEDIAPLAYER_HTML" file="resources\mediaplayer.html" flattenhtml="true" type="BINDATA" />
         <include name="IDR_MEDIAPLAYERPLAYLIST_HTML" file="resources\playlist.html" flattenhtml="true" type="BINDATA" />
         <include name="IDR_OFFLINE_LOAD_HTML" file="resources\offline_load.html" flattenhtml="true" type="BINDATA" />

chrome/browser/chromeos/cros/burn_library.cc

+// Copyright (c) 2010 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/cros/burn_library.h"
+
+#include <cstring>
+#include "base/linked_ptr.h"
+#include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chrome_thread.h"
+
+namespace chromeos {
+
+BurnLibraryImpl::BurnLibraryImpl() {
+  if (CrosLibrary::Get()->EnsureLoaded()) {
+      Init();
+    } else {
+      LOG(ERROR) << "Cros Library has not been loaded";
+    }
+}
+
+BurnLibraryImpl::~BurnLibraryImpl() {
+  if (burn_status_connection_) {
+    DisconnectBurnStatus(burn_status_connection_);
+  }
+}
+
+void BurnLibraryImpl::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void BurnLibraryImpl::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
+bool BurnLibraryImpl::DoBurn(const FilePath& from_path,
+                             const FilePath& to_path) {
+  BurnLibraryTaskProxy* task = new BurnLibraryTaskProxy(AsWeakPtr());
+  task->AddRef();
+  task->BurnImage(from_path, to_path);
+  ChromeThread::PostTask(ChromeThread::FILE, FROM_HERE,
+      NewRunnableMethod(task, &BurnLibraryTaskProxy::BurnImage,
+                        from_path, to_path));
+  return true;
+}
+
+bool BurnLibraryImpl::BurnImage(const FilePath& from_path,
+                                const FilePath& to_path) {
+  // Make sure we run on file thread.
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
+
+  // Check if there is a target path already being burnt to.
+  if (target_path_ == "") {
+    target_path_ = to_path.value();
+  } else {
+    return false;
+  }
+
+  StartBurn(from_path.value().c_str(), to_path.value().c_str(),
+            burn_status_connection_);
+  return true;
+}
+
+void BurnLibraryImpl::BurnStatusChangedHandler(void* object,
+                                               const BurnStatus& status,
+                                               BurnEventType evt) {
+  BurnLibraryImpl* burn = static_cast<BurnLibraryImpl*>(object);
+
+  // Copy burn status because it will be freed after returning from this method.
+  ImageBurnStatus* status_copy = new ImageBurnStatus(status);
+
+  BurnLibraryTaskProxy* task = new BurnLibraryTaskProxy(burn->AsWeakPtr());
+  task->AddRef();
+  ChromeThread::PostTask(ChromeThread::UI, FROM_HERE,
+      NewRunnableMethod(task, &BurnLibraryTaskProxy::UpdateBurnStatus,
+                        status_copy, evt));
+}
+
+void BurnLibraryImpl::Init() {
+  burn_status_connection_ = MonitorBurnStatus(&BurnStatusChangedHandler, this);
+}
+
+void BurnLibraryImpl::UpdateBurnStatus(const ImageBurnStatus& status,
+                                       BurnEventType evt) {
+  // Make sure we run on UI thread.
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+
+  // If burn is finished, remove target paths from paths being burnt to.
+  // This has to be done in thread-safe way, hence using task proxy class.
+  if ((evt == BURN_CANCELED || evt == BURN_COMPLETE) &&
+      target_path_ == status.target_path)
+    target_path_ = "";
+
+  FOR_EACH_OBSERVER(Observer, observers_, ProgressUpdated(this, evt, status));
+}
+
+BurnLibraryTaskProxy::BurnLibraryTaskProxy(
+                        const base::WeakPtr<BurnLibraryImpl>& library)
+                            : library_(library) {
+}
+
+void BurnLibraryTaskProxy::BurnImage(const FilePath& from_path,
+                                     const FilePath& to_path) {
+  library_->BurnImage(from_path, to_path);
+}
+
+void BurnLibraryTaskProxy::UpdateBurnStatus(ImageBurnStatus* status,
+                                            BurnEventType evt) {
+  library_->UpdateBurnStatus(*status, evt);
+  delete status;
+}
+
+
+class BurnLibraryStubImpl : public BurnLibrary {
+ public:
+  BurnLibraryStubImpl() {}
+  virtual ~BurnLibraryStubImpl() {}
+
+  // BurnLibrary overrides.
+  virtual void AddObserver(Observer* observer) {}
+  virtual void RemoveObserver(Observer* observer) {}
+  virtual bool DoBurn(const FilePath& from_path, const FilePath& to_path) {
+    return false;
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(BurnLibraryStubImpl);
+};
+
+// static
+BurnLibrary* BurnLibrary::GetImpl(bool stub) {
+  if (stub)
+    return new BurnLibraryStubImpl();
+  else
+    return new BurnLibraryImpl();
+}
+
+}  // namespace chromeos
+
+// Allows InvokeLater without adding refcounting. This class is a Singleton and
+// won't be deleted until it's last InvokeLater is run.
+DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::BurnLibraryImpl);
+

chrome/browser/chromeos/cros/burn_library.h

+// Copyright (c) 2010 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_CROS_BURN_LIBRARY_H_
+#define CHROME_BROWSER_CHROMEOS_CROS_BURN_LIBRARY_H_
+
+#include <string>
+#include <vector>
+
+#include "base/file_path.h"
+#include "base/weak_ptr.h"
+#include "base/observer_list.h"
+
+#include "cros/chromeos_imageburn.h"
+
+struct ImageBurnStatus {
+  explicit ImageBurnStatus(const chromeos::BurnStatus& status)
+      : amount_burnt(status.amount_burnt),
+        total_size(status.total_size) {
+    if (status.target_path)
+      target_path = status.target_path;
+    if (status.error)
+      error = status.error;
+  }
+  std::string target_path;
+  int64 amount_burnt;
+  int64 total_size;
+  std::string error;
+};
+
+namespace chromeos {
+class BurnLibrary {
+ public:
+  class Observer {
+   public:
+    virtual void ProgressUpdated(BurnLibrary* object, BurnEventType evt,
+                                 const ImageBurnStatus& status) = 0;
+  };
+
+  virtual ~BurnLibrary() {}
+
+  virtual void AddObserver(Observer* observer) = 0;
+  virtual void RemoveObserver(Observer* observer) = 0;
+  virtual bool DoBurn(const FilePath& from_path, const FilePath& to_path) = 0;
+
+  // Factory function, creates a new instance and returns ownership.
+  // For normal usage, access the singleton via CrosLibrary::Get().
+  static BurnLibrary* GetImpl(bool stub);
+};
+
+class BurnLibraryImpl : public BurnLibrary,
+                        public base::SupportsWeakPtr<BurnLibraryImpl> {
+ public:
+
+  BurnLibraryImpl();
+  virtual ~BurnLibraryImpl();
+
+  // BurnLibrary implementation.
+  virtual void AddObserver(Observer* observer);
+  virtual void RemoveObserver(Observer* observer);
+  virtual bool DoBurn(const FilePath& from_path, const FilePath& to_path);
+
+  bool BurnImage(const FilePath& from_path, const FilePath& to_path);
+  void UpdateBurnStatus(const ImageBurnStatus& status, BurnEventType evt);
+
+ private:
+  void Init();
+  static void BurnStatusChangedHandler(void* object,
+                                       const BurnStatus& status,
+                                       BurnEventType evt);
+
+ private:
+  ObserverList<BurnLibrary::Observer> observers_;
+  BurnStatusConnection burn_status_connection_;
+
+  // Holds a path that is currently being burnt to.
+  std::string target_path_;
+
+  DISALLOW_COPY_AND_ASSIGN(BurnLibraryImpl);
+};
+
+class BurnLibraryTaskProxy
+    : public base::RefCountedThreadSafe<BurnLibraryTaskProxy> {
+ public:
+  explicit BurnLibraryTaskProxy(const base::WeakPtr<BurnLibraryImpl>& library);
+
+  void BurnImage(const FilePath& from_path, const FilePath& to_path);
+
+  void UpdateBurnStatus(ImageBurnStatus* status, BurnEventType evt);
+
+ private:
+  base::WeakPtr<BurnLibraryImpl> library_;
+
+  friend class base::RefCountedThreadSafe<BurnLibraryTaskProxy>;
+
+  DISALLOW_COPY_AND_ASSIGN(BurnLibraryTaskProxy);
+};
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_CROS_BURN_LIBRARY_H_

chrome/browser/chromeos/cros/cros_library.cc

@@ -6,6 +6,7 @@
 
 #include "chrome/browser/chromeos/cros/cros_library_loader.h"
 #include "chrome/browser/chromeos/cros/cryptohome_library.h"
+#include "chrome/browser/chromeos/cros/burn_library.h"
 #include "chrome/browser/chromeos/cros/input_method_library.h"
 #include "chrome/browser/chromeos/cros/keyboard_library.h"
 #include "chrome/browser/chromeos/cros/login_library.h"
@@ -39,6 +40,10 @@ CrosLibrary* CrosLibrary::Get() {
   return Singleton<CrosLibrary>::get();
 }
 
+BurnLibrary* CrosLibrary::GetBurnLibrary() {
+  return burn_lib_.GetDefaultImpl(use_stub_impl_);
+}
+
 CryptohomeLibrary* CrosLibrary::GetCryptohomeLibrary() {
   return crypto_lib_.GetDefaultImpl(use_stub_impl_);
 }
@@ -129,6 +134,11 @@ void CrosLibrary::TestApi::SetLibraryLoader(LibraryLoader* loader, bool own) {
   library_->load_error_ = false;
 }
 
+void CrosLibrary::TestApi::SetBurnLibrary(
+    BurnLibrary* library, bool own) {
+  library_->burn_lib_.SetImpl(library, own);
+}
+
 void CrosLibrary::TestApi::SetCryptohomeLibrary(
     CryptohomeLibrary* library, bool own) {
   library_->crypto_lib_.SetImpl(library, own);

chrome/browser/chromeos/cros/cros_library.h

@@ -12,6 +12,7 @@
 #include "base/singleton.h"
 namespace chromeos {
 
+class BurnLibrary;
 class CryptohomeLibrary;
 class KeyboardLibrary;
 class InputMethodLibrary;
@@ -44,6 +45,8 @@ class CrosLibrary {
     // when the CrosLibrary is deleted (or other mocks are set).
     // Setter for LibraryLoader.
     void SetLibraryLoader(LibraryLoader* loader, bool own);
+    // Setter for BurnLibrary.
+    void SetBurnLibrary(BurnLibrary* library, bool own);
     // Setter for CryptohomeLibrary.
     void SetCryptohomeLibrary(CryptohomeLibrary* library, bool own);
     // Setter for KeyboardLibrary
@@ -80,6 +83,9 @@ class CrosLibrary {
   // This gets the CrosLibrary.
   static CrosLibrary* Get();
 
+  // Getter for BurnLibrary.
+  BurnLibrary* GetBurnLibrary();
+
   // Getter for CryptohomeLibrary.
   CryptohomeLibrary* GetCryptohomeLibrary();
 
@@ -139,6 +145,7 @@ class CrosLibrary {
   virtual ~CrosLibrary();
 
   LibraryLoader* library_loader_;
+
   bool own_library_loader_;
 
   // This template supports the creation, setting and optional deletion of
@@ -175,6 +182,7 @@ class CrosLibrary {
     bool own_;
   };
 
+  Library<BurnLibrary> burn_lib_;
   Library<CryptohomeLibrary> crypto_lib_;
   Library<KeyboardLibrary> keyboard_lib_;
   Library<InputMethodLibrary> input_method_lib_;

chrome/browser/chromeos/dom_ui/imageburner_ui.h

+// Copyright (c) 2010 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_DOM_UI_IMAGEBURNER_UI_H_
+#define CHROME_BROWSER_CHROMEOS_DOM_UI_IMAGEBURNER_UI_H_
+
+#include <string>
+#include <vector>
+
+#include "app/download_file_interface.h"
+#include "base/file_path.h"
+#include "base/file_util.h"
+#include "base/scoped_ptr.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/mount_library.h"
+#include "chrome/browser/dom_ui/chrome_url_data_manager.h"
+#include "chrome/browser/dom_ui/dom_ui.h"
+#include "chrome/browser/download/download_item.h"
+#include "chrome/browser/download/download_manager.h"
+#include "chrome/browser/download/download_util.h"
+#include "chrome/browser/tab_contents/tab_contents.h"
+#include "googleurl/src/gurl.h"
+#include "net/base/file_stream.h"
+
+static const std::string kPropertyPath = "path";
+static const std::string kPropertyTitle = "title";
+static const std::string kPropertyDirectory = "isDirectory";
+static const std::string kImageBaseURL =
+    "http://chrome-master.mtv.corp.google.com/chromeos/dev-channel/";
+static const std::string kImageFetcherName = "LATEST-x86-generic";
+static const std::string kImageFileName = "chromeos_image.bin.gz";
+static const std::string kTempImageFolderName = "chromeos_image";
+
+class ImageBurnResourceManager;
+
+class ImageBurnUIHTMLSource : public ChromeURLDataManager::DataSource {
+ public:
+  ImageBurnUIHTMLSource();
+
+  // Called when the network layer has requested a resource underneath
+  // the path we registered.
+  virtual void StartDataRequest(const std::string& path,
+                                 bool is_off_the_record,
+                                 int request_id);
+  virtual std::string GetMimeType(const std::string&) const {
+    return "text/html";
+  }
+
+ private:
+  ~ImageBurnUIHTMLSource() {}
+
+  DISALLOW_COPY_AND_ASSIGN(ImageBurnUIHTMLSource);
+};
+
+class ImageBurnHandler : public DOMMessageHandler,
+                         public chromeos::MountLibrary::Observer,
+                         public chromeos::BurnLibrary::Observer,
+                         public DownloadManager::Observer,
+                         public DownloadItem::Observer,
+                         public base::SupportsWeakPtr<ImageBurnHandler> {
+ public:
+  explicit ImageBurnHandler(TabContents* contents);
+  virtual ~ImageBurnHandler();
+
+  // DOMMessageHandler implementation.
+  virtual DOMMessageHandler* Attach(DOMUI* dom_ui);
+  virtual void RegisterMessages();
+
+  // chromeos::MountLibrary::Observer interface
+  virtual void MountChanged(chromeos::MountLibrary* obj,
+                     chromeos::MountEventType evt,
+                     const std::string& path);
+
+  // chromeos::BurnLibrary::Observer interface
+  virtual void ProgressUpdated(chromeos::BurnLibrary* object,
+                               chromeos::BurnEventType evt,
+                               const ImageBurnStatus& status);
+
+  // DownloadItem::Observer interface
+  virtual void OnDownloadUpdated(DownloadItem* download);
+  virtual void OnDownloadFileCompleted(DownloadItem* download);
+  virtual void OnDownloadOpened(DownloadItem* download);
+
+  // DownloadManager::Observer interface
+  virtual void ModelChanged();
+
+  void CreateImageUrlCallback(GURL* image_url);
+
+
+ private:
+  // Callback for the "getRoots" message.
+  void HandleGetRoots(const ListValue* args);
+
+  // Callback for the "downloadImage" message.
+  void HandleDownloadImage(const ListValue* args);
+
+  // Callback for the "burnImage" message.
+  void HandleBurnImage(const ListValue* args);
+
+  // Callback for the "cancelBurnImage" message.
+  void HandleCancelBurnImage(const ListValue* args);
+
+  void DownloadCompleted(bool success);
+
+  void BurnImage();
+  void FinalizeBurn(bool successful);
+
+  void UpdateBurnProgress(int64 total_burnt, int64 image_size,
+                          const std::string& path, chromeos::BurnEventType evt);
+  std::wstring GetBurnProgressText(int64 total_burnt, int64 image_size);
+
+  // helper functions
+  void CreateImageUrl();
+  void ExtractTargetedDeviceSystemPath(const ListValue* list_value);
+  void CreateLocalImagePath();
+
+ private:
+  // file path
+  FilePath local_image_file_path_;
+  FilePath image_target_;
+  GURL* image_download_url_;
+  TabContents* tab_contents_;
+  DownloadManager* download_manager_;
+  bool download_item_observer_added_;
+  DownloadItem*  active_download_item_;
+  ImageBurnResourceManager* burn_resource_manager_;
+
+  friend class ImageBurnTaskProxy;
+
+  DISALLOW_COPY_AND_ASSIGN(ImageBurnHandler);
+};
+
+class ImageBurnTaskProxy
+    : public base::RefCountedThreadSafe<ImageBurnTaskProxy> {
+ public:
+  explicit ImageBurnTaskProxy(const base::WeakPtr<ImageBurnHandler>& handler);
+
+  bool ReportDownloadInitialized();
+  bool CheckDownloadFinished();
+  void BurnImage();
+  void FinalizeBurn(bool success);
+
+  void CreateImageUrl(TabContents* tab_contents, ImageBurnHandler* downloader);
+
+ private:
+  base::WeakPtr<ImageBurnHandler> handler_;
+  ImageBurnResourceManager* resource_manager_;
+
+  friend class base::RefCountedThreadSafe<ImageBurnTaskProxy>;
+
+  DISALLOW_COPY_AND_ASSIGN(ImageBurnTaskProxy);
+};
+
+class ImageBurnResourceManager : public DownloadManager::Observer,
+                                 public DownloadItem::Observer {
+ public:
+  ImageBurnResourceManager();
+  ~ImageBurnResourceManager();
+
+  // DownloadItem::Observer interface
+  virtual void OnDownloadUpdated(DownloadItem* download);
+  virtual void OnDownloadFileCompleted(DownloadItem* download);
+  virtual void OnDownloadOpened(DownloadItem* download);
+
+  // DownloadManager::Observer interface
+  virtual void ModelChanged();
+
+  FilePath GetLocalImageDirPath();
+
+  bool CheckImageDownloadStarted();
+
+  void ReportImageDownloadStarted();
+
+  bool CheckDownloadFinished();
+
+  bool CheckBurnInProgress();
+
+  void SetBurnInProgress(bool value);
+
+  void ReportDownloadFinished(bool success);
+
+  void CreateImageUrl(TabContents* tab_content, ImageBurnHandler* downloader);
+
+  void ImageUrlFetched(bool success);
+
+  net::FileStream* CreateFileStream(FilePath* file_path);
+
+ private:
+  FilePath local_image_dir_file_path_;
+  FilePath image_fecher_local_path_;
+  bool image_download_started_;
+  bool image_download_finished_;
+  bool burn_in_progress_;
+  DownloadManager* download_manager_;
+  bool download_item_observer_added_;
+  DownloadItem*  active_download_item_;
+  scoped_ptr<GURL> image_url_;
+  GURL image_fetcher_url_;
+  bool image_url_fetching_requested_;
+  bool image_url_fetched_;
+  std::vector<ImageBurnHandler*> downloaders_;
+
+
+  DISALLOW_COPY_AND_ASSIGN(ImageBurnResourceManager);
+};
+
+class ImageBurnUI : public DOMUI {
+ public:
+  explicit ImageBurnUI(TabContents* contents);
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ImageBurnUI);
+};
+#endif  // CHROME_BROWSER_CHROMEOS_DOM_UI_IMAGEBURNER_UI_H_
+

chrome/browser/dom_ui/dom_ui_factory.cc

@@ -31,6 +31,7 @@
 #include "googleurl/src/gurl.h"
 
 #if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/dom_ui/imageburner_ui.h"
 #include "chrome/browser/dom_ui/filebrowse_ui.h"
 #include "chrome/browser/dom_ui/mediaplayer_ui.h"
 #include "chrome/browser/dom_ui/register_page_ui.h"
@@ -133,6 +134,8 @@ static DOMUIFactoryFunction GetDOMUIFactoryFunction(const GURL& url) {
     return &NewDOMUI<FileBrowseUI>;
   if (url.host() == chrome::kChromeUIMediaplayerHost)
     return &NewDOMUI<MediaplayerUI>;
+  if (url.host() == chrome::kChromeUIImageBurnerHost)
+    return &NewDOMUI<ImageBurnUI>;
   if (url.host() == chrome::kChromeUIRegisterPageHost)
     return &NewDOMUI<RegisterPageUI>;
   if (url.host() == chrome::kChromeUISlideshowHost)

chrome/chrome_browser.gypi

 # Copyright (c) 2010 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.
+# found in the LICENSE file. 
 
 {
   'targets': [
@@ -377,6 +377,8 @@
         'browser/chromeos/cros_settings_provider.h',
         'browser/chromeos/cros_settings_provider_user.cc',
         'browser/chromeos/cros_settings_provider_user.h',
+        'browser/chromeos/cros/burn_library.cc',
+        'browser/chromeos/cros/burn_library.h',
         'browser/chromeos/cros/cros_library.cc',
         'browser/chromeos/cros/cros_library.h',
         'browser/chromeos/cros/cros_library_loader.cc',
@@ -1220,6 +1222,8 @@
         'browser/dom_ui/html_dialog_tab_contents_delegate.h',
         'browser/dom_ui/html_dialog_ui.cc',
         'browser/dom_ui/html_dialog_ui.h',
+        'browser/chromeos/dom_ui/imageburner_ui.cc',
+        'browser/chromeos/dom_ui/imageburner_ui.h',
         'browser/dom_ui/import_data_handler.cc',
         'browser/dom_ui/import_data_handler.h',
         'browser/dom_ui/mediaplayer_ui.cc',

chrome/common/url_constants.cc

@@ -73,6 +73,7 @@ const char kChromeUIFavIconURL[] = "chrome://favicon/";
 const char kChromeUIFileBrowseURL[] = "chrome://filebrowse/";
 const char kChromeUIHistoryURL[] = "chrome://history/";
 const char kChromeUIHistory2URL[] = "chrome://history2/";
+const char kChromeUIImageBurnerURL[] = "chrome://imageburner/";
 const char kChromeUIIPCURL[] = "chrome://about/ipc";
 const char kChromeUIMediaplayerURL[] = "chrome://mediaplayer/";
 const char kChromeUINewTabURL[] = "chrome://newtab";
@@ -92,6 +93,7 @@ const char kChromeUIFavIconHost[] = "favicon";
 const char kChromeUIFileBrowseHost[] = "filebrowse";
 const char kChromeUIHistoryHost[] = "history";
 const char kChromeUIHistory2Host[] = "history2";
+const char kChromeUIImageBurnerHost[] = "imageburner";
 const char kChromeUIInspectorHost[] = "inspector";
 const char kChromeUIMediaplayerHost[] = "mediaplayer";
 const char kChromeUINetInternalsHost[] = "net-internals";

chrome/common/url_constants.h

@@ -66,6 +66,7 @@ extern const char kChromeUIFavIconURL[];
 extern const char kChromeUIFileBrowseURL[];
 extern const char kChromeUIHistoryURL[];
 extern const char kChromeUIHistory2URL[];
+extern const char kChromeUIImageBurnerURL[];
 extern const char kChromeUIIPCURL[];
 extern const char kChromeUIMediaplayerURL[];
 extern const char kChromeUINewTabURL[];
@@ -87,6 +88,7 @@ extern const char kChromeUIFavIconHost[];
 extern const char kChromeUIFileBrowseHost[];
 extern const char kChromeUIHistoryHost[];
 extern const char kChromeUIHistory2Host[];
+extern const char kChromeUIImageBurnerHost[];
 extern const char kChromeUIInspectorHost[];
 extern const char kChromeUIMediaplayerHost[];
 extern const char kChromeUINetInternalsHost[];