Move chromeos_mount.cc from libcros to Chrome tree

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 "chrome/browser/ui/webui/chromeos/imageburner/webui_handler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/i18n/rtl.h"
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
+#include "chrome/browser/chromeos/dbus/dbus_thread_manager.h"
 #include "chrome/browser/chromeos/system/statistics_provider.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 "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
@@ skipping 94 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 
 WebUIHandler::WebUIHandler(TabContents* contents)
     : tab_contents_(contents),
       download_manager_(NULL),
       active_download_item_(NULL),
       burn_manager_(NULL),
       state_machine_(NULL),
       observing_burn_lib_(false),
       working_(false) {
-  chromeos::CrosLibrary::Get()->GetMountLibrary()->AddObserver(this);
+  chromeos::DBusThreadManager::Get()->GetCrosDisksClient()->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::CrosLibrary::Get()->GetMountLibrary()->RemoveObserver(this);
+  chromeos::DBusThreadManager::Get()->GetCrosDisksClient()->
+      RemoveObserver(this);
   chromeos::CrosLibrary::Get()->GetBurnLibrary()->RemoveObserver(this);
   chromeos::CrosLibrary::Get()->GetNetworkLibrary()->
       RemoveNetworkManagerObserver(this);
   CleanupDownloadObjects();
   if (state_machine_)
     state_machine_->RemoveObserver(this);
 }
 
 WebUIMessageHandler* WebUIHandler::Attach(WebUI* web_ui) {
   return WebUIMessageHandler::Attach(web_ui);
 }
 
 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::MountLibraryEventType event,
-                                   const chromeos::MountLibrary::Disk* disk) {
+void WebUIHandler::DiskChanged(chromeos::CrosDisksClientEventType event,
+                               const chromeos::CrosDisksClient::Disk* disk) {
   if (!disk->is_parent() || disk->on_boot_device())
     return;
   if (event == chromeos::MOUNT_DISK_ADDED) {
     DictionaryValue disk_value;
     CreateDiskValue(*disk, &disk_value);
     web_ui_->CallJavascriptFunction("browserBridge.deviceAdded", disk_value);
   } else if (event == chromeos::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);
     }
   }
 }
 
 void WebUIHandler::BurnProgressUpdated(chromeos::BurnLibrary* object,
-                                           chromeos::BurnEvent evt,
-                                           const ImageBurnStatus& status) {
+                                       chromeos::BurnEvent evt,
+                                       const ImageBurnStatus& status) {
   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;
@@ skipping 76 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::MountLibrary::Disk& disk,
+void WebUIHandler::CreateDiskValue(const chromeos::CrosDisksClient::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());
 }
 
 void WebUIHandler::HandleGetDevices(const ListValue* args) {
-  chromeos::MountLibrary* mount_lib =
-      chromeos::CrosLibrary::Get()->GetMountLibrary();
-  const chromeos::MountLibrary::DiskMap& disks = mount_lib->disks();
+  chromeos::CrosDisksClient* mount_lib =
+      chromeos::DBusThreadManager::Get()->GetCrosDisksClient();
+  const chromeos::CrosDisksClient::DiskMap& disks = mount_lib->disks();
   ListValue results_value;
-  for (chromeos::MountLibrary::DiskMap::const_iterator iter =  disks.begin();
+  for (chromeos::CrosDisksClient::DiskMap::const_iterator iter =  disks.begin();
        iter != disks.end();
        ++iter) {
-    chromeos::MountLibrary::Disk* disk = iter->second;
+    chromeos::CrosDisksClient::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);
     }
   }
   web_ui_->CallJavascriptFunction("browserBridge.getDevicesCallback",
       results_value);
 }
 
@@ 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::MountLibrary* mount_lib =
-      chromeos::CrosLibrary::Get()->GetMountLibrary();
-  const chromeos::MountLibrary::DiskMap& disks = mount_lib->disks();
+  chromeos::CrosDisksClient* mount_lib =
+      chromeos::DBusThreadManager::Get()->GetCrosDisksClient();
+  const chromeos::CrosDisksClient::DiskMap& disks = mount_lib->disks();
   return disks.find(device_path)->second->total_size();
 }
 
 bool WebUIHandler::CheckNetwork() {
   return chromeos::CrosLibrary::Get()->GetNetworkLibrary()->Connected();
 }
 
 }  // namespace imageburner.
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // ImageBurnUI
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 ImageBurnUI::ImageBurnUI(TabContents* contents) : ChromeWebUI(contents) {
   imageburner::WebUIHandler* handler = new imageburner::WebUIHandler(contents);
   AddMessageHandler((handler)->Attach(this));
 
   Profile* profile = Profile::FromBrowserContext(contents->browser_context());
   profile->GetChromeURLDataManager()->AddDataSource(
       CreateImageburnerUIHTMLSource());
 }