Switch from MountLibrary to CrosDisksLibrary

chrome/browser/extensions/extension_file_browser_private_api.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/extensions/extension_file_browser_private_api.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
@@ skipping 32 matching lines @@
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 
-#ifdef OS_CHROMEOS
-#include "chrome/browser/chromeos/cros/cros_library.h"
-#endif
+using content::BrowserThread;
 
-using content::BrowserThread;
+namespace {
 
 // Error messages.
 const char kFileError[] = "File error %d";
 const char kInvalidFileUrl[] = "Invalid file URL";
 const char kVolumeDevicePathNotFound[] = "Device path not found";
 
 #ifdef OS_CHROMEOS
 // Volume type strings.
 const std::string kVolumeTypeFlash = "flash";
 const std::string kVolumeTypeOptical = "optical";
@@ skipping 192 matching lines @@
   DictionaryPrefUpdate prefs_usage_update(profile->GetPrefs(),
       prefs::kLastUsedFileBrowserHandlers);
   prefs_usage_update->SetWithoutPathExpansion(task_id,
       new base::FundamentalValue(
           static_cast<int>(base::Time::Now().ToInternalValue()/
                            base::Time::kMicrosecondsPerSecond)));
 }
 
 #ifdef OS_CHROMEOS
 base::DictionaryValue* MountPointToValue(Profile* profile,
-    const chromeos::MountLibrary::MountPointInfo& mount_point_info) {
+    const chromeos::disks::DiskMountManager::MountPointInfo& mount_point_info) {
 
     base::DictionaryValue *mount_info = new base::DictionaryValue();
 
     mount_info->SetString("mountType",
-        chromeos::MountLibrary::MountTypeToString(mount_point_info.mount_type));
+                          chromeos::disks::DiskMountManager::MountTypeToString(
+                              mount_point_info.mount_type));
 
     if (mount_point_info.mount_type == chromeos::MOUNT_TYPE_ARCHIVE) {
       GURL source_url;
       if (FileManagerUtil::ConvertFileToFileSystemUrl(profile,
               FilePath(mount_point_info.source_path),
               FileManagerUtil::GetFileBrowserExtensionUrl().GetOrigin(),
               &source_url)) {
         mount_info->SetString("sourceUrl", source_url.spec());
       }
     } else {
       mount_info->SetString("sourceUrl", mount_point_info.source_path);
     }
 
     FilePath relative_mount_path;
     // Convert mount point path to relative path with the external file system
     // exposed within File API.
     if (FileManagerUtil::ConvertFileToRelativeFileSystemPath(profile,
             FilePath(mount_point_info.mount_path),
             &relative_mount_path)) {
       mount_info->SetString("mountPath", relative_mount_path.value());
     }
 
     mount_info->SetString("mountCondition",
-        chromeos::MountLibrary::MountConditionToString(
+        chromeos::disks::DiskMountManager::MountConditionToString(
         mount_point_info.mount_condition));
 
     return mount_info;
 }
 #endif
 
+}  // namespace
 
-class LocalFileSystemCallbackDispatcher
+class RequestLocalFileSystemFunction::LocalFileSystemCallbackDispatcher
     : public fileapi::FileSystemCallbackDispatcher {
  public:
   explicit LocalFileSystemCallbackDispatcher(
       RequestLocalFileSystemFunction* function,
       Profile* profile,
       int child_id,
       scoped_refptr<const Extension> extension)
       : function_(function),
         profile_(profile),
         child_id_(child_id),
@@ skipping 297 matching lines @@
     task->SetString("iconUrl", icon.spec());
     result_list->Append(task);
   }
 
   // TODO(zelidrag, serya): Add intent content tasks to result_list once we
   // implement that API.
   SendResponse(true);
   return true;
 }
 
