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
13namespace storage_monitor {
14
15namespace {
16
17// Sample MTP device storage information.
18const base::char16 kMTPDeviceFriendlyName[] = L"Camera V1.1";
19const base::char16 kStorageLabelA[] = L"Camera V1.1 (s10001)";
20const base::char16 kStorageLabelB[] = L"Camera V1.1 (s20001)";
21const base::char16 kStorageObjectIdA[] = L"s10001";
22const base::char16 kStorageObjectIdB[] = L"s20001";
23const 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.
29base::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
45const base::char16
46TestPortableDeviceWatcherWin::kMTPDeviceWithMultipleStorages[] =
47    L"\\?\\usb#vid_ff&pid_18#32&2&1#{ab33-1de4-f22e-1882-9724})";
48const base::char16 TestPortableDeviceWatcherWin::kMTPDeviceWithInvalidInfo[] =
49    L"\\?\\usb#vid_00&pid_00#0&2&1#{0000-0000-0000-0000-0000})";
50const base::char16 TestPortableDeviceWatcherWin::kMTPDeviceWithValidInfo[] =
51    L"\\?\\usb#vid_ff&pid_000f#32&2&1#{abcd-1234-ffde-1112-9172})";
52const char TestPortableDeviceWatcherWin::kStorageUniqueIdA[] =
53    "mtp:StorageSerial:SID-{s10001, D, 12378}:123123";
54
55TestPortableDeviceWatcherWin::TestPortableDeviceWatcherWin()
56    : use_dummy_mtp_storage_info_(false) {
57}
58
59TestPortableDeviceWatcherWin::~TestPortableDeviceWatcherWin() {
60}
61
62// static
63std::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
73PortableDeviceWatcherWin::StorageObjectIDs
74TestPortableDeviceWatcherWin::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
84void 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
103PortableDeviceWatcherWin::StorageObjects
104TestPortableDeviceWatcherWin::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
118void TestPortableDeviceWatcherWin::EnumerateAttachedDevices() {
119}
120
121void 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
132bool 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