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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
// 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.
#include "content/browser/bluetooth/bluetooth_metrics.h"
#include <stdint.h>
#include <algorithm>
#include <map>
#include <set>
#include <unordered_set>
#include "base/hash/hash.h"
#include "base/metrics/histogram_functions.h"
#include "base/metrics/histogram_macros.h"
#include "device/bluetooth/public/cpp/bluetooth_uuid.h"
using device::BluetoothUUID;
namespace {
// Generates a hash from a canonical UUID string suitable for
// base::UmaHistogramSparse(positive int).
//
// Hash values can be produced manually using tool: bluetooth_metrics_hash.
int HashUUID(const std::string& canonical_uuid) {
DCHECK(canonical_uuid.size() == 36) << "HashUUID requires 128 bit UUID "
"strings in canonical format to "
"ensure consistent hash results.";
// TODO(crbug.com/41194594): Other than verifying that |uuid| contains a
// value, this logic should be migrated to a dedicated histogram macro for
// hashed strings.
uint32_t data = base::PersistentHash(canonical_uuid);
// Strip off the sign bit to make the hash look nicer.
return static_cast<int>(data & 0x7fffffff);
}
int HashUUID(const std::optional<BluetoothUUID>& uuid) {
return uuid ? HashUUID(uuid->canonical_value()) : 0;
}
} // namespace
namespace content {
// General
// requestDevice()
void RecordRequestDeviceOptions(
const blink::mojom::WebBluetoothRequestDeviceOptionsPtr& options) {
std::unordered_set<std::string> union_of_services;
for (const BluetoothUUID& service : options->optional_services) {
union_of_services.insert(service.canonical_value());
}
if (options->filters) {
for (const auto& filter : options->filters.value()) {
if (!filter->services) {
continue;
}
for (const BluetoothUUID& service : filter->services.value()) {
union_of_services.insert(service.canonical_value());
}
}
}
for (const std::string& service : union_of_services) {
// TODO(ortuno): Use a macro to histogram strings.
// http://crbug.com/520284
base::UmaHistogramSparse(
"Bluetooth.Web.RequestDevice.UnionOfServices.Services",
HashUUID(service));
}
}
// GATTServer.Connect
void RecordConnectGATTOutcome(UMAConnectGATTOutcome outcome) {
UMA_HISTOGRAM_ENUMERATION("Bluetooth.Web.ConnectGATT.Outcome", outcome);
}
void RecordConnectGATTOutcome(CacheQueryOutcome outcome) {
DCHECK_EQ(outcome, CacheQueryOutcome::kNoDevice);
RecordConnectGATTOutcome(UMAConnectGATTOutcome::kNoDevice);
}
// getPrimaryService & getPrimaryServices
void RecordGetPrimaryServicesServices(
blink::mojom::WebBluetoothGATTQueryQuantity quantity,
const std::optional<BluetoothUUID>& service) {
// TODO(ortuno): Use a macro to histogram strings.
// http://crbug.com/520284
switch (quantity) {
case blink::mojom::WebBluetoothGATTQueryQuantity::SINGLE:
base::UmaHistogramSparse("Bluetooth.Web.GetPrimaryService.Services",
HashUUID(service));
return;
case blink::mojom::WebBluetoothGATTQueryQuantity::MULTIPLE:
base::UmaHistogramSparse("Bluetooth.Web.GetPrimaryServices.Services",
HashUUID(service));
return;
}
}
void RecordGetCharacteristicsCharacteristic(
blink::mojom::WebBluetoothGATTQueryQuantity quantity,
const std::optional<BluetoothUUID>& characteristic) {
switch (quantity) {
case blink::mojom::WebBluetoothGATTQueryQuantity::SINGLE:
base::UmaHistogramSparse("Bluetooth.Web.GetCharacteristic.Characteristic",
HashUUID(characteristic));
return;
case blink::mojom::WebBluetoothGATTQueryQuantity::MULTIPLE:
base::UmaHistogramSparse(
"Bluetooth.Web.GetCharacteristics.Characteristic",
HashUUID(characteristic));
return;
}
}
// GATT Operations
void RecordGATTOperationOutcome(UMAGATTOperation operation,
UMAGATTOperationOutcome outcome) {
switch (operation) {
case UMAGATTOperation::kCharacteristicRead:
RecordCharacteristicReadValueOutcome(outcome);
return;
case UMAGATTOperation::kCharacteristicWrite:
RecordCharacteristicWriteValueOutcome(outcome);
return;
case UMAGATTOperation::kStartNotifications:
RecordStartNotificationsOutcome(outcome);
return;
case UMAGATTOperation::kDescriptorReadObsolete:
case UMAGATTOperation::kDescriptorWriteObsolete:
return;
}
}
static UMAGATTOperationOutcome TranslateCacheQueryOutcomeToGATTOperationOutcome(
CacheQueryOutcome outcome) {
switch (outcome) {
case CacheQueryOutcome::kSuccess:
case CacheQueryOutcome::kBadRenderer:
// No need to record a success or renderer crash.
NOTREACHED();
case CacheQueryOutcome::kNoDevice:
return UMAGATTOperationOutcome::kNoDevice;
case CacheQueryOutcome::kNoService:
return UMAGATTOperationOutcome::kNoService;
case CacheQueryOutcome::kNoCharacteristic:
return UMAGATTOperationOutcome::kNoCharacteristic;
case CacheQueryOutcome::kNoDescriptor:
return UMAGATTOperationOutcome::kNoDescriptor;
}
}
// Characteristic.readValue
void RecordCharacteristicReadValueOutcome(UMAGATTOperationOutcome outcome) {
base::UmaHistogramEnumeration(
"Bluetooth.Web.Characteristic.ReadValue.Outcome", outcome);
}
void RecordCharacteristicReadValueOutcome(CacheQueryOutcome outcome) {
RecordCharacteristicReadValueOutcome(
TranslateCacheQueryOutcomeToGATTOperationOutcome(outcome));
}
// Characteristic.writeValue
void RecordCharacteristicWriteValueOutcome(UMAGATTOperationOutcome outcome) {
base::UmaHistogramEnumeration(
"Bluetooth.Web.Characteristic.WriteValue.Outcome", outcome);
}
void RecordCharacteristicWriteValueOutcome(CacheQueryOutcome outcome) {
RecordCharacteristicWriteValueOutcome(
TranslateCacheQueryOutcomeToGATTOperationOutcome(outcome));
}
// Characteristic.startNotifications
void RecordStartNotificationsOutcome(UMAGATTOperationOutcome outcome) {
base::UmaHistogramEnumeration(
"Bluetooth.Web.Characteristic.StartNotifications.Outcome", outcome);
}
void RecordStartNotificationsOutcome(CacheQueryOutcome outcome) {
RecordStartNotificationsOutcome(
TranslateCacheQueryOutcomeToGATTOperationOutcome(outcome));
}
void RecordRSSISignalStrength(int rssi) {
base::UmaHistogramSparse("Bluetooth.Web.RequestDevice.RSSISignalStrength",
rssi);
}
void RecordRSSISignalStrengthLevel(UMARSSISignalStrengthLevel level) {
UMA_HISTOGRAM_ENUMERATION(
"Bluetooth.Web.RequestDevice.RSSISignalStrengthLevel", level);
}
} // namespace content
|
