content/common/renderer.mojom

// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

module content.mojom;

import "components/attribution_reporting/os_support.mojom";
import "content/common/agent_scheduling_group.mojom";
import "content/common/native_types.mojom";
import "ipc/ipc.mojom";
import "mojo/public/mojom/base/generic_pending_receiver.mojom";
import "mojo/public/mojom/base/time.mojom";
import "services/network/public/mojom/network_types.mojom";
import "skia/public/mojom/skcolor.mojom";
import "third_party/blink/public/mojom/browser_interface_broker.mojom";
import "third_party/blink/public/mojom/user_agent/user_agent_metadata.mojom";
import "ui/color/color_id.mojom";

struct UpdateScrollbarThemeParams {
  // TODO(avi): Update these to optional values when optional numeric types are
  // allowed. (https://crbug.com/657632)
  bool has_initial_button_delay;
  float initial_button_delay;
  bool has_autoscroll_button_delay;
  float autoscroll_button_delay;

  bool jump_on_track_click;
  ScrollerStyle preferred_scroller_style;
  bool redraw;

  bool scroll_view_rubber_banding;
};

struct UpdateSystemColorInfoParams {
  bool is_dark_mode;
  bool forced_colors;

  // uint32 represents a SkColor in the map.
  // TODO(crbug.com/1251637): These colors should be consolidated into the
  // renderer's ColorProviders.
  map<SystemThemeColor, uint32> colors;

  // Maps used to reconstruct ColorProvider instances in the renderer.
  map<color.mojom.RendererColorId, skia.mojom.SkColor> light_colors;
  map<color.mojom.RendererColorId, skia.mojom.SkColor> dark_colors;
};

// The background state for the render process.  When backgrounded the process's
// priority will be lower (via base::Process::SetProcessBackgrounded()) if
// allowed on the current platform (as determined by
// base::Process::CanBackgroundProcesses()).
enum RenderProcessBackgroundState {
  // The renderer process has not been backgrounded, a hidden renderer may still
  // be foregrounded, e.g. when it is playing audio.
  kForegrounded,
  // The renderer process has been backgrounded, a visible renderer may still
  // be backgrounded, e.g. when it is hosting only low priority frames.
  kBackgrounded,
};

// The visibility state for the renderer process, indicating whether or not any
// of the frames associated with the renderer process are visible.
enum RenderProcessVisibleState {
  kVisible,
  kHidden,
};

// 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 create a new AgentSchedulingGroup, and initialize its
  // legacy IPC Channel using the pipe provided by `bootstrap`. The channel will
  // later be used to bind the mojom::AgentSchedulingGroup receiver, that
  // listens to messages sent by the host.
  // This will create an "independent" agent scheduling group that is not
  // associated with the process-wide or other groups' IPC channels, meaning
  // there is no guaranteed ordering between them.
  // `broker_remote` is the BrowserInterfaceBroker bound to the newly-created
  // AgentSchedulingGroup.
  CreateAgentSchedulingGroup(
    pending_receiver<IPC.mojom.ChannelBootstrap> bootstrap,
    pending_remote<blink.mojom.BrowserInterfaceBroker> broker_remote);

  // Tells the renderer to create a new AgentSchedulingGroup, that will
  // listen to messages sent by the host via the pending
  // |agent_scheduling_group|.
  // This will create an agent scheduling group that is associated with the
  // process-wide IPC channel, preserving message ordering across different
  // agent scheduling groups.
  // `broker_remote` is the BrowserInterfaceBroker bound to the newly-created
  // AgentSchedulingGroup.
  CreateAssociatedAgentSchedulingGroup(
    pending_associated_receiver<AgentSchedulingGroup> agent_scheduling_group,
    pending_remote<blink.mojom.BrowserInterfaceBroker> broker_remote);

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

  // 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 process the new system color info.
  UpdateSystemColorInfo(UpdateSystemColorInfoParams params);

  // 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(RenderProcessBackgroundState background_state,
                  RenderProcessVisibleState visible_state);

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

  // Write out the accumulated code profiling profile to the configured file.
  // The callback is invoked once the profile has been flushed to disk.
  [EnableIf=clang_profiling_inside_sandbox]
  WriteClangProfilingProfile() => ();

  // Set whether this renderer process is "cross-origin isolated". This
  // corresponds to agent cluster's "cross-origin isolated" concept.
  // TODO(yhirano): Have the spec URL.
  // This property is process global because we ensure that a renderer process
  // host only cross-origin isolated agents or only non-cross-origin isolated
  // agents, not both.
  // This is called at most once, prior to committing a navigation.
  SetIsCrossOriginIsolated(bool value);

  // Set whether this renderer process is allowed to use Isolated Context APIs.
  // Similarly to the `SetIsCrossOriginIsolated()` method above, this flag is
  // process global, and called at most once, prior to committing a navigation.
  //
  // TODO(crbug.com/1206150): We need a specification for this restriction.
  SetIsIsolatedContext(bool value);

  // Set the OS-level support for Attribution Reporting indicating whether
  // OS-level attribution is enabled.
  SetOsSupportForAttributionReporting(
      attribution_reporting.mojom.OsSupport os_support);

  // Initialize renderer user agent string, user agent metadata and CORS exempt
  // header list on renderer startup.
  //
  // |user_agent| 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.
  //
  // |full_user_agent| sets the full user-agent with high-entropy information.
  //
  // |reduced_user_agent| sets a user-agent with high-entropy information
  // reduced to common values.
  //
  // |metadata| sets the user agent metadata. This will replace `SetUserAgent()`
  // if we decide to ship https://github.com/WICG/ua-client-hints.
  //
  // |cors_exempt_header_list| sets the CORS exempt header list for sanity
  // checking (e.g. DCHECKs).
  //
  // |attribution_os_support| sets the OS-level support for Attribution
  // Reporting.
  InitializeRenderer(string user_agent,
                     string full_user_agent,
                     string reduced_user_agent,
                     blink.mojom.UserAgentMetadata metadata,
                     array<string> cors_exempt_header_list,
                     attribution_reporting.mojom.OsSupport attribution_os_support);
};