-class ExecuteTasksFileSystemCallbackDispatcher
+class ExecuteTasksFileBrowserFunction::ExecuteTasksFileSystemCallbackDispatcher
     : public fileapi::FileSystemCallbackDispatcher {
  public:
   explicit ExecuteTasksFileSystemCallbackDispatcher(
       ExecuteTasksFileBrowserFunction* function,
       Profile* profile,
       int child_id,
       const GURL& source_url,
       scoped_refptr<const Extension> extension,
       const std::string task_id,
       const std::vector<GURL>& file_urls)
@@ skipping 349 matching lines @@
   }
   TabContents* tab_contents =
       dispatcher()->delegate()->GetAssociatedTabContents();
   if (!tab_contents) {
     LOG(WARNING) << "No associated tab contents";
     return 0;
   }
   return ExtensionTabUtil::GetTabId(tab_contents);
 }
 
+void FileBrowserFunction::GetLocalPathsOnFileThreadAndRunCallbackOnUIThread(
+    const UrlList& file_urls,
+    GetLocalPathsCallback callback) {
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(
+          &FileBrowserFunction::GetLocalPathsOnFileThread,
+          this,
+          file_urls, callback));
+}
+
 // GetFileSystemRootPathOnFileThread can only be called from the file thread,
 // so here we are. This function takes a vector of virtual paths, converts
-// them to local paths and calls GetLocalPathsResponseOnUIThread with the
-// result vector, on the UI thread.
-void FileBrowserFunction::GetLocalPathsOnFileThread(const UrlList& file_urls,
-                                                    void* context) {
+// them to local paths and calls |callback| with the result vector, on the UI
+// thread.
+void FileBrowserFunction::GetLocalPathsOnFileThread(
+    const UrlList& file_urls,
+    GetLocalPathsCallback callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   FilePathList selected_files;
 
   // FilePath(virtual_path) doesn't work on win, so limit this to ChromeOS.
 #if defined(OS_CHROMEOS)
   GURL origin_url = source_url().GetOrigin();
   fileapi::FileSystemPathManager* path_manager =
       profile()->GetFileSystemContext()->path_manager();
 
   size_t len = file_urls.size();
@@ skipping 18 matching lines @@
         false);
     if (!root.empty()) {
       selected_files.push_back(root.Append(virtual_path));
     } else {
       LOG(WARNING) << "GetLocalPathsOnFileThread failed "
                    << file_url.spec();
     }
   }
 #endif
 
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(
-          &FileBrowserFunction::GetLocalPathsResponseOnUIThread,
-          this,
-          selected_files, context));
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::Bind(callback, selected_files));
 }
 
 bool SelectFileFunction::RunImpl() {
   if (args_->GetSize() != 2) {
     return false;
   }
   std::string file_url;
   args_->GetString(0, &file_url);
   UrlList file_paths;
   file_paths.push_back(GURL(file_url));
 
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(
-          &SelectFileFunction::GetLocalPathsOnFileThread,
-          this,
-          file_paths, reinterpret_cast<void*>(NULL)));
-
+  GetLocalPathsOnFileThreadAndRunCallbackOnUIThread(
+      file_paths,
+      base::Bind(&SelectFileFunction::GetLocalPathsResponseOnUIThread, this));
   return true;
 }
 
 void SelectFileFunction::GetLocalPathsResponseOnUIThread(
-    const FilePathList& files, void* context) {
+    const FilePathList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!context);
   if (files.size() != 1) {
     SendResponse(false);
     return;
   }
   int index;
   args_->GetInteger(1, &index);
   int32 tab_id = GetTabId();
   SelectFileDialogExtension::OnFileSelected(tab_id, files[0], index);
   SendResponse(true);
 }
