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
|
// Copyright 2016 The Chromium Authors. All rights reserved.
// 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/installedapp/installed_app_controller.h"
#include "services/service_manager/public/cpp/interface_provider.h"
#include "third_party/blink/renderer/core/dom/document.h"
#include "third_party/blink/renderer/core/frame/local_frame.h"
#include "third_party/blink/renderer/platform/wtf/functional.h"
#include <utility>
namespace blink {
// Callbacks for the result of
// WebRelatedAppsFetcher::getManifestRelatedApplications. Calls
// filterByInstalledApps upon receiving the list of related applications.
class InstalledAppController::GetRelatedAppsCallbacks
: public AppInstalledCallbacks {
public:
GetRelatedAppsCallbacks(InstalledAppController* controller,
std::unique_ptr<AppInstalledCallbacks> callbacks)
: controller_(controller), callbacks_(std::move(callbacks)) {}
// AppInstalledCallbacks overrides:
void OnSuccess(
const WebVector<WebRelatedApplication>& related_apps) override {
if (!controller_)
return;
controller_->FilterByInstalledApps(related_apps, std::move(callbacks_));
}
void OnError() override { callbacks_->OnError(); }
private:
WeakPersistent<InstalledAppController> controller_;
std::unique_ptr<AppInstalledCallbacks> callbacks_;
};
InstalledAppController::~InstalledAppController() = default;
void InstalledAppController::GetInstalledRelatedApps(
std::unique_ptr<AppInstalledCallbacks> callbacks) {
// When detached, the fetcher is no longer valid.
if (!related_apps_fetcher_) {
// TODO(mgiuca): AbortError rather than simply undefined.
// https://crbug.com/687846
callbacks->OnError();
return;
}
// Get the list of related applications from the manifest. This requires a
// request to the content layer (because the manifest is not a Blink concept).
// Upon returning, filter the result list to those apps that are installed.
// TODO(mgiuca): This roundtrip to content could be eliminated if the Manifest
// class was moved from content into Blink.
related_apps_fetcher_->GetManifestRelatedApplications(
std::make_unique<GetRelatedAppsCallbacks>(this, std::move(callbacks)));
}
void InstalledAppController::ProvideTo(
LocalFrame& frame,
WebRelatedAppsFetcher* related_apps_fetcher) {
Supplement<LocalFrame>::ProvideTo(
frame, MakeGarbageCollected<InstalledAppController>(
frame, related_apps_fetcher));
}
InstalledAppController* InstalledAppController::From(LocalFrame& frame) {
InstalledAppController* controller =
Supplement<LocalFrame>::From<InstalledAppController>(frame);
DCHECK(controller);
return controller;
}
const char InstalledAppController::kSupplementName[] = "InstalledAppController";
InstalledAppController::InstalledAppController(
LocalFrame& frame,
WebRelatedAppsFetcher* related_apps_fetcher)
: Supplement<LocalFrame>(frame),
ContextLifecycleObserver(frame.GetDocument()),
related_apps_fetcher_(related_apps_fetcher) {}
void InstalledAppController::ContextDestroyed(ExecutionContext*) {
provider_.reset();
related_apps_fetcher_ = nullptr;
}
void InstalledAppController::FilterByInstalledApps(
const blink::WebVector<blink::WebRelatedApplication>& related_apps,
std::unique_ptr<blink::AppInstalledCallbacks> callbacks) {
WTF::Vector<mojom::blink::RelatedApplicationPtr> mojo_related_apps;
for (const auto& related_application : related_apps) {
mojom::blink::RelatedApplicationPtr converted_application(
mojom::blink::RelatedApplication::New());
DCHECK(!related_application.platform.IsEmpty());
converted_application->platform = related_application.platform;
converted_application->id = related_application.id;
converted_application->url = related_application.url;
mojo_related_apps.push_back(std::move(converted_application));
}
if (!provider_) {
// See https://bit.ly/2S0zRAS for task types.
GetSupplementable()->GetInterfaceProvider().GetInterface(
mojo::MakeRequest(&provider_, GetExecutionContext()->GetTaskRunner(
blink::TaskType::kMiscPlatformAPI)));
// TODO(mgiuca): Set a connection error handler. This requires a refactor to
// work like NavigatorShare.cpp (retain a persistent list of clients to
// reject all of their promises).
DCHECK(provider_);
}
provider_->FilterInstalledApps(
std::move(mojo_related_apps),
WTF::Bind(&InstalledAppController::OnFilterInstalledApps,
WrapPersistent(this), WTF::Passed(std::move(callbacks))));
}
void InstalledAppController::OnFilterInstalledApps(
std::unique_ptr<blink::AppInstalledCallbacks> callbacks,
WTF::Vector<mojom::blink::RelatedApplicationPtr> result) {
std::vector<blink::WebRelatedApplication> applications;
for (const auto& res : result) {
blink::WebRelatedApplication app;
app.platform = res->platform;
app.url = res->url;
app.id = res->id;
applications.push_back(app);
}
callbacks->OnSuccess(
blink::WebVector<blink::WebRelatedApplication>(applications));
}
void InstalledAppController::Trace(blink::Visitor* visitor) {
Supplement<LocalFrame>::Trace(visitor);
ContextLifecycleObserver::Trace(visitor);
}
} // namespace blink
|
