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
|
// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/modules/shapedetection/barcode_detector_statics.h"
#include "third_party/blink/public/common/privacy_budget/identifiability_metric_builder.h"
#include "third_party/blink/public/common/privacy_budget/identifiability_study_settings.h"
#include "third_party/blink/public/common/privacy_budget/identifiable_token_builder.h"
#include "third_party/blink/public/mojom/use_counter/metrics/web_feature.mojom-blink.h"
#include "third_party/blink/public/platform/browser_interface_broker_proxy.h"
#include "third_party/blink/public/platform/task_type.h"
#include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
#include "third_party/blink/renderer/core/execution_context/execution_context.h"
#include "third_party/blink/renderer/modules/shapedetection/barcode_detector.h"
#include "third_party/blink/renderer/platform/privacy_budget/identifiability_digest_helpers.h"
namespace blink {
// static
const char BarcodeDetectorStatics::kSupplementName[] = "BarcodeDetectorStatics";
// static
BarcodeDetectorStatics* BarcodeDetectorStatics::From(
ExecutionContext* document) {
DCHECK(document);
BarcodeDetectorStatics* statics =
Supplement<ExecutionContext>::From<BarcodeDetectorStatics>(*document);
if (!statics) {
statics = MakeGarbageCollected<BarcodeDetectorStatics>(*document);
Supplement<ExecutionContext>::ProvideTo(*document, statics);
}
return statics;
}
BarcodeDetectorStatics::BarcodeDetectorStatics(ExecutionContext& document)
: Supplement<ExecutionContext>(document), service_(&document) {}
BarcodeDetectorStatics::~BarcodeDetectorStatics() = default;
void BarcodeDetectorStatics::CreateBarcodeDetection(
mojo::PendingReceiver<shape_detection::mojom::blink::BarcodeDetection>
receiver,
shape_detection::mojom::blink::BarcodeDetectorOptionsPtr options) {
EnsureServiceConnection();
service_->CreateBarcodeDetection(std::move(receiver), std::move(options));
}
ScriptPromise<IDLSequence<V8BarcodeFormat>>
BarcodeDetectorStatics::EnumerateSupportedFormats(ScriptState* script_state) {
auto* resolver =
MakeGarbageCollected<ScriptPromiseResolver<IDLSequence<V8BarcodeFormat>>>(
script_state);
auto promise = resolver->Promise();
get_supported_format_requests_.insert(resolver);
EnsureServiceConnection();
service_->EnumerateSupportedFormats(
WTF::BindOnce(&BarcodeDetectorStatics::OnEnumerateSupportedFormats,
WrapPersistent(this), WrapPersistent(resolver)));
return promise;
}
void BarcodeDetectorStatics::Trace(Visitor* visitor) const {
Supplement<ExecutionContext>::Trace(visitor);
visitor->Trace(service_);
visitor->Trace(get_supported_format_requests_);
}
void BarcodeDetectorStatics::EnsureServiceConnection() {
if (service_.is_bound())
return;
ExecutionContext* context = GetSupplementable();
// See https://bit.ly/2S0zRAS for task types.
auto task_runner = context->GetTaskRunner(TaskType::kMiscPlatformAPI);
context->GetBrowserInterfaceBroker().GetInterface(
service_.BindNewPipeAndPassReceiver(task_runner));
service_.set_disconnect_handler(WTF::BindOnce(
&BarcodeDetectorStatics::OnConnectionError, WrapWeakPersistent(this)));
}
void BarcodeDetectorStatics::OnEnumerateSupportedFormats(
ScriptPromiseResolver<IDLSequence<V8BarcodeFormat>>* resolver,
const Vector<shape_detection::mojom::blink::BarcodeFormat>& formats) {
DCHECK(get_supported_format_requests_.Contains(resolver));
get_supported_format_requests_.erase(resolver);
Vector<V8BarcodeFormat> results;
results.ReserveInitialCapacity(results.size());
for (const auto& format : formats) {
results.push_back(
V8BarcodeFormat(BarcodeDetector::BarcodeFormatToEnum(format)));
}
if (IdentifiabilityStudySettings::Get()->ShouldSampleWebFeature(
WebFeature::kBarcodeDetector_GetSupportedFormats)) {
IdentifiableTokenBuilder builder;
for (const auto& format : results) {
builder.AddToken(IdentifiabilityBenignStringToken(format.AsString()));
}
ExecutionContext* context = GetSupplementable();
IdentifiabilityMetricBuilder(context->UkmSourceID())
.AddWebFeature(WebFeature::kBarcodeDetector_GetSupportedFormats,
builder.GetToken())
.Record(context->UkmRecorder());
}
resolver->Resolve(std::move(results));
}
void BarcodeDetectorStatics::OnConnectionError() {
service_.reset();
HeapHashSet<Member<ScriptPromiseResolver<IDLSequence<V8BarcodeFormat>>>>
resolvers;
resolvers.swap(get_supported_format_requests_);
for (const auto& resolver : resolvers) {
// Return an empty list to indicate that no barcode formats are supported
// since this connection failure indicates barcode detection is, in general,
// not supported by the platform.
resolver->Resolve(Vector<V8BarcodeFormat>());
}
}
} // namespace blink
|