@@ skipping 19 matching lines @@
 
   std::string virtual_path;
   size_t len = path_list->GetSize();
   UrlList file_urls;
   file_urls.reserve(len);
   for (size_t i = 0; i < len; ++i) {
     path_list->GetString(i, &virtual_path);
     file_urls.push_back(GURL(virtual_path));
   }
 
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(
-          &ViewFilesFunction::GetLocalPathsOnFileThread,
-          this,
-          file_urls,
-          reinterpret_cast<void*>(new std::string(internal_task_id))));
-
+  GetLocalPathsOnFileThreadAndRunCallbackOnUIThread(
+      file_urls,
+      base::Bind(&ViewFilesFunction::GetLocalPathsResponseOnUIThread,
+                 this,
+                 internal_task_id));
   return true;
 }
 
 void ViewFilesFunction::GetLocalPathsResponseOnUIThread(
-    const FilePathList& files, void* context) {
+    const std::string& internal_task_id,
+    const FilePathList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(context);
-  scoped_ptr<std::string> internal_task_id(
-      reinterpret_cast<std::string*>(context));
   for (FilePathList::const_iterator iter = files.begin();
        iter != files.end();
        ++iter) {
     FileManagerUtil::ViewItem(*iter,
-                              *(internal_task_id.get()) == kEnqueueTaskId ||
-                                  // Start the first one, enqueue others.
-                                  iter != files.begin());
+                              internal_task_id == kEnqueueTaskId ||
+                                // Start the first one, enqueue others.
+                                iter != files.begin());
   }
   SendResponse(true);
 }
 
 SelectFilesFunction::SelectFilesFunction() {
 }
 
 SelectFilesFunction::~SelectFilesFunction() {
 }
 
 bool SelectFilesFunction::RunImpl() {
   if (args_->GetSize() != 1) {
     return false;
   }
 
   ListValue* path_list = NULL;
   args_->GetList(0, &path_list);
   DCHECK(path_list);
 
   std::string virtual_path;
   size_t len = path_list->GetSize();
   UrlList file_urls;
   file_urls.reserve(len);
   for (size_t i = 0; i < len; ++i) {
     path_list->GetString(i, &virtual_path);
     file_urls.push_back(GURL(virtual_path));
   }
 
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(
-          &SelectFilesFunction::GetLocalPathsOnFileThread,
-          this,
-          file_urls, reinterpret_cast<void*>(NULL)));
-
+  GetLocalPathsOnFileThreadAndRunCallbackOnUIThread(
+      file_urls,
+      base::Bind(&SelectFilesFunction::GetLocalPathsResponseOnUIThread, this));
   return true;
 }
 
 void SelectFilesFunction::GetLocalPathsResponseOnUIThread(
-    const FilePathList& files, void* context) {
+    const FilePathList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!context);
   int32 tab_id = GetTabId();
   SelectFileDialogExtension::OnMultiFilesSelected(tab_id, files);
   SendResponse(true);
 }
 
 bool CancelFileDialogFunction::RunImpl() {
   int32 tab_id = GetTabId();
   SelectFileDialogExtension::OnFileSelectionCanceled(tab_id);
   SendResponse(true);
   return true;
 }
 
 AddMountFunction::AddMountFunction() {
 }
 
 AddMountFunction::~AddMountFunction() {
 }
 
 bool AddMountFunction::RunImpl() {
+  // The third argument is simply ignored.
   if (args_->GetSize() != 2 && args_->GetSize() != 3) {
     error_ = "Invalid argument count";
     return false;
   }
 
   std::string file_url;
   if (!args_->GetString(0, &file_url)) {
     return false;
   }
 
   std::string mount_type_str;
   if (!args_->GetString(1, &mount_type_str)) {
     return false;
   }
 
   UrlList file_paths;
   file_paths.push_back(GURL(file_url));
 
 #if defined(OS_CHROMEOS)
-  chromeos::MountPathOptions options;
-  if (args_->GetSize() == 3) {
-    DictionaryValue *dict;
-    if (!args_->GetDictionary(2, &dict)) {
-      NOTREACHED();
-    }
-
-    for (base::DictionaryValue::key_iterator it = dict->begin_keys();
-         it != dict->end_keys();
-         ++it) {
-      std::string value;
-      if (!dict->GetString(*it, &value)) {
-        NOTREACHED();
-      }
-
-      options.push_back(chromeos::MountPathOptions::value_type((*it).c_str(),
-                                                               value.c_str()));
-    }
-  }
-
-  MountParamaters* params = new MountParamaters(mount_type_str, options);
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(
-          &AddMountFunction::GetLocalPathsOnFileThread,
-          this,
-          file_paths, reinterpret_cast<void*>(params)));
+  GetLocalPathsOnFileThreadAndRunCallbackOnUIThread(
+      file_paths,
+      base::Bind(&AddMountFunction::GetLocalPathsResponseOnUIThread,
+                 this,
+                 mount_type_str));
 #endif  // OS_CHROMEOS
 
   return true;
 }
 
 void AddMountFunction::GetLocalPathsResponseOnUIThread(
-    const FilePathList& files, void* context) {
+    const std::string& mount_type_str,
+    const FilePathList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(context);
 
   if (!files.size()) {
     SendResponse(false);
     return;
   }
 
 #ifdef OS_CHROMEOS
-  scoped_ptr<MountParamaters> params(
-      reinterpret_cast<MountParamaters*>(context));
-  const std::string& mount_type_str = params->mount_type;
-  const chromeos::MountPathOptions& options = params->mount_options;
   FilePath::StringType source_file = files[0].value();
 
-  chromeos::MountLibrary *mount_lib =
-      chromeos::CrosLibrary::Get()->GetMountLibrary();
+  chromeos::disks::DiskMountManager* disk_mount_manager =
+      chromeos::disks::DiskMountManager::GetInstance();
 
   chromeos::MountType mount_type =
-      mount_lib->MountTypeFromString(mount_type_str);
+      disk_mount_manager->MountTypeFromString(mount_type_str);
   if (mount_type == chromeos::MOUNT_TYPE_INVALID) {
     error_ = "Invalid mount type";
     SendResponse(false);
     return;
   }
 
-  mount_lib->MountPath(source_file.data(), mount_type, options);
+  disk_mount_manager->MountPath(source_file.data(), mount_type);
 #endif
 
   SendResponse(true);
 }
 
 RemoveMountFunction::RemoveMountFunction() {
 }
 
 RemoveMountFunction::~RemoveMountFunction() {
 }
 
 bool RemoveMountFunction::RunImpl() {
   if (args_->GetSize() != 1) {
     return false;
   }
 
   std::string mount_path;
   if (!args_->GetString(0, &mount_path)) {
     return false;
   }
 
   UrlList file_paths;
   file_paths.push_back(GURL(mount_path));
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(
-          &RemoveMountFunction::GetLocalPathsOnFileThread,
-          this,
-          file_paths, reinterpret_cast<void*>(NULL)));
+  GetLocalPathsOnFileThreadAndRunCallbackOnUIThread(
+      file_paths,
+      base::Bind(&RemoveMountFunction::GetLocalPathsResponseOnUIThread, this));
   return true;
 }
 
 void RemoveMountFunction::GetLocalPathsResponseOnUIThread(
-    const FilePathList& files, void* context) {
+    const FilePathList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!context);
 
   if (files.size() != 1) {
     SendResponse(false);
     return;
   }
 #ifdef OS_CHROMEOS
