path: root/chromium/content/common/renderer.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/document_scoped_interface_bundle.mojom";
import "content/common/native_types.mojom";
import "ipc/constants.mojom";
import "mojo/public/mojom/base/time.mojom";
import "mojo/public/mojom/base/unguessable_token.mojom";
import "services/network/public/mojom/network_types.mojom";
import "services/service_manager/public/mojom/service.mojom";
import "third_party/blink/public/mojom/renderer_preferences.mojom";
import "third_party/blink/public/mojom/service_worker/embedded_worker.mojom";
import "third_party/blink/public/mojom/user_agent/user_agent_metadata.mojom";
import "ui/gfx/geometry/mojo/geometry.mojom";

struct CreateViewParams {
  // Renderer-wide preferences.
  blink.mojom.RendererPreferences renderer_preferences;

  // Preferences for this view.
  WebPreferences web_preferences;

  // The ID of the view to be created.
  int32 view_id = IPC.mojom.kRoutingIdNone;

  // The ID of the main frame hosted in the view, or None if creating a view to
  // host a main frame proxy. If this is None, then |proxy_routing_id| should be
  // set to something other than None.
  int32 main_frame_routing_id = IPC.mojom.kRoutingIdNone;

  // This is null precisely when |main_frame_routing_id| is MSG_ROUTING_NONE,
  // that is, when creating a RenderView for a remote main frame.
  DocumentScopedInterfaceBundle? main_frame_interface_bundle;

  // The ID of the widget for the main frame.
  int32 main_frame_widget_routing_id = IPC.mojom.kRoutingIdNone;

  // The session storage namespace ID this view should use.
  string session_storage_namespace_id;

  // The route ID of the opener RenderFrame or RenderFrameProxy, if we need to
  // set one (MSG_ROUTING_NONE otherwise).
  int32 opener_frame_route_id = IPC.mojom.kRoutingIdNone;

  // Carries replicated information, such as frame name and sandbox flags, for
  // this view's main frame, which will be a proxy when |main_frame_routing_id|
  // is None (due to site isolation), or a RenderFrame in all other cases.
  FrameReplicationState replicated_frame_state;

  // Used for devtools instrumentation and trace-ability. The token is
  // propagated to Blink's LocalFrame and both Blink and content/
  // can tag calls and requests with this instrumentation token in order to
  // attribute them to the context frame.
  // |devtools_main_frame_token| is only defined by the browser and is never
  // sent back from the renderer in the control calls.
  mojo_base.mojom.UnguessableToken devtools_main_frame_token;

  // The ID of the proxy object for the main frame in this view. It is only
  // used if |main_frame_routing_id| is None, and exactly one of the two
  // should be set to an id other than None at any time.
  int32 proxy_routing_id = IPC.mojom.kRoutingIdNone;

  // Whether the RenderView should initially be hidden.
  bool hidden;

  // Whether the RenderView will never be visible.
  bool never_visible;

  // Whether the window associated with this view was created with an opener.
  bool window_was_created_with_opener;

  // Whether or not the frame has previously committed a real load.
  bool has_committed_real_load;

  // The initial renderer size.
  VisualProperties visual_properties;

  // Whether lookup of frames in the created RenderView (e.g. lookup via
  // window.open or via <a target=...>) should be renderer-wide (i.e. going
  // beyond the usual opener-relationship-based BrowsingInstance boundaries).
  bool renderer_wide_named_frame_lookup;

  // Set this to true when creating a RenderView inside a portal.
  bool inside_portal;
};

struct CreateFrameWidgetParams {
  // Gives the routing ID for the RenderWidget that will be attached to the
  // new RenderFrame. If the RenderFrame does not need a RenderWidget, this
  // is MSG_ROUTING_NONE and the other parameters are not read.
  int32 routing_id;

  // Tells the new RenderWidget whether it is initially hidden.
  bool hidden;
};

struct CreateFrameParams {
  // Specifies the routing ID of the new RenderFrame object.
  int32 routing_id;

  // If a valid |previous_routing_id| is provided, the new frame will be
  // configured to replace either the previous frame or the previous proxy on
  // commit.
  int32 previous_routing_id;

  // Specifies the new frame's opener.  The opener will be null if this is
  // MSG_ROUTING_NONE.
  int32 opener_routing_id;

  // The new frame should be created as a child of the object
  // identified by |parent_routing_id| or as top level if that is
  // MSG_ROUTING_NONE.
  int32 parent_routing_id;

  // Identifies the previous sibling of the new frame, so that the new frame is
  // inserted into the correct place in the frame tree.  If this is
  // MSG_ROUTING_NONE, the frame will be created as the leftmost child of its
  // parent frame, in front of any other children.
  int32 previous_sibling_routing_id;

  DocumentScopedInterfaceBundle interface_bundle;

  // When the new frame has a parent, |replication_state| holds the new frame's
  // properties replicated from the process rendering the parent frame, such as
  // the new frame's sandbox flags.
  FrameReplicationState replication_state;

  // Used for devtools instrumentation and trace-ability. The token is
  // propagated to Blink's LocalFrame and both Blink and content/
  // can tag calls and requests with this instrumentation token in order to
  // attribute them to the context frame.
  // |devtools_frame_token| is only defined by the browser and is never
  // sent back from the renderer in the control calls.
  mojo_base.mojom.UnguessableToken devtools_frame_token;

  // When the new frame has a parent, |frame_owner_properties| holds the
  // properties of the HTMLFrameOwnerElement from the parent process.
  // Note that unlike FrameReplicationState, this is not replicated for remote
  // frames.
  FrameOwnerProperties frame_owner_properties;

