components/storage_monitor/storage_info.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef COMPONENTS_STORAGE_MONITOR_STORAGE_INFO_H_
   6 #define COMPONENTS_STORAGE_MONITOR_STORAGE_INFO_H_
   7
   8 #include "base/files/file_path.h"
   9 #include "base/strings/string16.h"
  10
  11 namespace storage_monitor {
  12
  13 class StorageInfo {
  14  public:
  15   enum Type {
  16     // A removable mass storage device with a DCIM directory.
  17     REMOVABLE_MASS_STORAGE_WITH_DCIM,
  18     // A removable mass storage device without a DCIM directory.
  19     REMOVABLE_MASS_STORAGE_NO_DCIM,
  20     // A fixed mass storage device.
  21     FIXED_MASS_STORAGE,
  22     // A MTP or PTP device.
  23     MTP_OR_PTP,
  24     // A Mac ImageCapture device.
  25     MAC_IMAGE_CAPTURE,
  26     // An iTunes library.
  27     ITUNES,
  28     // A Picasa database.
  29     PICASA,
  30     // An iPhoto library.
  31     IPHOTO,
  32   };
  33
  34   StorageInfo();
  35   // Note: |device_id_in| should be constructed with MakeDeviceId.
  36   StorageInfo(const std::string& device_id_in,
  37               const base::FilePath::StringType& device_location,
  38               const base::string16& label,
  39               const base::string16& vendor,
  40               const base::string16& model,
  41               uint64 size_in_bytes);
  42   ~StorageInfo();
  43
  44   // Returns a device id given properties of the device. A prefix dependent on
  45   // |type| is added so |unique_id| need only be unique within the given type.
  46   // Returns an empty string if an invalid type is passed in.
  47   static std::string MakeDeviceId(Type type, const std::string& unique_id);
  48
  49   // Extracts the device |type| and |unique_id| from |device_id|. Returns false
  50   // if the device_id isn't properly formatted.
  51   static bool CrackDeviceId(const std::string& device_id,
  52                             Type* type, std::string* unique_id);
  53
  54   // Looks inside |device_id| to determine if it is a media device
  55   // (type is REMOVABLE_MASS_STORAGE_WITH_DCIM or MTP_OR_PTP).
  56   static bool IsMediaDevice(const std::string& device_id);
  57
  58   // Looks inside |device_id| to determine if it is a media device
  59   // (type isn't FIXED_MASS_STORAGE).
  60   static bool IsRemovableDevice(const std::string& device_id);
  61
  62   // Looks inside |device_id| to determine if it is a mass storage device
  63   // (type isn't MTP_OR_PTP).
  64   static bool IsMassStorageDevice(const std::string& device_id);
  65
  66   static bool IsITunesDevice(const std::string& device_id);
  67
  68   static bool IsPicasaDevice(const std::string& device_id);
  69
  70   static bool IsIPhotoDevice(const std::string& device_id);
  71
  72   static bool IsMTPDevice(const std::string& device_id);
  73
  74   // Get the display name for the removable device represented by this
  75   // StorageInfo. Include the size for removable devices if |with_size| is true.
  76   base::string16 GetDisplayName(bool with_size) const;
  77
  78   // Same as GetDisplayName(), but may be overridden by |override_display_name|.
  79   base::string16 GetDisplayNameWithOverride(
  80       const base::string16& override_display_name, bool with_size) const;
  81
  82   const std::string& device_id() const { return device_id_; }
  83   const base::FilePath::StringType& location() const { return location_; }
  84   const base::string16& storage_label() const { return storage_label_; }
  85   const base::string16& vendor_name() const { return vendor_name_; }
  86   const base::string16& model_name() const { return model_name_; }
  87   uint64 total_size_in_bytes() const { return total_size_in_bytes_; }
  88
  89   void set_device_id(const std::string& device_id) { device_id_ = device_id; }
  90   void set_location(const base::FilePath::StringType& location) {
  91     location_ = location;
  92   }
  93
  94  private:
  95   // Unique device id - persists between device attachments.
  96   // This is the string that should be used as the label for a particular
  97   // storage device when interacting with the API. Clients should treat
  98   // this as an opaque string.
  99   std::string device_id_;
 100
 101   // Current attached removable storage device location.
 102   base::FilePath::StringType location_;
 103
 104   // Label given to this storage device by the user.
 105   // May be empty if not found or the device is unlabeled.
 106   base::string16 storage_label_;
 107
 108   // Vendor name for the removable device. (Human readable)
 109   // May be empty if not collected.
 110   base::string16 vendor_name_;
 111
 112   // Model name for the removable device. (Human readable)
 113   // May be empty if not collected.
 114   base::string16 model_name_;
 115
 116   // Size of the removable device in bytes.
 117   // Zero if not collected or unknown.
 118   uint64 total_size_in_bytes_;
 119 };
 120
 121 }  // namespace storage_monitor
 122
 123 #endif  // COMPONENTS_STORAGE_MONITOR_STORAGE_INFO_H_