| // 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/common/string16.mojom"; |
| import "mojo/common/time.mojom"; |
| import "mojo/common/unguessable_token.mojom"; |
| import "services/service_manager/public/interfaces/interface_provider.mojom"; |
| import "third_party/WebKit/common/service_worker/service_worker.mojom"; |
| import "third_party/WebKit/common/service_worker/service_worker_installed_scripts_manager.mojom"; |
| import "third_party/WebKit/public/web/console_message.mojom"; |
| import "third_party/WebKit/public/web/devtools_agent.mojom"; |
| import "third_party/WebKit/public/web/worker_content_settings_proxy.mojom"; |
| import "url/mojo/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.common.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.common.mojom.TimeTicks blink_initialized_time; |
| // When the start worker message was received by the renderer. |
| mojo.common.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(); |
| |
| // 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.common.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.common.mojom.String16 message, int32 line_number, |
| url.mojom.Url source_url); |
| // Indicates that the worker has stopped. |
| OnStopped(); |
| }; |