naiveproxy/content/common/service_worker/embedded_worker.mojom

// 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_installed_scripts_manager.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/public/platform/modules/serviceworker/service_worker.mojom";
import "third_party/WebKit/public/web/console_message.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;
};

// 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().
  // |dispatcher_request| is used to dispatch events from (via) the browser
  // process.
  //
  // S13nServiceWorker:
  // |controller_request| is cloned and passed to each
  // controllee to directly dispatch events from the controllees.
  StartWorker(EmbeddedWorkerStartParams params,
              ServiceWorkerEventDispatcher& dispatcher_request,
              ControllerServiceWorker& controller_request,
              ServiceWorkerInstalledScriptsInfo? installed_scripts_info,
              associated blink.mojom.ServiceWorkerHost service_worker_host,
              associated EmbeddedWorkerInstanceHost instance_host,
              ServiceWorkerProviderInfoForStartWorker provider_info,
              blink.mojom.WorkerContentSettingsProxy content_settings_proxy);
  // The response is sent back via EmbeddedWorkerInstanceHost.OnStopped().
  StopWorker();
  ResumeAfterDownload();
  AddMessageToConsole(blink.mojom.ConsoleMessageLevel level, string message);
};

// 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();
};