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

chrome/browser/chromeos/dbus/cros_disks_client.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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/dbus/cros_disks_client.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "chrome/browser/chromeos/system/runtime_environment.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_proxy.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
 const char* kDefaultMountOptions[] = {
   "rw",
   "nodev",
   "noexec",
   "nosuid",
 };
 
 const char* kDefaultUnmountOptions[] = {
   "force",
 };
 
-// Returns the device type from the given arguments.
-DeviceType GetDeviceType(bool is_optical, bool is_rotational) {
-  if (is_optical)
-    return OPTICAL;
-  if (is_rotational)
-    return HDD;
-  return FLASH;
+// Checks if retrieved media type is in boundaries of DeviceMediaType.
+bool IsValidMediaType(uint32 type) {
+  return type < static_cast<uint32>(cros_disks::DEVICE_MEDIA_NUM_VALUES);
+}
+
+
+// Translates enum used in cros-disks to enum used in Chrome.
+// Note that we could just do static_cast, but this is less sensitive to
+// changes in cros-disks.
+DeviceType DeviceMediaTypeToDeviceType(uint32 media_type_uint32) {
+  if (!IsValidMediaType(media_type_uint32))
+    return DEVICE_TYPE_UNKNOWN;
+
+  cros_disks::DeviceMediaType media_type =
+      cros_disks::DeviceMediaType(media_type_uint32);
+
+  switch (media_type) {
+    case(cros_disks::DEVICE_MEDIA_UNKNOWN):
+      return DEVICE_TYPE_UNKNOWN;
+    case(cros_disks::DEVICE_MEDIA_USB):
+      return DEVICE_TYPE_USB;
+    case(cros_disks::DEVICE_MEDIA_SD):
+      return DEVICE_TYPE_SD;
+    case(cros_disks::DEVICE_MEDIA_OPTICAL_DISC):
+      return DEVICE_TYPE_OPTICAL_DISC;
+    case(cros_disks::DEVICE_MEDIA_MOBILE):
+      return DEVICE_TYPE_MOBILE;
+    default:
+      return DEVICE_TYPE_UNKNOWN;
+  }
 }
 
 // Pops a bool value when |reader| is not NULL.
 // Returns true when a value is popped, false otherwise.
 bool MaybePopBool(dbus::MessageReader* reader, bool* value) {
   if (!reader)
     return false;
   return reader->PopBool(value);
 }
 
 // Pops a string value when |reader| is not NULL.
 // Returns true when a value is popped, false otherwise.
 bool MaybePopString(dbus::MessageReader* reader, std::string* value) {
   if (!reader)
     return false;
   return reader->PopString(value);
 }
 
+// Pops a uint32 value when |reader| is not NULL.
+// Returns true when a value is popped, false otherwise.
+bool MaybePopUint32(dbus::MessageReader* reader, uint32* value) {
+  if (!reader)
+    return false;
+
+  return reader->PopUint32(value);
+}
+
 // Pops a uint64 value when |reader| is not NULL.
 // Returns true when a value is popped, false otherwise.
 bool MaybePopUint64(dbus::MessageReader* reader, uint64* value) {
   if (!reader)
     return false;
   return reader->PopUint64(value);
 }
 
 // Pops an array of strings when |reader| is not NULL.
 // Returns true when an array is popped, false otherwise.
@@ skipping 303 matching lines @@
 } // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // DiskInfo
 
 DiskInfo::DiskInfo(const std::string& device_path, dbus::Response* response)
     : device_path_(device_path),
       is_drive_(false),
       has_media_(false),
       on_boot_device_(false),
-      device_type_(UNDEFINED),
+      device_type_(DEVICE_TYPE_UNKNOWN),
       total_size_in_bytes_(0),
       is_read_only_(false),
       is_hidden_(true) {
   InitializeFromResponse(response);
 }
 
 DiskInfo::~DiskInfo() {
 }
 
 // Initialize |this| from |response| given by the cros-disks service.
@@ skipping 106 matching lines @@
   MaybePopBool(properties[cros_disks::kDevicePresentationHide], &is_hidden_);
   MaybePopBool(properties[cros_disks::kDeviceIsMediaAvailable], &has_media_);
   MaybePopBool(properties[cros_disks::kDeviceIsOnBootDevice],
                &on_boot_device_);
   MaybePopString(properties[cros_disks::kNativePath], &system_path_);
   MaybePopString(properties[cros_disks::kDeviceFile], &file_path_);
   MaybePopString(properties[cros_disks::kDriveModel], &drive_model_);
   MaybePopString(properties[cros_disks::kIdLabel], &label_);
   MaybePopUint64(properties[cros_disks::kDeviceSize], &total_size_in_bytes_);
 
+  uint32 media_type_uint32 = 0;
+  if (MaybePopUint32(properties[cros_disks::kDeviceMediaType],
+                     &media_type_uint32)) {
+    device_type_ = DeviceMediaTypeToDeviceType(media_type_uint32);
+  }
+
   std::vector<std::string> mount_paths;
   if (MaybePopArrayOfStrings(properties[cros_disks::kDeviceMountPaths],
                              &mount_paths) && !mount_paths.empty())
     mount_path_ = mount_paths[0];
-
-  bool is_rotational = false;
-  bool is_optical = false;
-  if (MaybePopBool(properties[cros_disks::kDriveIsRotational],
-                   &is_rotational) &&
-      MaybePopBool(properties[cros_disks::kDeviceIsOpticalDisc],
-                   &is_optical))
-    device_type_ = GetDeviceType(is_optical, is_rotational);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // CrosDisksClient
 
 CrosDisksClient::CrosDisksClient() {}
 
 CrosDisksClient::~CrosDisksClient() {}
 
 // static
 CrosDisksClient* CrosDisksClient::Create(dbus::Bus* bus) {
   if (system::runtime_environment::IsRunningOnChromeOS())
     return new CrosDisksClientImpl(bus);
   else
     return new CrosDisksClientStubImpl();
 }
 
 }  // namespace chromeos