components/storage_monitor/storage_info.cc

   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 #include "components/storage_monitor/storage_info.h"
   6
   7 #include "base/logging.h"
   8
   9 namespace {
  10
  11 // Prefix constants for different device id spaces.
  12 const char kRemovableMassStorageWithDCIMPrefix[] = "dcim:";
  13 const char kRemovableMassStorageNoDCIMPrefix[] = "nodcim:";
  14 const char kFixedMassStoragePrefix[] = "path:";
  15 const char kMtpPtpPrefix[] = "mtp:";
  16 const char kMacImageCapturePrefix[] = "ic:";
  17 const char kITunesPrefix[] = "itunes:";
  18 const char kPicasaPrefix[] = "picasa:";
  19 const char kIPhotoPrefix[] = "iphoto:";
  20
  21 }  // namespace
  22
  23 StorageInfo::StorageInfo() : total_size_in_bytes_(0) {
  24 }
  25
  26 StorageInfo::StorageInfo(const std::string& device_id_in,
  27                          const base::string16& device_name,
  28                          const base::FilePath::StringType& device_location,
  29                          const base::string16& label,
  30                          const base::string16& vendor,
  31                          const base::string16& model,
  32                          uint64 size_in_bytes)
  33     : device_id_(device_id_in),
  34       name_(device_name),
  35       location_(device_location),
  36       storage_label_(label),
  37       vendor_name_(vendor),
  38       model_name_(model),
  39       total_size_in_bytes_(size_in_bytes) {
  40 }
  41
  42 StorageInfo::~StorageInfo() {
  43 }
  44
  45 // static
  46 std::string StorageInfo::MakeDeviceId(Type type, const std::string& unique_id) {
  47   DCHECK(!unique_id.empty());
  48   switch (type) {
  49     case REMOVABLE_MASS_STORAGE_WITH_DCIM:
  50       return std::string(kRemovableMassStorageWithDCIMPrefix) + unique_id;
  51     case REMOVABLE_MASS_STORAGE_NO_DCIM:
  52       return std::string(kRemovableMassStorageNoDCIMPrefix) + unique_id;
  53     case FIXED_MASS_STORAGE:
  54       return std::string(kFixedMassStoragePrefix) + unique_id;
  55     case MTP_OR_PTP:
  56       return std::string(kMtpPtpPrefix) + unique_id;
  57     case MAC_IMAGE_CAPTURE:
  58       return std::string(kMacImageCapturePrefix) + unique_id;
  59     case ITUNES:
  60       return std::string(kITunesPrefix) + unique_id;
  61     case PICASA:
  62       return std::string(kPicasaPrefix) + unique_id;
  63     case IPHOTO:
  64       return std::string(kIPhotoPrefix) + unique_id;
  65   }
  66   NOTREACHED();
  67   return std::string();
  68 }
  69
  70 // static
  71 bool StorageInfo::CrackDeviceId(const std::string& device_id,
  72                                 Type* type, std::string* unique_id) {
  73   size_t prefix_length = device_id.find_first_of(':');
  74   std::string prefix = prefix_length != std::string::npos
  75                            ? device_id.substr(0, prefix_length + 1)
  76                            : std::string();
  77
  78   Type found_type;
  79   if (prefix == kRemovableMassStorageWithDCIMPrefix) {
  80     found_type = REMOVABLE_MASS_STORAGE_WITH_DCIM;
  81   } else if (prefix == kRemovableMassStorageNoDCIMPrefix) {
  82     found_type = REMOVABLE_MASS_STORAGE_NO_DCIM;
  83   } else if (prefix == kFixedMassStoragePrefix) {
  84     found_type = FIXED_MASS_STORAGE;
  85   } else if (prefix == kMtpPtpPrefix) {
  86     found_type = MTP_OR_PTP;
  87   } else if (prefix == kMacImageCapturePrefix) {
  88     found_type = MAC_IMAGE_CAPTURE;
  89   } else if (prefix == kITunesPrefix) {
  90     found_type = ITUNES;
  91   } else if (prefix == kPicasaPrefix) {
  92     found_type = PICASA;
  93   } else if (prefix == kIPhotoPrefix) {
  94     found_type = IPHOTO;
  95   } else {
  96     NOTREACHED();
  97     return false;
  98   }
  99   if (type)
 100     *type = found_type;
 101
 102   if (unique_id)
 103     *unique_id = device_id.substr(prefix_length + 1);
 104   return true;
 105 }
 106
 107 // static
 108 bool StorageInfo::IsMediaDevice(const std::string& device_id) {
 109   Type type;
 110   return CrackDeviceId(device_id, &type, NULL) &&
 111       (type == REMOVABLE_MASS_STORAGE_WITH_DCIM || type == MTP_OR_PTP ||
 112        type == MAC_IMAGE_CAPTURE);
 113 }
 114
 115 // static
 116 bool StorageInfo::IsRemovableDevice(const std::string& device_id) {
 117   Type type;
 118   return CrackDeviceId(device_id, &type, NULL) &&
 119          (type == REMOVABLE_MASS_STORAGE_WITH_DCIM ||
 120           type == REMOVABLE_MASS_STORAGE_NO_DCIM ||
 121           type == MTP_OR_PTP ||
 122           type == MAC_IMAGE_CAPTURE);
 123 }
 124
 125 // static
 126 bool StorageInfo::IsMassStorageDevice(const std::string& device_id) {
 127   Type type;
 128   return CrackDeviceId(device_id, &type, NULL) &&
 129          (type == REMOVABLE_MASS_STORAGE_WITH_DCIM ||
 130           type == REMOVABLE_MASS_STORAGE_NO_DCIM ||
 131           type == FIXED_MASS_STORAGE ||
 132           type == ITUNES ||
 133           type == IPHOTO ||
 134           type == PICASA);
 135 }
 136
 137 // static
 138 bool StorageInfo::IsITunesDevice(const std::string& device_id) {
 139   Type type;
 140   return CrackDeviceId(device_id, &type, NULL) && type == ITUNES;
 141 }
 142
 143 // static
 144 bool StorageInfo::IsIPhotoDevice(const std::string& device_id) {
 145   Type type;
 146   return CrackDeviceId(device_id, &type, NULL) && type == IPHOTO;
 147 }
 148
 149 // static
 150 bool StorageInfo::IsPicasaDevice(const std::string& device_id) {
 151   Type type;
 152   return CrackDeviceId(device_id, &type, NULL) && type == PICASA;
 153 }