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
|
// 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 "modules/serviceworkers/ServiceWorkerLinkResource.h"
#include "bindings/core/v8/ExceptionState.h"
#include "core/dom/Document.h"
#include "core/frame/DOMWindow.h"
#include "core/frame/LocalFrame.h"
#include "core/html/HTMLLinkElement.h"
#include "core/inspector/ConsoleMessage.h"
#include "core/loader/FrameLoaderClient.h"
#include "modules/serviceworkers/NavigatorServiceWorker.h"
#include "modules/serviceworkers/ServiceWorkerContainer.h"
#include "public/platform/Platform.h"
#include "public/platform/WebScheduler.h"
#include "wtf/PtrUtil.h"
namespace blink {
namespace {
class RegistrationCallback
: public WebServiceWorkerProvider::WebServiceWorkerRegistrationCallbacks {
public:
explicit RegistrationCallback(LinkLoaderClient* client) : m_client(client) {}
~RegistrationCallback() override {}
void onSuccess(
std::unique_ptr<WebServiceWorkerRegistration::Handle> handle) override {
Platform::current()
->currentThread()
->scheduler()
->timerTaskRunner()
->postTask(BLINK_FROM_HERE,
WTF::bind(&LinkLoaderClient::linkLoaded, m_client));
}
void onError(const WebServiceWorkerError& error) override {
Platform::current()
->currentThread()
->scheduler()
->timerTaskRunner()
->postTask(BLINK_FROM_HERE,
WTF::bind(&LinkLoaderClient::linkLoadingErrored, m_client));
}
private:
WTF_MAKE_NONCOPYABLE(RegistrationCallback);
Persistent<LinkLoaderClient> m_client;
};
}
ServiceWorkerLinkResource* ServiceWorkerLinkResource::create(
HTMLLinkElement* owner) {
return new ServiceWorkerLinkResource(owner);
}
ServiceWorkerLinkResource::~ServiceWorkerLinkResource() {}
void ServiceWorkerLinkResource::process() {
if (!m_owner || !m_owner->document().frame())
return;
if (!m_owner->shouldLoadLink())
return;
Document& document = m_owner->document();
KURL scriptURL = m_owner->href();
String scope = m_owner->scope();
KURL scopeURL;
if (scope.isNull())
scopeURL = KURL(scriptURL, "./");
else
scopeURL = document.completeURL(scope);
scopeURL.removeFragmentIdentifier();
String errorMessage;
ServiceWorkerContainer* container = NavigatorServiceWorker::serviceWorker(
&document, *document.frame()->domWindow()->navigator(), errorMessage);
if (!container) {
document.addConsoleMessage(ConsoleMessage::create(
JSMessageSource, ErrorMessageLevel,
"Cannot register service worker with <link> element. " + errorMessage));
WTF::makeUnique<RegistrationCallback>(m_owner)->onError(
WebServiceWorkerError(WebServiceWorkerError::ErrorTypeSecurity,
errorMessage));
return;
}
container->registerServiceWorkerImpl(
&document, scriptURL, scopeURL,
WTF::makeUnique<RegistrationCallback>(m_owner));
}
bool ServiceWorkerLinkResource::hasLoaded() const {
return false;
}
void ServiceWorkerLinkResource::ownerRemoved() {
process();
}
ServiceWorkerLinkResource::ServiceWorkerLinkResource(HTMLLinkElement* owner)
: LinkResource(owner) {}
} // namespace blink
|
