forked from chromium/chromium
-
Notifications
You must be signed in to change notification settings - Fork 0
/
mojo_compositor_frame_sink.mojom
72 lines (62 loc) · 3.23 KB
/
mojo_compositor_frame_sink.mojom
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
// 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 cc.mojom;
import "cc/ipc/begin_frame_args.mojom";
import "cc/ipc/compositor_frame.mojom";
import "cc/ipc/copy_output_request.mojom";
import "cc/ipc/frame_sink_id.mojom";
import "cc/ipc/local_surface_id.mojom";
import "cc/ipc/surface_id.mojom";
import "cc/ipc/returned_resource.mojom";
import "cc/ipc/surface_sequence.mojom";
import "ui/gfx/geometry/mojo/geometry.mojom";
// A MojoCompositorFrameSink is an interface for receiving CompositorFrame
// structs. A CompositorFrame contains the complete output meant for display.
// Each time a client has a graphical update, and receives an OnBeginFrame, it
// is responsible for creating a CompositorFrame to update its portion of the
// screen.
interface MojoCompositorFrameSink {
// Lets the display compositor know that the client wishes to receive the next
// BeginFrame event.
SetNeedsBeginFrame(bool needs_begin_frame);
// Submits a CompositorFrame to the display compositor that will be presented
// to screen the next time frames from all CompositorFrameSinks are aggregated
// to produce a display CompositorFrame. If a client wishes to allocate a new
// surface (e.g. during resize), then it can simply allocate a new
// |local_surface_id|.
// For successful swaps, the implementation must call
// DidReceiveCompositorFrameAck() asynchronously when the frame has been
// processed in order to unthrottle the next frame.
SubmitCompositorFrame(cc.mojom.LocalSurfaceId local_surface_id,
cc.mojom.CompositorFrame frame);
// Notifies the frame sink that a BeginFrame was completed, but that no
// CompositorFrame was produced as a result of it.
DidNotProduceFrame(cc.mojom.BeginFrameAck ack);
};
interface MojoCompositorFrameSinkClient {
// Notification that the previous CompositorFrame given to
// SubmitCompositorFrame() has been processed and that another frame
// can be submitted. This provides backpressure from the display compositor
// so that frames are submitted only at the rate it can handle them.
// TODO(fsamuel): This method ought not be necessary with unified BeginFrame.
// However, there's a fair amount of cleanup and refactoring necessary to get
// rid of it.
DidReceiveCompositorFrameAck(ReturnedResourceArray resources);
// Notification for the client to generate a CompositorFrame.
OnBeginFrame(BeginFrameArgs args);
// Returns resources sent to SubmitCompositorFrame to be reused or freed.
ReclaimResources(ReturnedResourceArray resources);
};
// MojoCompositorFrameSinkPrivate is used by the display compositor host to
// perform privilieged operations on a CompositorFrameSink such as
// CopyOutputRequests.
interface MojoCompositorFrameSinkPrivate {
// Claims this FrameSinkId will embed |surface_id| so it should own the
// temporary reference to |surface_id|.
ClaimTemporaryReference(SurfaceId surface_id);
// Requests that the renderer send back a copy of the surface that this
// CompositorFrameSink submits to. The result can be in form of a bitmap
// or a texture. See cc::CopyOutputRequest.
RequestCopyOfSurface(cc.mojom.CopyOutputRequest request);
};