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 // TestPortableDeviceWatcherWin implementation. 6 7 #include "components/storage_monitor/test_portable_device_watcher_win.h" 8 9 #include <vector> 10 11 #include "base/strings/utf_string_conversions.h" 12 13 namespace storage_monitor { 14 15 namespace { 16 17 // Sample MTP device storage information. 18 const base::char16 kMTPDeviceFriendlyName[] = L"Camera V1.1"; 19 const base::char16 kStorageLabelA[] = L"Camera V1.1 (s10001)"; 20 const base::char16 kStorageLabelB[] = L"Camera V1.1 (s20001)"; 21 const base::char16 kStorageObjectIdA[] = L"s10001"; 22 const base::char16 kStorageObjectIdB[] = L"s20001"; 23 const char kStorageUniqueIdB[] = 24 "mtp:StorageSerial:SID-{s20001, S, 2238}:123123"; 25 26 // Returns the storage name of the device specified by |pnp_device_id|. 27 // |storage_object_id| specifies the string ID that uniquely identifies the 28 // object on the device. 29 base::string16 GetMTPStorageName(const base::string16& pnp_device_id, 30 const base::string16& storage_object_id) { 31 if (pnp_device_id == TestPortableDeviceWatcherWin::kMTPDeviceWithInvalidInfo) 32 return base::string16(); 33 34 if (storage_object_id == kStorageObjectIdA) 35 return kStorageLabelA; 36 return (storage_object_id == kStorageObjectIdB) ? 37 kStorageLabelB : base::string16(); 38 } 39 40 } // namespace 41 42 // TestPortableDeviceWatcherWin ------------------------------------------------ 43 44 // static 45 const base::char16 46 TestPortableDeviceWatcherWin::kMTPDeviceWithMultipleStorages[] = 47 L"\\?\\usb#vid_ff&pid_18#32&2&1#{ab33-1de4-f22e-1882-9724})"; 48 const base::char16 TestPortableDeviceWatcherWin::kMTPDeviceWithInvalidInfo[] = 49 L"\\?\\usb#vid_00&pid_00#0&2&1#{0000-0000-0000-0000-0000})"; 50 const base::char16 TestPortableDeviceWatcherWin::kMTPDeviceWithValidInfo[] = 51 L"\\?\\usb#vid_ff&pid_000f#32&2&1#{abcd-1234-ffde-1112-9172})"; 52 const char TestPortableDeviceWatcherWin::kStorageUniqueIdA[] = 53 "mtp:StorageSerial:SID-{s10001, D, 12378}:123123"; 54 55 TestPortableDeviceWatcherWin::TestPortableDeviceWatcherWin() 56 : use_dummy_mtp_storage_info_(false) { 57 } 58 59 TestPortableDeviceWatcherWin::~TestPortableDeviceWatcherWin() { 60 } 61 62 // static 63 std::string TestPortableDeviceWatcherWin::GetMTPStorageUniqueId( 64 const base::string16& pnp_device_id, 65 const base::string16& storage_object_id) { 66 if (storage_object_id == kStorageObjectIdA) 67 return TestPortableDeviceWatcherWin::kStorageUniqueIdA; 68 return (storage_object_id == kStorageObjectIdB) ? 69 kStorageUniqueIdB : std::string(); 70 } 71 72 // static 73 PortableDeviceWatcherWin::StorageObjectIDs 74 TestPortableDeviceWatcherWin::GetMTPStorageObjectIds( 75 const base::string16& pnp_device_id) { 76 PortableDeviceWatcherWin::StorageObjectIDs storage_object_ids; 77 storage_object_ids.push_back(kStorageObjectIdA); 78 if (pnp_device_id == kMTPDeviceWithMultipleStorages) 79 storage_object_ids.push_back(kStorageObjectIdB); 80 return storage_object_ids; 81 } 82 83 // static 84 void TestPortableDeviceWatcherWin::GetMTPStorageDetails( 85 const base::string16& pnp_device_id, 86 const base::string16& storage_object_id, 87 base::string16* device_location, 88 std::string* unique_id, 89 base::string16* name) { 90 std::string storage_unique_id = GetMTPStorageUniqueId(pnp_device_id, 91 storage_object_id); 92 if (device_location) 93 *device_location = base::UTF8ToUTF16("\\\\" + storage_unique_id); 94 95 if (unique_id) 96 *unique_id = storage_unique_id; 97 98 if (name) 99 *name = GetMTPStorageName(pnp_device_id, storage_object_id); 100 } 101 102 // static 103 PortableDeviceWatcherWin::StorageObjects 104 TestPortableDeviceWatcherWin::GetDeviceStorageObjects( 105 const base::string16& pnp_device_id) { 106 PortableDeviceWatcherWin::StorageObjects storage_objects; 107 PortableDeviceWatcherWin::StorageObjectIDs storage_object_ids = 108 GetMTPStorageObjectIds(pnp_device_id); 109 for (PortableDeviceWatcherWin::StorageObjectIDs::const_iterator it = 110 storage_object_ids.begin(); 111 it != storage_object_ids.end(); ++it) { 112 storage_objects.push_back(DeviceStorageObject( 113 *it, GetMTPStorageUniqueId(pnp_device_id, *it))); 114 } 115 return storage_objects; 116 } 117 118 void TestPortableDeviceWatcherWin::EnumerateAttachedDevices() { 119 } 120 121 void TestPortableDeviceWatcherWin::HandleDeviceAttachEvent( 122 const base::string16& pnp_device_id) { 123 DeviceDetails device_details = { 124 (pnp_device_id != kMTPDeviceWithInvalidInfo) ? 125 kMTPDeviceFriendlyName : base::string16(), 126 pnp_device_id, 127 GetDeviceStorageObjects(pnp_device_id) 128 }; 129 OnDidHandleDeviceAttachEvent(&device_details, true); 130 } 131 132 bool TestPortableDeviceWatcherWin::GetMTPStorageInfoFromDeviceId( 133 const std::string& storage_device_id, 134 base::string16* device_location, 135 base::string16* storage_object_id) const { 136 DCHECK(!storage_device_id.empty()); 137 if (use_dummy_mtp_storage_info_) { 138 if (storage_device_id == TestPortableDeviceWatcherWin::kStorageUniqueIdA) { 139 *device_location = kMTPDeviceWithValidInfo; 140 *storage_object_id = kStorageObjectIdA; 141 return true; 142 } 143 return false; 144 } 145 return PortableDeviceWatcherWin::GetMTPStorageInfoFromDeviceId( 146 storage_device_id, device_location, storage_object_id); 147 } 148 149 } // namespace storage_monitor 150