1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_USB_USB_CHOOSER_CONTEXT_H_
#define CHROME_BROWSER_USB_USB_CHOOSER_CONTEXT_H_
#include <map>
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>
#include "base/containers/queue.h"
#include "base/observer_list.h"
#include "base/values.h"
#include "build/build_config.h"
#include "chrome/browser/usb/usb_policy_allowed_devices.h"
#include "components/permissions/object_permission_context_base.h"
#include "mojo/public/cpp/bindings/associated_receiver.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "services/device/public/mojom/usb_manager.mojom.h"
#include "services/device/public/mojom/usb_manager_client.mojom.h"
#include "url/origin.h"
class Profile;
class UsbChooserContext : public permissions::ObjectPermissionContextBase,
public device::mojom::UsbDeviceManagerClient {
public:
explicit UsbChooserContext(Profile* profile);
UsbChooserContext(const UsbChooserContext&) = delete;
UsbChooserContext& operator=(const UsbChooserContext&) = delete;
~UsbChooserContext() override;
// This observer can be used to be notified of changes to USB devices that are
// connected.
class DeviceObserver : public base::CheckedObserver {
public:
virtual void OnDeviceAdded(const device::mojom::UsbDeviceInfo&);
virtual void OnDeviceRemoved(const device::mojom::UsbDeviceInfo&);
virtual void OnDeviceManagerConnectionError();
// Called when the BrowserContext is shutting down. Observers must remove
// themselves before returning.
virtual void OnBrowserContextShutdown() = 0;
};
static base::Value::Dict DeviceInfoToValue(
const device::mojom::UsbDeviceInfo& device_info);
// ObjectPermissionContextBase:
std::vector<std::unique_ptr<Object>> GetGrantedObjects(
const url::Origin& origin) override;
std::vector<std::unique_ptr<Object>> GetAllGrantedObjects() override;
void RevokeObjectPermission(const url::Origin& origin,
const base::Value::Dict& object) override;
std::string GetKeyForObject(const base::Value::Dict& object) override;
bool IsValidObject(const base::Value::Dict& object) override;
std::u16string GetObjectDisplayName(const base::Value::Dict& object) override;
// Grants |origin| access to the USB device.
void GrantDevicePermission(const url::Origin& origin,
const device::mojom::UsbDeviceInfo& device_info);
// Checks if |origin| has access to a device with |device_info|.
bool HasDevicePermission(const url::Origin& origin,
const device::mojom::UsbDeviceInfo& device_info);
// Revokes |origin| access to the USB device ordered by website.
void RevokeDevicePermissionWebInitiated(
const url::Origin& origin,
const device::mojom::UsbDeviceInfo& device);
void AddObserver(DeviceObserver* observer);
void RemoveObserver(DeviceObserver* observer);
// Forward UsbDeviceManager methods.
void GetDevices(device::mojom::UsbDeviceManager::GetDevicesCallback callback);
void GetDevice(
const std::string& guid,
base::span<const uint8_t> blocked_interface_classes,
mojo::PendingReceiver<device::mojom::UsbDevice> device_receiver,
mojo::PendingRemote<device::mojom::UsbDeviceClient> device_client);
#if BUILDFLAG(IS_ANDROID)
void RefreshDeviceInfo(
const std::string& guid,
device::mojom::UsbDeviceManager::RefreshDeviceInfoCallback callback);
#endif
// This method should only be called when you are sure that |devices_| has
// been initialized. It will return nullptr if the guid cannot be found.
const device::mojom::UsbDeviceInfo* GetDeviceInfo(const std::string& guid);
base::WeakPtr<UsbChooserContext> AsWeakPtr();
void SetDeviceManagerForTesting(
mojo::PendingRemote<device::mojom::UsbDeviceManager> fake_device_manager);
void InitDeviceList(std::vector<::device::mojom::UsbDeviceInfoPtr> devices);
const UsbPolicyAllowedDevices& usb_policy_allowed_devices() {
return *usb_policy_allowed_devices_;
}
// KeyedService:
void Shutdown() override;
private:
// device::mojom::UsbDeviceManagerClient implementation.
void OnDeviceAdded(device::mojom::UsbDeviceInfoPtr device_info) override;
void OnDeviceRemoved(device::mojom::UsbDeviceInfoPtr device_info) override;
void RevokeObjectPermissionInternal(const url::Origin& origin,
const base::Value::Dict& object,
bool revoked_by_website);
void OnDeviceManagerConnectionError();
void EnsureConnectionWithDeviceManager();
void SetUpDeviceManagerConnection();
#if BUILDFLAG(IS_ANDROID)
void OnDeviceInfoRefreshed(
device::mojom::UsbDeviceManager::RefreshDeviceInfoCallback callback,
device::mojom::UsbDeviceInfoPtr device_info);
#endif
bool is_incognito_;
bool is_initialized_ = false;
base::queue<device::mojom::UsbDeviceManager::GetDevicesCallback>
pending_get_devices_requests_;
std::map<url::Origin, std::set<std::string>> ephemeral_devices_;
std::map<std::string, device::mojom::UsbDeviceInfoPtr> devices_;
std::unique_ptr<UsbPolicyAllowedDevices> usb_policy_allowed_devices_;
// Connection to |device_manager_instance_|.
mojo::Remote<device::mojom::UsbDeviceManager> device_manager_;
mojo::AssociatedReceiver<device::mojom::UsbDeviceManagerClient>
client_receiver_{this};
base::ObserverList<DeviceObserver> device_observer_list_;
base::WeakPtrFactory<UsbChooserContext> weak_factory_{this};
};
#endif // CHROME_BROWSER_USB_USB_CHOOSER_CONTEXT_H_
|
