mojom/page/widget.mojom

// Copyright 2020 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 blink.mojom;

import "cc/mojom/render_frame_metadata.mojom";
import "cc/mojom/touch_action.mojom";
import "mojo/public/mojom/base/string16.mojom";
import "mojo/public/mojom/base/text_direction.mojom";
import "mojo/public/mojom/base/time.mojom";
import "services/viz/public/mojom/compositing/compositor_frame_sink.mojom";
import "services/viz/public/mojom/compositing/local_surface_id.mojom";
import "services/viz/public/mojom/hit_test/input_target_client.mojom";
import "skia/public/mojom/bitmap.mojom";
import "third_party/blink/public/mojom/frame/intrinsic_sizing_info.mojom";
import "third_party/blink/public/mojom/frame/viewport_intersection_state.mojom";
import "third_party/blink/public/mojom/input/input_handler.mojom";
import "third_party/blink/public/mojom/input/touch_event.mojom";
import "third_party/blink/public/mojom/page/drag.mojom";
import "third_party/blink/public/mojom/page/record_content_to_visible_time_request.mojom";
import "third_party/blink/public/mojom/widget/device_emulation_params.mojom";
import "third_party/blink/public/mojom/widget/visual_properties.mojom";
import "ui/base/mojom/ui_base_types.mojom";
import "ui/base/ime/mojom/text_input_state.mojom";
import "ui/base/cursor/mojom/cursor.mojom";
import "ui/gfx/geometry/mojom/geometry.mojom";

[EnableIf=is_mac]
import "ui/base/mojom/attributed_string.mojom";

// Implemented in Blink, this interface defines frame-widget-specific methods that
// will be invoked from the browser process (e.g. blink::WebFrameWidget).
interface FrameWidget {
  // Drag-and-drop methods:
  // |point_in_viewport| is the position of the drag event in the viewport
  // coordinates.
  // |screen_point| is the absolute position of the mouse pointer.
  // |key_modifiers| the event/keyboard modifiers that are active during the
  // operation. See WebInputEvent::Modifiers.

  // Notifies the Widget of a drag enter operation. |drag_data| only
  // contains a subset of the actual drag data the browser has and it
  // used to only start the drag action. Once the item is dropped |drag_data|
  // will be provided with the complete data. Once the renderer has
  // completed processing the event the callback is called with the type of
  // the current drag operation that is active and the browser will update
  // the mouse cursor displayed to the user.
  DragTargetDragEnter(DragData drag_data,
                      gfx.mojom.PointF point_in_viewport,
                      gfx.mojom.PointF screen_point,
                      AllowedDragOperations operations_allowed,
                      uint32 key_modifiers)
      => (DragOperation operation);

  // Notifies the Widget of a drag over operation. Once the renderer has
  // completed processing the event the callback is called with the type of
  // the current drag operation that is active and the browser will update
  // the mouse cursor displayed to the user.
  DragTargetDragOver(gfx.mojom.PointF point_in_viewport,
                     gfx.mojom.PointF screen_point,
                     AllowedDragOperations operations_allowed,
                     uint32 key_modifiers)
      => (DragOperation operation);

  // Notifies the Widget of a drag leave operation.
  DragTargetDragLeave(gfx.mojom.PointF point_in_viewport,
                      gfx.mojom.PointF screen_point);

  // Notifies the Widget of a drag drop operation.
  DragTargetDrop(DragData drag_data,
                 gfx.mojom.PointF point_in_viewport,
                 gfx.mojom.PointF screen_point,
                 uint32 key_modifiers);

  // Notifies the Widget that a drag has terminated.
  DragSourceEndedAt(gfx.mojom.PointF point_in_viewport,
                    gfx.mojom.PointF screen_point,
                    DragOperation drag_operation);

  // Notifies the Widget that the system drag and drop operation has ended.
  DragSourceSystemDragEnded();

  // Makes the Widget background transparent or opaque.
  SetBackgroundOpaque(bool opaque);

  // Changes the text direction of the currently selected input field (if any).
  SetTextDirection(mojo_base.mojom.TextDirection direction);

  // Activate/deactivate the Widget.
  // Focused window is the window that receives keyboard input.
  // The focused window is always or is always contained by the Active window.
  // Active window is the one that contains the focused element.
  // https://www.chromium.org/developers/design-documents/aura/focus-and-activation
  SetActive(bool active);

