[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.

[hashimoto, 2012/01/24 05:28:06]

Please fix copyright year (in all files).

[tbarzic, 2012/01/24 19:47:33]

Done.

 // 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;
+// 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(cros_disks::DeviceMediaType type) {
+  switch (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;
+  }
+}
+
+// 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) &&
+         type >= 0;

[hashimoto, 2012/01/24 05:28:06]

Since |type| is unsigned, type >= 0 does nothing here.
It may be removed.

[tbarzic, 2012/01/24 19:47:33]

Done.

+}
+
+// Pops unit32 value and converts it to DeviceMediaType when |reader| is not
+// NULL. Returns true iff value is popped and converted.
+bool MaybePopDeviceType(dbus::MessageReader* reader, DeviceType* type) {

[hashimoto, 2012/01/24 05:28:06]

Having MaybePopUint32 and doing something like 'device_type_ =
DeviceMediaTypeToDeviceType(media_type_uint32);' in InitializeFromResponse will
be more consistent with other MaybePopXX functions.

[tbarzic, 2012/01/24 19:47:33]

Done.

+  if (!reader)
+    return false;
+
+  uint32 media_type_uint32 = 0;
+  bool success = reader->PopUint32(&media_type_uint32);
+
+  if (!success || !IsValidMediaType(media_type_uint32))
+    return false;
+
+  *type = DeviceMediaTypeToDeviceType(
+              cros_disks::DeviceMediaType(media_type_uint32));
+  return success;
 }
 
 // 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);
 }
 
@@ skipping 321 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 105 matching lines @@
   MaybePopBool(properties[cros_disks::kDeviceIsReadOnly], &is_read_only_);
   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_);
+  MaybePopDeviceType(properties[cros_disks::kDeviceMediaType], &device_type_);
 
   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