Move AuxiliaryListsBuilder into DisplayListBuilder

This makes it a bit less complicated to use the WebRender API and hides
some details that might change later.

Fixes #574.

sample/src/main.rs

@@ -7,8 +7,7 @@ extern crate euclid;
 use euclid::{Size2D, Point2D, Rect, Matrix4D};
 use gleam::gl;
 use std::path::PathBuf;
-use std::ffi::CStr;
-use webrender_traits::{AuxiliaryListsBuilder, ColorF, Epoch, GlyphInstance};
+use webrender_traits::{ColorF, Epoch, GlyphInstance};
 use webrender_traits::{ImageData, ImageFormat, PipelineId, RendererKind};
 use std::fs::File;
 use std::io::Read;
@@ -106,20 +105,17 @@ fn main() {
     let epoch = Epoch(0);
     let root_background_color = ColorF::new(0.3, 0.0, 0.0, 1.0);
 
-    let mut auxiliary_lists_builder = AuxiliaryListsBuilder::new();
     let mut builder = webrender_traits::DisplayListBuilder::new();
 
     let bounds = Rect::new(Point2D::new(0.0, 0.0), Size2D::new(width as f32, height as f32));
-    builder.push_stacking_context(
-        webrender_traits::StackingContext::new(webrender_traits::ScrollPolicy::Scrollable,
-                                               bounds,
-                                               bounds,
-                                               0,
-                                               &Matrix4D::identity(),
-                                               &Matrix4D::identity(),
-                                               webrender_traits::MixBlendMode::Normal,
-                                               Vec::new(),
-                                               &mut auxiliary_lists_builder));
+    builder.push_stacking_context(webrender_traits::ScrollPolicy::Scrollable,
+                                  bounds,
+                                  bounds,
+                                  0,
+                                  &Matrix4D::identity(),
+                                  &Matrix4D::identity(),
+                                  webrender_traits::MixBlendMode::Normal,
+                                  Vec::new());
 
     let clip_region = {
         let mask = webrender_traits::ImageMask {
@@ -132,10 +128,7 @@ fn main() {
             Rect::new(Point2D::new(50.0, 50.0), Size2D::new(100.0, 100.0)),
             radius);
 
-        webrender_traits::ClipRegion::new(&bounds,
-                                          vec![complex],
-                                          Some(mask),
-                                          &mut auxiliary_lists_builder)
+        builder.new_clip_region(&bounds, vec![complex], Some(mask))
     };
 
     builder.push_rect(Rect::new(Point2D::new(100.0, 100.0), Size2D::new(100.0, 100.0)),
@@ -207,24 +200,14 @@ fn main() {
         },
     ];
 
-//     builder.push_text(text_bounds,
-//                       clip_region,
-//                       glyphs,
-//                       font_key,
-//                       ColorF::new(1.0, 1.0, 0.0, 1.0),
-//                       Au::from_px(32),
-//                       Au::from_px(0),
-//                       &mut frame_builder.auxiliary_lists_builder);
-
     builder.pop_stacking_context();
 
     api.set_root_display_list(
         root_background_color,
         epoch,
         pipeline_id,
         Size2D::new(width as f32, height as f32),
-        builder.finalize(),
-        auxiliary_lists_builder.finalize());
+        builder);
     api.set_root_pipeline(pipeline_id);
 
     for event in window.wait_events() {

webrender_traits/src/api.rs

@@ -7,7 +7,7 @@ use channel::{self, MsgSender, PayloadHelperMethods, PayloadSender};
 use euclid::{Point2D, Size2D};
 use offscreen_gl_context::{GLContextAttributes, GLLimits};
 use std::cell::Cell;
-use {ApiMsg, AuxiliaryLists, BuiltDisplayList, ColorF, Epoch};
+use {ApiMsg, ColorF, DisplayListBuilder, Epoch};
 use {FontKey, IdNamespace, ImageFormat, ImageKey, NativeFontHandle, PipelineId};
 use {RenderApiSender, ResourceId, ScrollEventPhase, ScrollLayerState, ServoScrollRootId};
 use {GlyphKey, GlyphDimensions, ImageData, WebGLContextId, WebGLCommand};
@@ -167,8 +167,8 @@ impl RenderApi {
                                  epoch: Epoch,
                                  pipeline_id: PipelineId,
                                  viewport_size: Size2D<f32>,
-                                 display_list: BuiltDisplayList,
-                                 auxiliary_lists: AuxiliaryLists) {
+                                 builder: DisplayListBuilder) {
+        let (display_list, auxiliary_lists) = builder.finalize();
         let msg = ApiMsg::SetRootDisplayList(background_color,
                                              epoch,
                                              pipeline_id,

webrender_traits/src/display_list.rs

@@ -3,17 +3,18 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use app_units::Au;
-use euclid::{Point2D, Rect, Size2D};
+use euclid::{Matrix4D, Point2D, Rect, Size2D};
 use std::mem;
 use std::slice;
 use {AuxiliaryLists, AuxiliaryListsDescriptor, BorderDisplayItem, BorderRadius};
 use {BorderSide, BoxShadowClipMode, BoxShadowDisplayItem, BuiltDisplayList};
 use {BuiltDisplayListDescriptor, ClipRegion, ComplexClipRegion, ColorF};
 use {DisplayItem, DisplayListMode, FilterOp, YuvColorSpace};
 use {FontKey, GlyphInstance, GradientDisplayItem, GradientStop, IframeDisplayItem};
-use {ImageDisplayItem, YuvImageDisplayItem, ImageKey, ImageRendering, ItemRange, PipelineId,};
+use {ImageDisplayItem, ImageKey, ImageMask, ImageRendering, ItemRange, MixBlendMode, PipelineId};
 use {PushScrollLayerItem, PushStackingContextDisplayItem, RectangleDisplayItem, ScrollLayerId};
-use {SpecificDisplayItem, StackingContext, TextDisplayItem, WebGLContextId, WebGLDisplayItem};
+use {ScrollPolicy, SpecificDisplayItem, StackingContext, TextDisplayItem, WebGLContextId};
+use {WebGLDisplayItem, YuvImageDisplayItem};
 
 impl BuiltDisplayListDescriptor {
     pub fn size(&self) -> usize {
@@ -47,13 +48,15 @@ impl BuiltDisplayList {
 pub struct DisplayListBuilder {
     pub mode: DisplayListMode,
     pub list: Vec<DisplayItem>,
+    auxiliary_lists_builder: AuxiliaryListsBuilder,
 }
 
 impl DisplayListBuilder {
     pub fn new() -> DisplayListBuilder {
         DisplayListBuilder {
             mode: DisplayListMode::Default,
             list: Vec::new(),
+            auxiliary_lists_builder: AuxiliaryListsBuilder::new(),
         }
     }
 
@@ -146,8 +149,7 @@ impl DisplayListBuilder {
                      font_key: FontKey,
                      color: ColorF,
                      size: Au,
-                     blur_radius: Au,
-                     auxiliary_lists_builder: &mut AuxiliaryListsBuilder) {
+                     blur_radius: Au) {
         // Sanity check - anything with glyphs bigger than this
         // is probably going to consume too much memory to render
         // efficiently anyway. This is specifically to work around
@@ -157,7 +159,7 @@ impl DisplayListBuilder {
         if size < Au::from_px(4096) {
             let item = TextDisplayItem {
                 color: color,
-                glyphs: auxiliary_lists_builder.add_glyph_instances(&glyphs),
+                glyphs: self.auxiliary_lists_builder.add_glyph_instances(&glyphs),
                 font_key: font_key,
                 size: size,
                 blur_radius: blur_radius,
@@ -232,12 +234,11 @@ impl DisplayListBuilder {
                          clip: ClipRegion,
                          start_point: Point2D<f32>,
                          end_point: Point2D<f32>,
-                         stops: Vec<GradientStop>,
-                         auxiliary_lists_builder: &mut AuxiliaryListsBuilder) {
+                         stops: Vec<GradientStop>) {
         let item = GradientDisplayItem {
             start_point: start_point,
             end_point: end_point,
-            stops: auxiliary_lists_builder.add_gradient_stops(&stops),
+            stops: self.auxiliary_lists_builder.add_gradient_stops(&stops),
         };
 
         let display_item = DisplayItem {
@@ -249,7 +250,26 @@ impl DisplayListBuilder {
         self.list.push(display_item);
     }
 
-    pub fn push_stacking_context(&mut self, stacking_context: StackingContext) {
+    pub fn push_stacking_context(&mut self, 
+                                 scroll_policy: ScrollPolicy,
+                                 bounds: Rect<f32>,
+                                 overflow: Rect<f32>,
+                                 z_index: i32,
+                                 transform: &Matrix4D<f32>,
+                                 perspective: &Matrix4D<f32>,
+                                 mix_blend_mode: MixBlendMode,
+                                 filters: Vec<FilterOp>) {
+        let stacking_context = StackingContext {
+            scroll_policy: scroll_policy,
+            bounds: bounds,
+            overflow: overflow,
+            z_index: z_index,
+            transform: transform.clone(),
+            perspective: perspective.clone(),
+            mix_blend_mode: mix_blend_mode,
+            filters: self.auxiliary_lists_builder.add_filters(&filters),
+        };
+
         let item = DisplayItem {
             item: SpecificDisplayItem::PushStackingContext(PushStackingContextDisplayItem {
                 stacking_context: stacking_context
@@ -304,19 +324,28 @@ impl DisplayListBuilder {
         self.list.push(item);
     }
 
-    pub fn finalize(self) -> BuiltDisplayList {
+    pub fn new_clip_region(&mut self,
+                           rect: &Rect<f32>,
+                           complex: Vec<ComplexClipRegion>,
+                           image_mask: Option<ImageMask>)
+                           -> ClipRegion {
+        ClipRegion::new(rect, complex, image_mask, &mut self.auxiliary_lists_builder)
+    }
+
+    pub fn finalize(self) -> (BuiltDisplayList, AuxiliaryLists) {
         unsafe {
             let blob = convert_pod_to_blob(&self.list).to_vec();
             let display_list_items_size = blob.len();
 
-            BuiltDisplayList {
-                descriptor: BuiltDisplayListDescriptor {
-                    mode: self.mode,
-                    display_list_items_size: display_list_items_size,
-                    display_items_size: 0,
-                },
-                data: blob,
-            }
+            (BuiltDisplayList {
+                 descriptor: BuiltDisplayListDescriptor {
+                     mode: self.mode,
+                     display_list_items_size: display_list_items_size,
+                     display_items_size: 0,
+                 },
+                 data: blob,
+             },
+             self.auxiliary_lists_builder.finalize())
         }
     }
 }

webrender_traits/src/lib.rs

@@ -42,5 +42,5 @@ mod stacking_context;
 mod webgl;
 
 pub use api::RenderApi;
-pub use display_list::{AuxiliaryListsBuilder, DisplayListBuilder};
+pub use display_list::DisplayListBuilder;
 pub use units::*;