  // Only valid for sub frame local roots.
  //
  // Sets the inherited effective touch action on an out-of-process iframe.
  SetInheritedEffectiveTouchActionForSubFrame(cc.mojom.TouchAction touch_action);

  // Toggles render throttling for an out-of-process iframe.
  UpdateRenderThrottlingStatusForSubFrame(bool is_throttled, bool subtree_throttled);

  // When the browser receives a call to RenderFrameProxyHost::SetIsInert
  // from the parent widget's embedding renderer changing its inertness,
  // it sets the same inertness value to the renderer of the child subframe.
  // When a widget is inert, it is unable to process input events.
  // https://html.spec.whatwg.org/multipage/interaction.html#inert
  SetIsInertForSubFrame(bool inert);

  // Requests the word under the given point relative to the origin of the
  // widget and its baseline point.
  [EnableIf=is_mac]
  GetStringAtPoint(gfx.mojom.Point point_in_local_root)
      => (ui.mojom.AttributedString? string, gfx.mojom.Point baseline_point);

  // Sent to inform the renderer to invoke a context menu.
  // The parameter specifies the location in the render widget's coordinates.
  ShowContextMenu(
      ui.mojom.MenuSourceType source_type, gfx.mojom.Point location);

  // Enables device emulator.
  EnableDeviceEmulation(DeviceEmulationParams parameters);

  // Disables device emulator.
  DisableDeviceEmulation();

  // Binds an WidgetCompositor interface.
  BindWidgetCompositor(pending_receiver<WidgetCompositor> host);

  // Binds an InputTargetClient interface.
  BindInputTargetClient(pending_receiver<viz.mojom.InputTargetClient> host);

  // Sent by a parent frame to notify its child about the state of the child's
  // intersection with the parent's viewport, primarily for use by the
  // IntersectionObserver API. Also see 'UpdateViewportIntersection' in
  // third_party/blink/public/mojom/frame/viewport_intersection_state.mojom
  SetViewportIntersection(ViewportIntersectionState intersection_state);
};

// Implemented in Browser, this interface defines frame-widget-specific methods that
// will be invoked from the render process (e.g. content::RenderWidgetHostImpl).
interface FrameWidgetHost {
  // Sent by a widget to the browser to request a page scale animation in the
  // main-frame's widget.
  AnimateDoubleTapZoomInMainFrame(
                    gfx.mojom.Point tap_point,
                    gfx.mojom.Rect rect_to_zoom);

  // Sent by a widget to the browser to request a page scale animation in the
  // main-frame's widget for find-in-page zoom.
  ZoomToFindInPageRectInMainFrame(gfx.mojom.Rect rect_to_zoom);

  // Notifies what type of touch event consumers, if any, exist in the renderer,
  // e.g. JavaScript touch event handlers or hit testable scrollbars.
  SetHasTouchEventConsumers(TouchEventConsumers touch_event_consumers);

  // Sent by a widget to the browser to be used for SVGs inside of <object> and
  // not for iframes. Informs the browser that the current frame's intrinsic
  // sizing info has changed. The browser can then notify a containing frame
  // that the frame may need to trigger a new layout.
  //
  // Also see blink::mojom::RemoteFrame::IntrinsicSizingInfoOfChildChanged.
  IntrinsicSizingInfoChanged(IntrinsicSizingInfo sizing_info);

  // Requests a non-decelerating synthetic fling animation to be latched on the
  // scroller at the start point, and whose velocity can be changed over time by
  // sending multiple AutoscrollFling gestures. Used for features like
  // middle-click autoscroll.
  //
  // Sent by a widget to the browser to notify the start point for the
  // autoscroll.
  AutoscrollStart(gfx.mojom.PointF position);

  // Sent by a widget to the browser to notify the velocity for the autoscroll
  // fling animation.
  AutoscrollFling(gfx.mojom.Vector2dF velocity);

  // Sent by a widget to the browser to notify the end of the autoscroll.
  AutoscrollEnd();

  // Sent once a paint happens after the first non empty layout. In other words,
  // after the frame widget has painted something.
  DidFirstVisuallyNonEmptyPaint();

  // Used to tell the browser the user started dragging in the content area.
  // |drag_data| contains contextual information about the pieces of the page
  // the user dragged. The browser uses this notification to initiate a drag
  // session at the OS level.
  StartDragging(DragData drag_data,
                AllowedDragOperations operations_allowed,
                skia.mojom.Bitmap? image,
                gfx.mojom.Vector2d bitmap_offset_in_dip,
                DragEventSourceInfo event_info);
};