-  chromeos::CrosLibrary::Get()->GetMountLibrary()->UnmountPath(
-      files[0].value().c_str());
+  chromeos::disks::DiskMountManager::GetInstance()->UnmountPath(
+      files[0].value());
 #endif
 
   SendResponse(true);
 }
 
 GetMountPointsFunction::GetMountPointsFunction() {
 }
 
 GetMountPointsFunction::~GetMountPointsFunction() {
 }
 
 bool GetMountPointsFunction::RunImpl() {
   if (args_->GetSize())
     return false;
 
   base::ListValue *mounts = new base::ListValue();
   result_.reset(mounts);
 
 #ifdef OS_CHROMEOS
-  chromeos::MountLibrary *mount_lib =
-      chromeos::CrosLibrary::Get()->GetMountLibrary();
-  chromeos::MountLibrary::MountPointMap mount_points =
-      mount_lib->mount_points();
+  chromeos::disks::DiskMountManager* disk_mount_manager =
+      chromeos::disks::DiskMountManager::GetInstance();
+  chromeos::disks::DiskMountManager::MountPointMap mount_points =
+      disk_mount_manager->mount_points();
 
-  for (chromeos::MountLibrary::MountPointMap::const_iterator it =
+  for (chromeos::disks::DiskMountManager::MountPointMap::const_iterator it =
            mount_points.begin();
        it != mount_points.end();
        ++it) {
     mounts->Append(MountPointToValue(profile_, it->second));
   }
 #endif
 
   SendResponse(true);
   return true;
 }
 
 GetSizeStatsFunction::GetSizeStatsFunction() {
 }
 
 GetSizeStatsFunction::~GetSizeStatsFunction() {
 }
 
 bool GetSizeStatsFunction::RunImpl() {
   if (args_->GetSize() != 1) {
     return false;
   }
 
   std::string mount_url;
   if (!args_->GetString(0, &mount_url))
     return false;
 
   UrlList mount_paths;
   mount_paths.push_back(GURL(mount_url));
 
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(
-          &GetSizeStatsFunction::GetLocalPathsOnFileThread,
-          this,
-          mount_paths, reinterpret_cast<void*>(NULL)));
+  GetLocalPathsOnFileThreadAndRunCallbackOnUIThread(
+      mount_paths,
+      base::Bind(&GetSizeStatsFunction::GetLocalPathsResponseOnUIThread, this));
   return true;
 }
 
 void GetSizeStatsFunction::GetLocalPathsResponseOnUIThread(
-    const FilePathList& files, void* context) {
+    const FilePathList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (files.size() != 1) {
     SendResponse(false);
     return;
   }
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(
           &GetSizeStatsFunction::CallGetSizeStatsOnFileThread,
           this,
-          files[0].value().c_str()));
+          files[0].value()));
 }
 
 void GetSizeStatsFunction::CallGetSizeStatsOnFileThread(
-    const char* mount_path) {
+    const std::string& mount_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   size_t total_size_kb = 0;
   size_t remaining_size_kb = 0;
 #ifdef OS_CHROMEOS
-  chromeos::CrosLibrary::Get()->GetMountLibrary()->GetSizeStatsOnFileThread(
-      mount_path, &total_size_kb, &remaining_size_kb);
+  chromeos::disks::DiskMountManager::GetInstance()->
+      GetSizeStatsOnFileThread(mount_path, &total_size_kb, &remaining_size_kb);
 #endif
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &GetSizeStatsFunction::GetSizeStatsCallbackOnUIThread,
           this,
           mount_path, total_size_kb, remaining_size_kb));
 }
 
 void GetSizeStatsFunction::GetSizeStatsCallbackOnUIThread(
-    const char* mount_path, size_t total_size_kb, size_t remaining_size_kb) {
+    const std::string&  mount_path,
+    size_t total_size_kb,
+    size_t remaining_size_kb) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::DictionaryValue* sizes = new base::DictionaryValue();
   result_.reset(sizes);
 
   sizes->SetInteger("totalSizeKB", total_size_kb);
   sizes->SetInteger("remainingSizeKB", remaining_size_kb);
 
   SendResponse(true);
 }
