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 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.
module content.mojom;
import "content/common/native_types.mojom";
import "content/common/service_worker/controller_service_worker.mojom";
import "content/common/service_worker/service_worker_event_dispatcher.mojom";
import "content/common/service_worker/service_worker_provider.mojom";
import "mojo/public/mojom/base/string16.mojom";
import "mojo/public/mojom/base/time.mojom";
import "mojo/public/mojom/base/unguessable_token.mojom";
import "services/service_manager/public/mojom/interface_provider.mojom";
import "third_party/blink/public/mojom/service_worker/service_worker.mojom";
import "third_party/blink/public/mojom/service_worker/service_worker_installed_scripts_manager.mojom";
import "third_party/blink/public/platform/web_feature.mojom";
import "third_party/blink/public/web/console_message.mojom";
import "third_party/blink/public/web/devtools_agent.mojom";
import "third_party/blink/public/web/worker_content_settings_proxy.mojom";
import "url/mojom/url.mojom";
// Parameters to launch a service worker. This is passed from the browser to the
// renderer at mojom::EmbeddedWorkerInstanceClient::StartWorker().
struct EmbeddedWorkerStartParams {
// The id of the embedded worker. This changes when the service worker is
// stopped and restarted.
int32 embedded_worker_id;
// The id of the service worker being started. This remains fixed even if the
// worker is stopped and restarted, or even if the browser restarts.
int64 service_worker_version_id;
// This service worker's registration's scope:
// https://w3c.github.io/ServiceWorker/#service-worker-registration-scope
url.mojom.Url scope;
// This service worker's script url:
// https://w3c.github.io/ServiceWorker/#dom-serviceworker-scripturl
url.mojom.Url script_url;
// The id to talk with the DevTools agent for the worker.
int32 worker_devtools_agent_route_id;
// Unique token identifying this worker for DevTools.
mojo_base.mojom.UnguessableToken devtools_worker_token;
// When true, worker script evaluation is blocked until
// EmbeddedWorkerInstanceClient::ResumeAfterDownload() is called.
bool pause_after_download;
// True if starting the worker should wait until DevTools gets ready.
bool wait_for_debugger;
// True if this service worker has been installed.
bool is_installed;
// Determines how eagerly V8 creates the code cache.
V8CacheOptions v8_cache_options;
// True if Data Saver is enabled.
bool data_saver_enabled;
// Used to dispatch events from (via) the browser process.
ServiceWorkerEventDispatcher& dispatcher_request;
// S13nServiceWorker: cloned and passed to each controllee to directly
// dispatch events from the controllees.
ControllerServiceWorker& controller_request;
// Information to transfer installed scripts from the browser to the renderer.
blink.mojom.ServiceWorkerInstalledScriptsInfo? installed_scripts_info;
// Interface for the renderer to ask the browser to do operations needed for
// ServiceWorkerGlobalScope functionalities.
associated blink.mojom.ServiceWorkerHost service_worker_host;
// Interface for the renderer to send the status updates to the browser.
associated EmbeddedWorkerInstanceHost instance_host;
// Information for creating ServiceWorkerNetworkProvider on the renderer.
ServiceWorkerProviderInfoForStartWorker provider_info;
// Interface for the renderer to query the content settings in the browser.
blink.mojom.WorkerContentSettingsProxy content_settings_proxy;
};
// Holds timing information about the start worker sequence for UMA.
struct EmbeddedWorkerStartTiming {
// When this Blink instance finished initializing.
mojo_base.mojom.TimeTicks blink_initialized_time;
// When the start worker message was received by the renderer.
mojo_base.mojom.TimeTicks start_worker_received_time;
};
// EmbeddedWorkerInstanceClient is the renderer-side ("Client") of
// EmbeddedWorkerInstanceHost. It allows control of a renderer-side
// embedded worker. The browser uses this interface to start, stop, and
// issue commands to the worker.
interface EmbeddedWorkerInstanceClient {
// Called back as various functions in EmbeddedWorkerInstanceHost, such
// as OnThreadStarted(), OnStarted().
StartWorker(EmbeddedWorkerStartParams params);
// The response is sent back via EmbeddedWorkerInstanceHost.OnStopped().
StopWorker();
ResumeAfterDownload();
AddMessageToConsole(blink.mojom.ConsoleMessageLevel level, string message);
// Returns a DevToolsAgent interface for this embedded worker, used for
// remote debugging. See DevToolsAgent for details.
BindDevToolsAgent(associated blink.mojom.DevToolsAgent& devtools_agent);
};
// EmbeddedWorkerInstanceHost is the browser-side ("Host") of
// EmbeddedWorkerInstanceClient. It allows control of a browser-side
// embedded worker instance. The renderer uses this interface to report
// embedded worker state back to the browser, or request termination of the
// worker. This interface is associated with the EmbeddedWorkerInstanceClient
// interface.
interface EmbeddedWorkerInstanceHost {
// S13nServiceWorker:
// Called when the worker requests to be terminated. The worker will request
// to be terminated when it realizes it has been idle for some time. The
// request may be ignored, for example when there are inflight events issued
// just before RequestTermination(). Note that the browser can terminate the
// worker at any time even if RequestTermination() is not called. For example,
// if the worker thread is continuously busy and the browser's periodic ping
// message has been missed, the browser will terminate the service worker.
RequestTermination();
// Tells the browser process that this service worker used |feature|, for
// UseCounter purposes. The browser process propagates the feature usage bit
// to all clients controlled by the service worker. See
// https://crbug.com/376039 for background.
// Note: Because CountFeature() is possible to be called on the main thread
// during service worker startup and is also called on the worker thread after
// that, we put it here rather than interface ServiceWorkerHost, so that we
// can still keep interface ServiceWorkerHost being used solely on the worker
// thread in the renderer process.
CountFeature(blink.mojom.WebFeature feature);
// Indicates that the worker is ready for inspection.
OnReadyForInspection();
// Indicates that the worker has finished loading the script.
OnScriptLoaded();
// Indicates that the worker has failed to load the script.
OnScriptLoadFailed();
// Indicates that the worker thread has started. |thread_id| is the actual
// platform thread id on which the worker runs.
// This is called after OnScriptLoaded.
OnThreadStarted(int32 thread_id);
// Indicates that the worker has evaluated the script. |success| means
// evaluating the script completed and no uncaught exception occurred.
// This is called after OnThreadStarted.
OnScriptEvaluated(bool success);
// Indicates that the worker has started.
// This is called after OnScriptEvaluated.
OnStarted(EmbeddedWorkerStartTiming start_timing);
// Reports that an uncaught exception occurred in the worker.
OnReportException(mojo_base.mojom.String16 error_message, int32 line_number,
int32 column_number, url.mojom.Url source_url);
// Reports that a console message was emitted to the worker's console.
OnReportConsoleMessage(int32 source_identifier, int32 message_level,
mojo_base.mojom.String16 message, int32 line_number,
url.mojom.Url source_url);
// Indicates that the worker has stopped.
OnStopped();
};
|