  // Specifies properties for a new RenderWidget that will be attached to the
  // new RenderFrame (if one is needed).
  CreateFrameWidgetParams widget_params;

  // Whether or not the frame has previously committed a real load.
  bool has_committed_real_load;
};

struct UpdateScrollbarThemeParams {
  float initial_button_delay;
  float autoscroll_button_delay;
  bool jump_on_track_click;
  ScrollerStyle preferred_scroller_style;
  bool redraw;
  ScrollbarButtonsPlacement button_placement;
  bool scroll_view_rubber_banding;
};

enum RenderProcessState {
  kVisible,
  // Hidden render processes can still be foregrounded. For example, a hidden
  // renderer playing audio would be foregrounded.
  kHidden,
  // Refers to a renderer that is hidden and running at background process
  // priority.
  kBackgrounded,
};

// The primordial Channel-associated interface implemented by a render process.
// This should be used for implementing browser-to-renderer control messages
// which need to retain FIFO with respect to legacy IPC messages.
interface Renderer {
  // Tells the renderer to ask its embedder to bind |service_request| to an
  // embedder-provided renderer-side service implementation. This is required to
  // ensure that embedder-provided renderer-side service is initialized at the
  // appropriate time.
  CreateEmbedderRendererService(service_manager.mojom.Service& service_request);

  // Tells the renderer to create a new view.
  CreateView(CreateViewParams params);

  // Tells the renderer to create a new RenderFrame.
  CreateFrame(CreateFrameParams params);

  // Tells the renderer to create a new RenderFrameProxy object with
  // |routing_id|.  |render_view_routing_id| identifies the
  // RenderView to be associated with this proxy.  The new proxy's opener should
  // be set to the object identified by |opener_routing_id|, or to null if that
  // is MSG_ROUTING_NONE.  The new proxy should be created as a child of the
  // object identified by |parent_routing_id| or as top level if that is
  // MSG_ROUTING_NONE.
  // |devtools_frame_token| is used for devtools instrumentation
  // and trace-ability. It is defined by the browser and is never
  // sent back from the renderer in the control calls.
  CreateFrameProxy(int32 routing_id, int32 render_view_routing_id,
                   int32 opener_routing_id, int32 parent_routing_id,
                   FrameReplicationState replication_state,
                   mojo_base.mojom.UnguessableToken devtools_frame_token);

  // Tells the renderer to create an EmbeddedWorkerInstanceClient, which is what
  // manages service worker startup and shutdown.
  // TODO(shimazu): Send all params for starting service worker to reduce the
  // number of IPCs.
  SetUpEmbeddedWorkerChannelForServiceWorker(
      blink.mojom.EmbeddedWorkerInstanceClient& client_request);

  // Tells the renderer that the network type has changed so that
  // navigator.onLine and navigator.connection can be updated.
  OnNetworkConnectionChanged(NetworkConnectionType connection_type,
                             double max_bandwidth_mbps);

  // Tells the renderer process that the network quality estimate has changed.
  // EffectiveConnectionType is the connection type whose typical performance is
  // most similar to the measured performance of the network in use.
  // The downstream throughput is computed in kilobits per second. If an
  // estimate of the HTTP or transport RTT is unavailable, it will be set to
  // net::nqe::internal::InvalidRTT(). If the throughput estimate is
  // unavailable, it will be set to net::nqe::internal::INVALID_RTT_THROUGHPUT.
  OnNetworkQualityChanged(
      network.mojom.EffectiveConnectionType effective_connection_type,
      mojo_base.mojom.TimeDelta http_rtt,
      mojo_base.mojom.TimeDelta transport_rtt,
      double bandwidth_kbps);

  // Tells the renderer to suspend/resume the webkit timers. Only for use on
  // Android.
  SetWebKitSharedTimersSuspended(bool suspend);

  // Sets the user-agent string. This is needed because getting the value in the
  // renderer from the system leads to a wrong value due to sandboxing. This
  // must be called as early as possible, during the renderer process
  // initialization.
  SetUserAgent(string user_agent);

  // Sets the user agent metadata. This will replace `SetUserAgent()` if we
  // decide to ship https://github.com/WICG/ua-client-hints.
  SetUserAgentMetadata(blink.mojom.UserAgentMetadata metadata);

  // Tells the renderer about a scrollbar appearance change. Only for use on
  // OS X.
  UpdateScrollbarTheme(UpdateScrollbarThemeParams params);

  // Notification that the OS X Aqua color preferences changed.
  OnSystemColorsChanged(int32 aqua_color_variant, string highlight_text_color,
                        string highlight_color);

  // Tells the renderer to empty its plugin list cache, optional reloading
  // pages containing plugins.
  PurgePluginListCache(bool reload_pages);


  // Tells the renderer process of a change in visibility or background state.
  SetProcessState(RenderProcessState process_state);

  // Tells the scheduler about "keep-alive" state which can be due to:
  // service workers, shared workers, or fetch keep-alive.
  // If set to true, then the scheduler should not freeze the renderer.
  SetSchedulerKeepActive(bool keep_active);

  // Tells the renderer process that it has been locked to a site (i.e., a
  // scheme plus eTLD+1, such as https://google.com), or to a more specific
  // origin.
  SetIsLockedToSite();

  // Tells the renderer to enable V8's memory saving mode when possible.
  // This is only used when site-per-process is enabled. If the process
  // only contains subframes, V8's low memory mode will be enabled.
  // If a main frame exists or is created, the low memory mode will
  // be disabled.
  EnableV8LowMemoryMode();
};