@@ skipping 11 matching lines @@
 
   std::string volume_file_url;
   if (!args_->GetString(0, &volume_file_url)) {
     NOTREACHED();
     return false;
   }
 
   UrlList file_paths;
   file_paths.push_back(GURL(volume_file_url));
 
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(
-          &FormatDeviceFunction::GetLocalPathsOnFileThread,
-          this,
-          file_paths, reinterpret_cast<void*>(NULL)));
+  GetLocalPathsOnFileThreadAndRunCallbackOnUIThread(
+      file_paths,
+      base::Bind(&FormatDeviceFunction::GetLocalPathsResponseOnUIThread, this));
   return true;
 }
 
 void FormatDeviceFunction::GetLocalPathsResponseOnUIThread(
-    const FilePathList& files, void* context) {
+    const FilePathList& files) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (files.size() != 1) {
     SendResponse(false);
     return;
   }
 
 #ifdef OS_CHROMEOS
-  chromeos::CrosLibrary::Get()->GetMountLibrary()->FormatMountedDevice(
-      files[0].value().c_str());
+  chromeos::disks::DiskMountManager::GetInstance()->FormatMountedDevice(
+      files[0].value());
 #endif
 
   SendResponse(true);
 }
 
 GetVolumeMetadataFunction::GetVolumeMetadataFunction() {
 }
 
 GetVolumeMetadataFunction::~GetVolumeMetadataFunction() {
 }
 
 bool GetVolumeMetadataFunction::RunImpl() {
   if (args_->GetSize() != 1) {
     error_ = "Invalid argument count";
     return false;
   }
 
   std::string volume_device_path;
   if (!args_->GetString(0, &volume_device_path)) {
     NOTREACHED();
   }
 
 #ifdef OS_CHROMEOS
-  chromeos::MountLibrary* mount_lib =
-      chromeos::CrosLibrary::Get()->GetMountLibrary();
-  chromeos::MountLibrary::DiskMap::const_iterator volume_it =
-      mount_lib->disks().find(volume_device_path);
+  chromeos::disks::DiskMountManager* disk_mount_manager =
+      chromeos::disks::DiskMountManager::GetInstance();
+  chromeos::disks::DiskMountManager::DiskMap::const_iterator volume_it =
+      disk_mount_manager->disks().find(volume_device_path);
 
-  if (volume_it != mount_lib->disks().end() &&
+  if (volume_it != disk_mount_manager->disks().end() &&
       !volume_it->second->is_hidden()) {
-    chromeos::MountLibrary::Disk* volume = volume_it->second;
+    chromeos::disks::DiskMountManager::Disk* volume = volume_it->second;
     DictionaryValue* volume_info = new DictionaryValue();
     result_.reset(volume_info);
     // Localising mount path.
     std::string mount_path;
     if (!volume->mount_path().empty()) {
       FilePath relative_mount_path;
       FileManagerUtil::ConvertFileToRelativeFileSystemPath(profile_,
           FilePath(volume->mount_path()), &relative_mount_path);
       mount_path = relative_mount_path.value();
     }
     volume_info->SetString("devicePath", volume->device_path());
     volume_info->SetString("mountPath", mount_path);
     volume_info->SetString("systemPath", volume->system_path());
     volume_info->SetString("filePath", volume->file_path());
     volume_info->SetString("deviceLabel", volume->device_label());
     volume_info->SetString("driveLabel", volume->drive_label());
     volume_info->SetString("deviceType",
         DeviceTypeToString(volume->device_type()));
-    volume_info->SetInteger("totalSize", volume->total_size());
+    volume_info->SetInteger("totalSize", volume->total_size_in_bytes());
     volume_info->SetBoolean("isParent", volume->is_parent());
     volume_info->SetBoolean("isReadOnly", volume->is_read_only());
     volume_info->SetBoolean("hasMedia", volume->has_media());
     volume_info->SetBoolean("isOnBootDevice", volume->on_boot_device());
 
     return true;
   }
 #endif
   error_ = kVolumeDevicePathNotFound;
   return false;
@@ skipping 184 matching lines @@
       l10n_util::GetStringUTF16(IDS_CERT_MANAGER_VIEW_CERT_BUTTON));
   dict->SetString("PLAY_MEDIA",
       l10n_util::GetStringUTF16(IDS_CONTENT_CONTEXT_PLAY));
 #if defined(OS_CHROMEOS)
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnablePhotoEditor))
     dict->SetString("ENABLE_PHOTO_EDITOR", "true");
 #endif
 
   return true;
 }