// Implemented in Blink, this interface defines widget-specific methods that
// will be invoked from the browser process (e.g. blink::WebWidget).
interface Widget {
  // Sent by the browser to ask the renderer to redraw. Robust to events that
  // can happen in renderer (abortion of the commit or draw, loss of output
  // surface etc.).
  ForceRedraw() => ();

  // Setup the input channel for this widget. If the widget is a frame,
  // then it can also obtain a FrameWidgetInputHandler from the
  // WidgetInputHandler interface.
  GetWidgetInputHandler(
    pending_receiver<blink.mojom.WidgetInputHandler> request,
    pending_remote<blink.mojom.WidgetInputHandlerHost> host);

  // Update the visual properties of the widget.
  UpdateVisualProperties(VisualProperties visual_properties);

  // Informs the widget of its position on the user's screen, as well as
  // the position of the native window holding the widget.
  // TODO(danakj): These should be part of UpdateVisualProperties.
  UpdateScreenRects(gfx.mojom.Rect widget_screen_rect,
                    gfx.mojom.Rect window_screen_rect) => ();


  // Informs the widget that it was hidden. This allows it to reduce its
  // resource utilization.
  WasHidden();

  // Tells the render view that it is no longer hidden (see WasHidden).
  WasShown(mojo_base.mojom.TimeTicks show_request_timestamp,
           bool was_evicted,
           RecordContentToVisibleTimeRequest? record_tab_switch_time_request);
};

// Implemented in Browser, this interface defines widget-specific methods that
// will be invoked from the render process (e.g. content::RenderWidgetHostImpl).
interface WidgetHost {
  // Updates the current cursor to be used by the browser for indicating the
  // location of a pointing device.
  SetCursor(ui.mojom.Cursor cursor);

  // Sent by a widget to the browser to set the tooltip text for the current
  // mouse position. An empty |tooltip_text| will hide the tooltip view.
  SetToolTipText(mojo_base.mojom.String16 tooltip_text,
                 mojo_base.mojom.TextDirection text_direction_hint);

  // Sent when the text input state is changed. This usually happens when
  // a text input entry is focused.
  TextInputStateChanged(ui.mojom.TextInputState state);

  // Sent when the current selection bounds are changed.
  SelectionBoundsChanged(gfx.mojom.Rect anchor_rect,
             mojo_base.mojom.TextDirection anchor_dir,
             gfx.mojom.Rect focus_rect,
             mojo_base.mojom.TextDirection focus_dir,
             bool is_anchor_first);

  // Create a CompositorFrameSink that is associated with this widget.
  // The renderer compositor will use the returned sink to submit
  // CompositorFrames for this widget.
  CreateFrameSink(
      pending_receiver<viz.mojom.CompositorFrameSink>
          compositor_frame_sink_receiver,
      pending_remote<viz.mojom.CompositorFrameSinkClient>
          compositor_frame_sink_client);

  // Register compositor RenderFrameMetadataObserver and client.
  // This call will be made in conjunction with calling CreateFrameSink.
  // The renderer compositor will invoke the RenderFrameMetadataObserver
  // apis when it produces a frame that changes the metadata.
  RegisterRenderFrameMetadataObserver(
      pending_receiver<cc.mojom.RenderFrameMetadataObserverClient>
        render_frame_metadata_observer_client_receiver,
      pending_remote<cc.mojom.RenderFrameMetadataObserver>
        render_frame_metadata_observer);
};

// This interface is bound on the compositor thread.
interface WidgetCompositor {
  // Requests that the RenderWidget sends back a response after the next main
  // frame is generated and presented in the display compositor.
  VisualStateRequest() => ();
};

// Implemented in Browser, this interface defines popup-widget-specific methods
// that will be invoked from the render process (e.g. RenderWidgetHostImpl).
// Popup widgets in the renderer are owned by the PopupWidgetHost in the browser
// process, so the PopupWidgetHost channel disconnecting indicates that the
// widget in the renderer should be destroyed.
interface PopupWidgetHost {
  // Request that this popup be dismissed.
  RequestClosePopup();

  // Request the popup be shown.
  ShowPopup(gfx.mojom.Rect initial_rect) => ();

  // Request that the browser change the bounds of the widget.
  SetPopupBounds(gfx.mojom.Rect bounds) => ();
};