-
Notifications
You must be signed in to change notification settings - Fork 54
/
api.rs
2079 lines (1886 loc) · 73 KB
/
api.rs
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#![deny(missing_docs)]
extern crate serde_bytes;
use crate::channel::{self, MsgReceiver, MsgSender, Payload, PayloadSender};
use peek_poke::PeekPoke;
use std::cell::Cell;
use std::fmt;
use std::marker::PhantomData;
use std::os::raw::c_void;
use std::path::PathBuf;
use std::sync::Arc;
use std::u32;
// local imports
use crate::{display_item as di, font};
use crate::color::{ColorU, ColorF};
use crate::display_list::{BuiltDisplayList, BuiltDisplayListDescriptor};
use crate::image::{BlobImageData, BlobImageKey, ImageData, ImageDescriptor, ImageKey};
use crate::units::*;
/// Width and height in device pixels of image tiles.
pub type TileSize = u16;
/// Documents are rendered in the ascending order of their associated layer values.
pub type DocumentLayer = i8;
/// Various settings that the caller can select based on desired tradeoffs
/// between rendering quality and performance / power usage.
#[derive(Copy, Clone, Deserialize, Serialize)]
pub struct QualitySettings {
/// If true, allow picture cache slices to be created that may prevent
/// subpixel AA on text being used due to lack of opaque background. This
/// often allows a significant performance win on pages that interleave
/// scroll regions with fixed position elements.
pub allow_sacrificing_subpixel_aa: bool,
}
impl Default for QualitySettings {
fn default() -> Self {
QualitySettings {
// Preferring performance in this case retains the current behavior.
allow_sacrificing_subpixel_aa: true,
}
}
}
/// Update of a persistent resource in WebRender.
///
/// ResourceUpdate changes keep theirs effect across display list changes.
#[derive(Clone, Deserialize, Serialize)]
pub enum ResourceUpdate {
/// See `AddImage`.
AddImage(AddImage),
/// See `UpdateImage`.
UpdateImage(UpdateImage),
/// See `AddBlobImage`.
AddBlobImage(AddBlobImage),
/// See `UpdateBlobImage`.
UpdateBlobImage(UpdateBlobImage),
/// Delete an existing image or blob-image resource.
///
/// It is invalid to continue referring to the image key in any display list
/// in the transaction that contains the `DeleteImage` message and subsequent
/// transactions.
DeleteImage(ImageKey),
/// See `AddBlobImage::visible_area`.
SetBlobImageVisibleArea(BlobImageKey, DeviceIntRect),
/// See `AddFont`.
AddFont(AddFont),
/// Deletes an already existing font resource.
///
/// It is invalid to continue referring to the font key in any display list
/// in the transaction that contains the `DeleteImage` message and subsequent
/// transactions.
DeleteFont(font::FontKey),
/// See `AddFontInstance`.
AddFontInstance(AddFontInstance),
/// Deletes an already existing font instance resource.
///
/// It is invalid to continue referring to the font instance in any display
/// list in the transaction that contains the `DeleteImage` message and
/// subsequent transactions.
DeleteFontInstance(font::FontInstanceKey),
}
impl fmt::Debug for ResourceUpdate {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
ResourceUpdate::AddImage(ref i) => f.write_fmt(format_args!(
"ResourceUpdate::AddImage size({:?})",
&i.descriptor.size
)),
ResourceUpdate::UpdateImage(ref i) => f.write_fmt(format_args!(
"ResourceUpdate::UpdateImage size({:?})",
&i.descriptor.size
)),
ResourceUpdate::AddBlobImage(ref i) => f.write_fmt(format_args!(
"ResourceUpdate::AddBlobImage size({:?})",
&i.descriptor.size
)),
ResourceUpdate::UpdateBlobImage(i) => f.write_fmt(format_args!(
"ResourceUpdate::UpdateBlobImage size({:?})",
&i.descriptor.size
)),
ResourceUpdate::DeleteImage(..) => f.write_str("ResourceUpdate::DeleteImage"),
ResourceUpdate::SetBlobImageVisibleArea(..) => f.write_str("ResourceUpdate::SetBlobImageVisibleArea"),
ResourceUpdate::AddFont(..) => f.write_str("ResourceUpdate::AddFont"),
ResourceUpdate::DeleteFont(..) => f.write_str("ResourceUpdate::DeleteFont"),
ResourceUpdate::AddFontInstance(..) => f.write_str("ResourceUpdate::AddFontInstance"),
ResourceUpdate::DeleteFontInstance(..) => f.write_str("ResourceUpdate::DeleteFontInstance"),
}
}
}
/// A Transaction is a group of commands to apply atomically to a document.
///
/// This mechanism ensures that:
/// - no other message can be interleaved between two commands that need to be applied together.
/// - no redundant work is performed if two commands in the same transaction cause the scene or
/// the frame to be rebuilt.
pub struct Transaction {
/// Operations affecting the scene (applied before scene building).
scene_ops: Vec<SceneMsg>,
/// Operations affecting the generation of frames (applied after scene building).
frame_ops: Vec<FrameMsg>,
/// Additional display list data.
payloads: Vec<Payload>,
notifications: Vec<NotificationRequest>,
/// Persistent resource updates to apply as part of this transaction.
pub resource_updates: Vec<ResourceUpdate>,
/// If true the transaction is piped through the scene building thread, if false
/// it will be applied directly on the render backend.
use_scene_builder_thread: bool,
generate_frame: bool,
/// Set to true in order to force re-rendering even if WebRender can't internally
/// detect that something has changed.
pub invalidate_rendered_frame: bool,
low_priority: bool,
}
impl Transaction {
/// Constructor.
pub fn new() -> Self {
Transaction {
scene_ops: Vec::new(),
frame_ops: Vec::new(),
resource_updates: Vec::new(),
payloads: Vec::new(),
notifications: Vec::new(),
use_scene_builder_thread: true,
generate_frame: false,
invalidate_rendered_frame: false,
low_priority: false,
}
}
/// Marks this transaction to allow it to skip going through the scene builder
/// thread.
///
/// This is useful to avoid jank in transaction associated with animated
/// property updates, panning and zooming.
///
/// Note that transactions that skip the scene builder thread can race ahead of
/// transactions that don't skip it.
pub fn skip_scene_builder(&mut self) {
self.use_scene_builder_thread = false;
}
/// Marks this transaction to enforce going through the scene builder thread.
pub fn use_scene_builder_thread(&mut self) {
self.use_scene_builder_thread = true;
}
/// Returns true if the transaction has no effect.
pub fn is_empty(&self) -> bool {
!self.generate_frame &&
!self.invalidate_rendered_frame &&
self.scene_ops.is_empty() &&
self.frame_ops.is_empty() &&
self.resource_updates.is_empty() &&
self.notifications.is_empty()
}
/// Update a pipeline's epoch.
pub fn update_epoch(&mut self, pipeline_id: PipelineId, epoch: Epoch) {
// We track epochs before and after scene building.
// This one will be applied to the pending scene right away:
self.scene_ops.push(SceneMsg::UpdateEpoch(pipeline_id, epoch));
// And this one will be applied to the currently built scene at the end
// of the transaction (potentially long after the scene_ops one).
self.frame_ops.push(FrameMsg::UpdateEpoch(pipeline_id, epoch));
// We could avoid the duplication here by storing the epoch updates in a
// separate array and let the render backend schedule the updates at the
// proper times, but it wouldn't make things simpler.
}
/// Sets the root pipeline.
///
/// # Examples
///
/// ```
/// # use webrender_api::{PipelineId, RenderApiSender, Transaction};
/// # use webrender_api::units::{DeviceIntSize};
/// # fn example() {
/// let pipeline_id = PipelineId(0, 0);
/// let mut txn = Transaction::new();
/// txn.set_root_pipeline(pipeline_id);
/// # }
/// ```
pub fn set_root_pipeline(&mut self, pipeline_id: PipelineId) {
self.scene_ops.push(SceneMsg::SetRootPipeline(pipeline_id));
}
/// Removes data associated with a pipeline from the internal data structures.
/// If the specified `pipeline_id` is for the root pipeline, the root pipeline
/// is reset back to `None`.
pub fn remove_pipeline(&mut self, pipeline_id: PipelineId) {
self.scene_ops.push(SceneMsg::RemovePipeline(pipeline_id));
}
/// Supplies a new frame to WebRender.
///
/// Non-blocking, it notifies a worker process which processes the display list.
///
/// Note: Scrolling doesn't require an own Frame.
///
/// Arguments:
///
/// * `epoch`: The unique Frame ID, monotonically increasing.
/// * `background`: The background color of this pipeline.
/// * `viewport_size`: The size of the viewport for this frame.
/// * `pipeline_id`: The ID of the pipeline that is supplying this display list.
/// * `content_size`: The total screen space size of this display list's display items.
/// * `display_list`: The root Display list used in this frame.
/// * `preserve_frame_state`: If a previous frame exists which matches this pipeline
/// id, this setting determines if frame state (such as scrolling
/// position) should be preserved for this new display list.
pub fn set_display_list(
&mut self,
epoch: Epoch,
background: Option<ColorF>,
viewport_size: LayoutSize,
(pipeline_id, content_size, display_list): (PipelineId, LayoutSize, BuiltDisplayList),
preserve_frame_state: bool,
) {
let (display_list_data, list_descriptor) = display_list.into_data();
self.scene_ops.push(
SceneMsg::SetDisplayList {
epoch,
pipeline_id,
background,
viewport_size,
content_size,
list_descriptor,
preserve_frame_state,
}
);
self.payloads.push(Payload { epoch, pipeline_id, display_list_data });
}
/// Add a set of persistent resource updates to apply as part of this transaction.
pub fn update_resources(&mut self, mut resources: Vec<ResourceUpdate>) {
self.resource_updates.append(&mut resources);
}
// Note: Gecko uses this to get notified when a transaction that contains
// potentially long blob rasterization or scene build is ready to be rendered.
// so that the tab-switching integration can react adequately when tab
// switching takes too long. For this use case when matters is that the
// notification doesn't fire before scene building and blob rasterization.
/// Trigger a notification at a certain stage of the rendering pipeline.
///
/// Not that notification requests are skipped during serialization, so is is
/// best to use them for synchronization purposes and not for things that could
/// affect the WebRender's state.
pub fn notify(&mut self, event: NotificationRequest) {
self.notifications.push(event);
}
/// Setup the output region in the framebuffer for a given document.
pub fn set_document_view(
&mut self,
device_rect: DeviceIntRect,
device_pixel_ratio: f32,
) {
self.scene_ops.push(
SceneMsg::SetDocumentView {
device_rect,
device_pixel_ratio,
},
);
}
/// Enable copying of the output of this pipeline id to
/// an external texture for callers to consume.
pub fn enable_frame_output(&mut self, pipeline_id: PipelineId, enable: bool) {
self.scene_ops.push(SceneMsg::EnableFrameOutput(pipeline_id, enable));
}
/// Scrolls the scrolling layer under the `cursor`
///
/// WebRender looks for the layer closest to the user
/// which has `ScrollPolicy::Scrollable` set.
pub fn scroll(&mut self, scroll_location: ScrollLocation, cursor: WorldPoint) {
self.frame_ops.push(FrameMsg::Scroll(scroll_location, cursor));
}
///
pub fn scroll_node_with_id(
&mut self,
origin: LayoutPoint,
id: di::ExternalScrollId,
clamp: ScrollClamping,
) {
self.frame_ops.push(FrameMsg::ScrollNodeWithId(origin, id, clamp));
}
/// Set the current quality / performance settings for this document.
pub fn set_quality_settings(&mut self, settings: QualitySettings) {
self.scene_ops.push(SceneMsg::SetQualitySettings { settings });
}
///
pub fn set_page_zoom(&mut self, page_zoom: ZoomFactor) {
self.scene_ops.push(SceneMsg::SetPageZoom(page_zoom));
}
///
pub fn set_pinch_zoom(&mut self, pinch_zoom: ZoomFactor) {
self.frame_ops.push(FrameMsg::SetPinchZoom(pinch_zoom));
}
///
pub fn set_is_transform_async_zooming(&mut self, is_zooming: bool, animation_id: PropertyBindingId) {
self.frame_ops.push(FrameMsg::SetIsTransformAsyncZooming(is_zooming, animation_id));
}
///
pub fn set_pan(&mut self, pan: DeviceIntPoint) {
self.frame_ops.push(FrameMsg::SetPan(pan));
}
/// Generate a new frame. When it's done and a RenderNotifier has been set
/// in `webrender::Renderer`, [new_frame_ready()][notifier] gets called.
/// Note that the notifier is called even if the frame generation was a
/// no-op; the arguments passed to `new_frame_ready` will provide information
/// as to when happened.
///
/// [notifier]: trait.RenderNotifier.html#tymethod.new_frame_ready
pub fn generate_frame(&mut self) {
self.generate_frame = true;
}
/// Invalidate rendered frame. It ensure that frame will be rendered during
/// next frame generation. WebRender could skip frame rendering if there
/// is no update.
/// But there are cases that needs to force rendering.
/// - Content of image is updated by reusing same ExternalImageId.
/// - Platform requests it if pixels become stale (like wakeup from standby).
pub fn invalidate_rendered_frame(&mut self) {
self.invalidate_rendered_frame = true;
}
/// Supply a list of animated property bindings that should be used to resolve
/// bindings in the current display list.
pub fn update_dynamic_properties(&mut self, properties: DynamicProperties) {
self.frame_ops.push(FrameMsg::UpdateDynamicProperties(properties));
}
/// Add to the list of animated property bindings that should be used to
/// resolve bindings in the current display list. This is a convenience method
/// so the caller doesn't have to figure out all the dynamic properties before
/// setting them on the transaction but can do them incrementally.
pub fn append_dynamic_transform_properties(&mut self, transforms: Vec<PropertyValue<LayoutTransform>>) {
self.frame_ops.push(FrameMsg::AppendDynamicTransformProperties(transforms));
}
/// Consumes this object and just returns the frame ops.
pub fn get_frame_ops(self) -> Vec<FrameMsg> {
self.frame_ops
}
fn finalize(self) -> (TransactionMsg, Vec<Payload>) {
(
TransactionMsg {
scene_ops: self.scene_ops,
frame_ops: self.frame_ops,
resource_updates: self.resource_updates,
notifications: self.notifications,
use_scene_builder_thread: self.use_scene_builder_thread,
generate_frame: self.generate_frame,
invalidate_rendered_frame: self.invalidate_rendered_frame,
low_priority: self.low_priority,
},
self.payloads,
)
}
/// See `ResourceUpdate::AddImage`.
pub fn add_image(
&mut self,
key: ImageKey,
descriptor: ImageDescriptor,
data: ImageData,
tiling: Option<TileSize>,
) {
self.resource_updates.push(ResourceUpdate::AddImage(AddImage {
key,
descriptor,
data,
tiling,
}));
}
/// See `ResourceUpdate::UpdateImage`.
pub fn update_image(
&mut self,
key: ImageKey,
descriptor: ImageDescriptor,
data: ImageData,
dirty_rect: &ImageDirtyRect,
) {
self.resource_updates.push(ResourceUpdate::UpdateImage(UpdateImage {
key,
descriptor,
data,
dirty_rect: *dirty_rect,
}));
}
/// See `ResourceUpdate::DeleteImage`.
pub fn delete_image(&mut self, key: ImageKey) {
self.resource_updates.push(ResourceUpdate::DeleteImage(key));
}
/// See `ResourceUpdate::AddBlobImage`.
pub fn add_blob_image(
&mut self,
key: BlobImageKey,
descriptor: ImageDescriptor,
data: Arc<BlobImageData>,
visible_rect: DeviceIntRect,
tiling: Option<TileSize>,
) {
self.resource_updates.push(
ResourceUpdate::AddBlobImage(AddBlobImage {
key,
descriptor,
data,
visible_rect,
tiling,
})
);
}
/// See `ResourceUpdate::UpdateBlobImage`.
pub fn update_blob_image(
&mut self,
key: BlobImageKey,
descriptor: ImageDescriptor,
data: Arc<BlobImageData>,
visible_rect: DeviceIntRect,
dirty_rect: &BlobDirtyRect,
) {
self.resource_updates.push(
ResourceUpdate::UpdateBlobImage(UpdateBlobImage {
key,
descriptor,
data,
visible_rect,
dirty_rect: *dirty_rect,
})
);
}
/// See `ResourceUpdate::DeleteBlobImage`.
pub fn delete_blob_image(&mut self, key: BlobImageKey) {
self.resource_updates.push(ResourceUpdate::DeleteImage(key.as_image()));
}
/// See `ResourceUpdate::SetBlobImageVisibleArea`.
pub fn set_blob_image_visible_area(&mut self, key: BlobImageKey, area: DeviceIntRect) {
self.resource_updates.push(ResourceUpdate::SetBlobImageVisibleArea(key, area))
}
/// See `ResourceUpdate::AddFont`.
pub fn add_raw_font(&mut self, key: font::FontKey, bytes: Vec<u8>, index: u32) {
self.resource_updates
.push(ResourceUpdate::AddFont(AddFont::Raw(key, bytes, index)));
}
/// See `ResourceUpdate::AddFont`.
pub fn add_native_font(&mut self, key: font::FontKey, native_handle: font::NativeFontHandle) {
self.resource_updates
.push(ResourceUpdate::AddFont(AddFont::Native(key, native_handle)));
}
/// See `ResourceUpdate::DeleteFont`.
pub fn delete_font(&mut self, key: font::FontKey) {
self.resource_updates.push(ResourceUpdate::DeleteFont(key));
}
/// See `ResourceUpdate::AddFontInstance`.
pub fn add_font_instance(
&mut self,
key: font::FontInstanceKey,
font_key: font::FontKey,
glyph_size: Au,
options: Option<font::FontInstanceOptions>,
platform_options: Option<font::FontInstancePlatformOptions>,
variations: Vec<font::FontVariation>,
) {
self.resource_updates
.push(ResourceUpdate::AddFontInstance(AddFontInstance {
key,
font_key,
glyph_size,
options,
platform_options,
variations,
}));
}
/// See `ResourceUpdate::DeleteFontInstance`.
pub fn delete_font_instance(&mut self, key: font::FontInstanceKey) {
self.resource_updates.push(ResourceUpdate::DeleteFontInstance(key));
}
/// A hint that this transaction can be processed at a lower priority. High-
/// priority transactions can jump ahead of regular-priority transactions,
/// but both high- and regular-priority transactions are processed in order
/// relative to other transactions of the same priority.
pub fn set_low_priority(&mut self, low_priority: bool) {
self.low_priority = low_priority;
}
/// Returns whether this transaction is marked as low priority.
pub fn is_low_priority(&self) -> bool {
self.low_priority
}
}
///
pub struct DocumentTransaction {
///
pub document_id: DocumentId,
///
pub transaction: Transaction,
}
/// Represents a transaction in the format sent through the channel.
#[derive(Clone, Deserialize, Serialize)]
pub struct TransactionMsg {
/// Changes that require re-building the scene.
pub scene_ops: Vec<SceneMsg>,
/// Changes to animated properties that do not require re-building the scene.
pub frame_ops: Vec<FrameMsg>,
/// Updates to resources that persist across display lists.
pub resource_updates: Vec<ResourceUpdate>,
/// Whether to trigger frame building and rendering if something has changed.
pub generate_frame: bool,
/// Whether to force frame building and rendering even if no changes are internally
/// observed.
pub invalidate_rendered_frame: bool,
/// Whether to enforce that this transaction go through the scene builder.
pub use_scene_builder_thread: bool,
///
pub low_priority: bool,
/// Handlers to notify at certain points of the pipeline.
#[serde(skip)]
pub notifications: Vec<NotificationRequest>,
}
impl fmt::Debug for TransactionMsg {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
writeln!(f, "threaded={}, genframe={}, invalidate={}, low_priority={}",
self.use_scene_builder_thread,
self.generate_frame,
self.invalidate_rendered_frame,
self.low_priority,
).unwrap();
for scene_op in &self.scene_ops {
writeln!(f, "\t\t{:?}", scene_op).unwrap();
}
for frame_op in &self.frame_ops {
writeln!(f, "\t\t{:?}", frame_op).unwrap();
}
for resource_update in &self.resource_updates {
writeln!(f, "\t\t{:?}", resource_update).unwrap();
}
Ok(())
}
}
impl TransactionMsg {
/// Returns true if this transaction has no effect.
pub fn is_empty(&self) -> bool {
!self.generate_frame &&
!self.invalidate_rendered_frame &&
self.scene_ops.is_empty() &&
self.frame_ops.is_empty() &&
self.resource_updates.is_empty() &&
self.notifications.is_empty()
}
/// Creates a transaction message from a single frame message.
pub fn frame_message(msg: FrameMsg) -> Self {
TransactionMsg {
scene_ops: Vec::new(),
frame_ops: vec![msg],
resource_updates: Vec::new(),
notifications: Vec::new(),
generate_frame: false,
invalidate_rendered_frame: false,
use_scene_builder_thread: false,
low_priority: false,
}
}
/// Creates a transaction message from a single scene message.
pub fn scene_message(msg: SceneMsg) -> Self {
TransactionMsg {
scene_ops: vec![msg],
frame_ops: Vec::new(),
resource_updates: Vec::new(),
notifications: Vec::new(),
generate_frame: false,
invalidate_rendered_frame: false,
use_scene_builder_thread: false,
low_priority: false,
}
}
}
/// Creates an image resource with provided parameters.
///
/// Must be matched with a `DeleteImage` at some point to prevent memory leaks.
#[derive(Clone, Deserialize, Serialize)]
pub struct AddImage {
/// A key to identify the image resource.
pub key: ImageKey,
/// Properties of the image.
pub descriptor: ImageDescriptor,
/// The pixels of the image.
pub data: ImageData,
/// An optional tiling scheme to apply when storing the image's data
/// on the GPU. Applies to both width and heights of the tiles.
///
/// Note that WebRender may internally chose to tile large images
/// even if this member is set to `None`.
pub tiling: Option<TileSize>,
}
/// Updates an already existing image resource.
#[derive(Clone, Deserialize, Serialize)]
pub struct UpdateImage {
/// The key identfying the image resource to update.
pub key: ImageKey,
/// Properties of the image.
pub descriptor: ImageDescriptor,
/// The pixels of the image.
pub data: ImageData,
/// An optional dirty rect that lets WebRender optimize the amount of
/// data to transfer to the GPU.
///
/// The data provided must still represent the entire image.
pub dirty_rect: ImageDirtyRect,
}
/// Creates a blob-image resource with provided parameters.
///
/// Must be matched with a `DeleteImage` at some point to prevent memory leaks.
#[derive(Clone, Deserialize, Serialize)]
pub struct AddBlobImage {
/// A key to identify the blob-image resource.
pub key: BlobImageKey,
/// Properties of the image.
pub descriptor: ImageDescriptor,
/// The blob-image's serialized commands.
pub data: Arc<BlobImageData>,
/// The portion of the plane in the blob-image's internal coordinate
/// system that is stretched to fill the image display item.
///
/// Unlike regular images, blob images are not limited in size. The
/// top-left corner of their internal coordinate system is also not
/// necessary at (0, 0).
/// This means that blob images can be updated to insert/remove content
/// in any direction to support panning and zooming.
pub visible_rect: DeviceIntRect,
/// An optional tiling scheme to apply when rasterizing the blob-image
/// and when storing its rasterized data on the GPU.
/// Applies to both width and heights of the tiles.
///
/// Note that WebRender may internally chose to tile large blob-images
/// even if this member is set to `None`.
pub tiling: Option<TileSize>,
}
/// Updates an already existing blob-image resource.
#[derive(Clone, Deserialize, Serialize)]
pub struct UpdateBlobImage {
/// The key identfying the blob-image resource to update.
pub key: BlobImageKey,
/// Properties of the image.
pub descriptor: ImageDescriptor,
/// The blob-image's serialized commands.
pub data: Arc<BlobImageData>,
/// See `AddBlobImage::visible_rect`.
pub visible_rect: DeviceIntRect,
/// An optional dirty rect that lets WebRender optimize the amount of
/// data to to rasterize and transfer to the GPU.
pub dirty_rect: BlobDirtyRect,
}
/// Creates a font resource.
///
/// Must be matched with a corresponding `ResourceUpdate::DeleteFont` at some point to prevent
/// memory leaks.
#[derive(Clone, Deserialize, Serialize)]
pub enum AddFont {
///
Raw(
font::FontKey,
#[serde(with = "serde_bytes")] Vec<u8>,
u32
),
///
Native(font::FontKey, font::NativeFontHandle),
}
/// Describe an item that matched a hit-test query.
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct HitTestItem {
/// The pipeline that the display item that was hit belongs to.
pub pipeline: PipelineId,
/// The tag of the hit display item.
pub tag: di::ItemTag,
/// The hit point in the coordinate space of the "viewport" of the display item. The
/// viewport is the scroll node formed by the root reference frame of the display item's
/// pipeline.
pub point_in_viewport: LayoutPoint,
/// The coordinates of the original hit test point relative to the origin of this item.
/// This is useful for calculating things like text offsets in the client.
pub point_relative_to_item: LayoutPoint,
}
/// Returned by `RenderApi::hit_test`.
#[derive(Clone, Debug, Default, Deserialize, Serialize)]
pub struct HitTestResult {
/// List of items that are match the hit-test query.
pub items: Vec<HitTestItem>,
}
bitflags! {
#[derive(Deserialize, MallocSizeOf, Serialize)]
///
pub struct HitTestFlags: u8 {
///
const FIND_ALL = 0b00000001;
///
const POINT_RELATIVE_TO_PIPELINE_VIEWPORT = 0b00000010;
}
}
/// Creates a font instance resource.
///
/// Must be matched with a corresponding `DeleteFontInstance` at some point
/// to prevent memory leaks.
#[derive(Clone, Deserialize, Serialize)]
pub struct AddFontInstance {
/// A key to identify the font instance.
pub key: font::FontInstanceKey,
/// The font resource's key.
pub font_key: font::FontKey,
/// Glyph size in app units.
pub glyph_size: Au,
///
pub options: Option<font::FontInstanceOptions>,
///
pub platform_options: Option<font::FontInstancePlatformOptions>,
///
pub variations: Vec<font::FontVariation>,
}
/// Frame messages affect building the scene.
#[derive(Clone, Deserialize, Serialize)]
pub enum SceneMsg {
///
UpdateEpoch(PipelineId, Epoch),
///
SetPageZoom(ZoomFactor),
///
SetRootPipeline(PipelineId),
///
RemovePipeline(PipelineId),
///
EnableFrameOutput(PipelineId, bool),
///
SetDisplayList {
///
list_descriptor: BuiltDisplayListDescriptor,
///
epoch: Epoch,
///
pipeline_id: PipelineId,
///
background: Option<ColorF>,
///
viewport_size: LayoutSize,
///
content_size: LayoutSize,
///
preserve_frame_state: bool,
},
///
SetDocumentView {
///
device_rect: DeviceIntRect,
///
device_pixel_ratio: f32,
},
/// Set the current quality / performance configuration for this document.
SetQualitySettings {
/// The set of available quality / performance config values.
settings: QualitySettings,
},
}
/// Frame messages affect frame generation (applied after building the scene).
#[derive(Clone, Deserialize, Serialize)]
pub enum FrameMsg {
///
UpdateEpoch(PipelineId, Epoch),
///
HitTest(Option<PipelineId>, WorldPoint, HitTestFlags, MsgSender<HitTestResult>),
///
RequestHitTester(MsgSender<Arc<dyn ApiHitTester>>),
///
SetPan(DeviceIntPoint),
///
Scroll(ScrollLocation, WorldPoint),
///
ScrollNodeWithId(LayoutPoint, di::ExternalScrollId, ScrollClamping),
///
GetScrollNodeState(MsgSender<Vec<ScrollNodeState>>),
///
UpdateDynamicProperties(DynamicProperties),
///
AppendDynamicTransformProperties(Vec<PropertyValue<LayoutTransform>>),
///
SetPinchZoom(ZoomFactor),
///
SetIsTransformAsyncZooming(bool, PropertyBindingId),
}
impl fmt::Debug for SceneMsg {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str(match *self {
SceneMsg::UpdateEpoch(..) => "SceneMsg::UpdateEpoch",
SceneMsg::SetDisplayList { .. } => "SceneMsg::SetDisplayList",
SceneMsg::SetPageZoom(..) => "SceneMsg::SetPageZoom",
SceneMsg::RemovePipeline(..) => "SceneMsg::RemovePipeline",
SceneMsg::EnableFrameOutput(..) => "SceneMsg::EnableFrameOutput",
SceneMsg::SetDocumentView { .. } => "SceneMsg::SetDocumentView",
SceneMsg::SetRootPipeline(..) => "SceneMsg::SetRootPipeline",
SceneMsg::SetQualitySettings { .. } => "SceneMsg::SetQualitySettings",
})
}
}
impl fmt::Debug for FrameMsg {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str(match *self {
FrameMsg::UpdateEpoch(..) => "FrameMsg::UpdateEpoch",
FrameMsg::HitTest(..) => "FrameMsg::HitTest",
FrameMsg::RequestHitTester(..) => "FrameMsg::RequestHitTester",
FrameMsg::SetPan(..) => "FrameMsg::SetPan",
FrameMsg::Scroll(..) => "FrameMsg::Scroll",
FrameMsg::ScrollNodeWithId(..) => "FrameMsg::ScrollNodeWithId",
FrameMsg::GetScrollNodeState(..) => "FrameMsg::GetScrollNodeState",
FrameMsg::UpdateDynamicProperties(..) => "FrameMsg::UpdateDynamicProperties",
FrameMsg::AppendDynamicTransformProperties(..) => "FrameMsg::AppendDynamicTransformProperties",
FrameMsg::SetPinchZoom(..) => "FrameMsg::SetPinchZoom",
FrameMsg::SetIsTransformAsyncZooming(..) => "FrameMsg::SetIsTransformAsyncZooming",
})
}
}
bitflags!{
/// Bit flags for WR stages to store in a capture.
// Note: capturing `FRAME` without `SCENE` is not currently supported.
#[derive(Deserialize, Serialize)]
pub struct CaptureBits: u8 {
///
const SCENE = 0x1;
///
const FRAME = 0x2;
///
const TILE_CACHE = 0x4;
}
}
bitflags!{
/// Mask for clearing caches in debug commands.
#[derive(Deserialize, Serialize)]
pub struct ClearCache: u8 {
///
const IMAGES = 0b1;
///
const GLYPHS = 0b01;
///
const GLYPH_DIMENSIONS = 0b001;
///
const RENDER_TASKS = 0b0001;
///
const TEXTURE_CACHE = 0b00001;
///
const RASTERIZED_BLOBS = 0b000001;
}
}
/// Information about a loaded capture of each document
/// that is returned by `RenderBackend`.
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CapturedDocument {
///
pub document_id: DocumentId,
///
pub root_pipeline_id: Option<PipelineId>,
}
/// Update of the state of built-in debugging facilities.
#[derive(Clone, Deserialize, Serialize)]
pub enum DebugCommand {
/// Sets the provided debug flags.
SetFlags(DebugFlags),
/// Configure if dual-source blending is used, if available.
EnableDualSourceBlending(bool),
/// Fetch current documents and display lists.
FetchDocuments,
/// Fetch current passes and batches.
FetchPasses,
// TODO: This should be called FetchClipScrollTree. However, that requires making
// changes to webrender's web debugger ui, touching a 4Mb minified file that
// is too big to submit through the conventional means.
/// Fetch the spatial tree.
FetchClipScrollTree,
/// Fetch render tasks.
FetchRenderTasks,
/// Fetch screenshot.
FetchScreenshot,
/// Save a capture of all the documents state.
SaveCapture(PathBuf, CaptureBits),
/// Load a capture of all the documents state.
LoadCapture(PathBuf, MsgSender<CapturedDocument>),
/// Clear cached resources, forcing them to be re-uploaded from templates.
ClearCaches(ClearCache),
/// Enable/disable native compositor usage
EnableNativeCompositor(bool),
/// Enable/disable parallel job execution with rayon.
EnableMultithreading(bool),
/// Sets the maximum amount of existing batches to visit before creating a new one.
SetBatchingLookback(u32),
/// Invalidate GPU cache, forcing the update from the CPU mirror.
InvalidateGpuCache,
/// Causes the scene builder to pause for a given amount of milliseconds each time it
/// processes a transaction.
SimulateLongSceneBuild(u32),
/// Causes the low priority scene builder to pause for a given amount of milliseconds
/// each time it processes a transaction.
SimulateLongLowPrioritySceneBuild(u32),
/// Logs transactions to a file for debugging purposes
SetTransactionLogging(bool),
/// Set an override tile size to use for picture caches
SetPictureTileSize(Option<DeviceIntSize>),
}
/// Message sent by the `RenderApi` to the render backend thread.
#[derive(Clone, Deserialize, Serialize)]
pub enum ApiMsg {
/// Add/remove/update images and fonts.
UpdateResources(Vec<ResourceUpdate>),