[CrosDisksClient] Determine device type from DeviceMediaType property sent by cros-disks.

chrome/browser/ui/webui/chromeos/imageburner/imageburner_ui.cc

 // Copyright (c) 2011 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/ui/webui/chromeos/imageburner/imageburner_ui.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 12 matching lines @@
 #include "content/browser/webui/web_ui.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/text/bytes_formatting.h"
 
+using chromeos::disks::DiskMountManager;
+using chromeos::disks::DiskMountManagerEventType;
 using content::BrowserThread;
 using content::DownloadItem;
 using content::WebContents;
 
+namespace {
+
 const char kPropertyDevicePath[] = "devicePath";
 const char kPropertyFilePath[] = "filePath";
 const char kPropertyLabel[] = "label";
 const char kPropertyPath[] = "path";
+const char kPropertyDeviceType[] = "type";
 
 // 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";
 
-namespace {
+bool AllowBurnToDevice(const DiskMountManager::Disk* disk) {

[achuithb, 2012/01/23 22:17:17]

might be nicer to use const DiskMountManager::Disk& instead of Disk*. pointers
are generally used for out params, and references for in params.

[tbarzic, 2012/01/23 22:42:40]

Done.

+  return disk->is_parent() && !disk->on_boot_device() &&
+         (disk->device_type() == chromeos::DEVICE_TYPE_USB ||
+          disk->device_type() == chromeos::DEVICE_TYPE_SD);
+}
 
 ChromeWebUIDataSource* CreateImageburnerUIHTMLSource() {
   ChromeWebUIDataSource* source =
       new ChromeWebUIDataSource(chrome::kChromeUIImageBurnerHost);
 
     source->AddLocalizedString("headerTitle", IDS_IMAGEBURN_HEADER_TITLE);
     source->AddLocalizedString("headerDescription",
                                IDS_IMAGEBURN_HEADER_DESCRIPTION);
     source->AddLocalizedString("headerLink", IDS_IMAGEBURN_HEADER_LINK);
     source->AddLocalizedString("statusDevicesNone",
@@ skipping 65 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 
 WebUIHandler::WebUIHandler(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);
+  DiskMountManager::GetInstance()->AddObserver(this);
   chromeos::CrosLibrary::Get()->GetNetworkLibrary()->
       AddNetworkManagerObserver(this);
   burn_manager_ = BurnManager::GetInstance();
   state_machine_ = burn_manager_->state_machine();
   state_machine_->AddObserver(this);
 }
 
 WebUIHandler::~WebUIHandler() {
-  chromeos::disks::DiskMountManager::GetInstance()->
-      RemoveObserver(this);
+  DiskMountManager::GetInstance()->RemoveObserver(this);
   chromeos::CrosLibrary::Get()->GetBurnLibrary()->RemoveObserver(this);
   chromeos::CrosLibrary::Get()->GetNetworkLibrary()->
       RemoveNetworkManagerObserver(this);
   CleanupDownloadObjects();
   if (state_machine_)
     state_machine_->RemoveObserver(this);
 }
 
 void WebUIHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback("getDevices",
       base::Bind(&WebUIHandler::HandleGetDevices, base::Unretained(this)));
   web_ui()->RegisterMessageCallback("burnImage",
       base::Bind(&WebUIHandler::HandleBurnImage, base::Unretained(this)));
   web_ui()->RegisterMessageCallback("cancelBurnImage",
       base::Bind(&WebUIHandler::HandleCancelBurnImage, base::Unretained(this)));
   web_ui()->RegisterMessageCallback("webuiInitialized",
       base::Bind(&WebUIHandler::HandleWebUIInitialized,
                  base::Unretained(this)));
 }
 
-void WebUIHandler::DiskChanged(
-    chromeos::disks::DiskMountManagerEventType event,
-    const chromeos::disks::DiskMountManager::Disk* disk) {
-  if (!disk->is_parent() || disk->on_boot_device())
+void WebUIHandler::DiskChanged(DiskMountManagerEventType event,
+                               const DiskMountManager::Disk* disk) {

[achuithb, 2012/01/23 22:17:17]

Disk&?

[tbarzic, 2012/01/23 22:42:40]

This is DiskMountManager observer method, so I would leave it like this for now
(we can change DiskMountManager to send reference instead of pointer later, in
separate CL)

+  if (!AllowBurnToDevice(disk))
     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() ==
@@ skipping 95 matching lines @@
     HandleBurnImage(NULL);
   }
 }
 
 void WebUIHandler::OnError(int error_message_id) {
   StringValue error_message(l10n_util::GetStringUTF16(error_message_id));
   web_ui()->CallJavascriptFunction("browserBridge.reportFail", error_message);
   working_ = false;
 }
 
-void WebUIHandler::CreateDiskValue(
-    const chromeos::disks::DiskMountManager::Disk& disk,
-    DictionaryValue* disk_value) {
+void WebUIHandler::CreateDiskValue(const DiskMountManager::Disk& disk,
+                                   DictionaryValue* disk_value) {
   string16 label = ASCIIToUTF16(disk.drive_label());
   base::i18n::AdjustStringForLocaleDirection(&label);
   disk_value->SetString(std::string(kPropertyLabel), label);
   disk_value->SetString(std::string(kPropertyFilePath), disk.file_path());
   disk_value->SetString(std::string(kPropertyDevicePath), disk.device_path());
+  disk_value->SetString(std::string(kPropertyDeviceType),
+      DiskMountManager::DeviceTypeToString(disk.device_type()));
 }
 
 void WebUIHandler::HandleGetDevices(const ListValue* args) {
-  chromeos::disks::DiskMountManager* disk_mount_manager =
-      chromeos::disks::DiskMountManager::GetInstance();
-  const chromeos::disks::DiskMountManager::DiskMap& disks =
-      disk_mount_manager->disks();
+  DiskMountManager* disk_mount_manager = DiskMountManager::GetInstance();
+  const DiskMountManager::DiskMap& disks = disk_mount_manager->disks();
   ListValue results_value;
-  for (chromeos::disks::DiskMountManager::DiskMap::const_iterator iter =
-           disks.begin();
+  for (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()) {
+    DiskMountManager::Disk* disk = iter->second;
+    if (AllowBurnToDevice(disk)) {
       DictionaryValue* disk_value = new DictionaryValue();
       CreateDiskValue(*disk, disk_value);
       results_value.Append(disk_value);
     }
   }
   web_ui()->CallJavascriptFunction("browserBridge.getDevicesCallback",
       results_value);
 }
 
 void WebUIHandler::HandleWebUIInitialized(const ListValue* args) {
@@ skipping 297 matching lines @@
     std::string image_dest;
     string_value->GetAsString(&image_dest);
     *device_path = FilePath(image_dest);
   } else {
     LOG(ERROR) << "Unable to get path string";
     device_path->clear();
   }
 }
 
 int64 WebUIHandler::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();
+  DiskMountManager* disk_mount_manager = DiskMountManager::GetInstance();
+  const DiskMountManager::DiskMap& disks = disk_mount_manager->disks();
   return disks.find(device_path)->second->total_size_in_bytes();
 }
 
 bool WebUIHandler::CheckNetwork() {
   return chromeos::CrosLibrary::Get()->GetNetworkLibrary()->Connected();
 }
 
 }  // namespace imageburner.
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // ImageBurnUI
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 ImageBurnUI::ImageBurnUI(WebContents* contents) : WebUI(contents) {
   imageburner::WebUIHandler* handler = new imageburner::WebUIHandler(contents);
   AddMessageHandler(handler);
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   profile->GetChromeURLDataManager()->AddDataSource(
       CreateImageburnerUIHTMLSource());
 }