Add util::drain_filter.

webrender/src/render_backend.rs

@@ -9,6 +9,7 @@ use api::{DeviceIntPoint, DevicePixelScale, DeviceUintPoint, DeviceUintRect, Dev
 use api::{DocumentId, DocumentLayer, ExternalScrollId, FrameMsg, HitTestFlags, HitTestResult};
 use api::{IdNamespace, LayoutPoint, PipelineId, RenderNotifier, SceneMsg, ScrollClamping};
 use api::{ScrollLocation, ScrollNodeState, TransactionMsg, ResourceUpdate, ImageKey};
+use api::ExternalEvent;
 use api::channel::{MsgReceiver, Payload};
 #[cfg(feature = "capture")]
 use api::CaptureBits;

webrender/src/resource_cache.rs

@@ -42,6 +42,7 @@ use std::path::PathBuf;
 use std::sync::{Arc, RwLock};
 use texture_cache::{TextureCache, TextureCacheHandle, Eviction};
 use tiling::SpecialRenderPasses;
+use util::drain_filter;
 
 const DEFAULT_TILE_SIZE: TileSize = 512;
 
@@ -518,9 +519,8 @@ impl ResourceCache {
         updates: &mut Vec<ResourceUpdate>,
         profile_counters: &mut ResourceProfileCounters,
     ) {
-        let mut new_updates = Vec::with_capacity(updates.len());
-        for update in mem::replace(updates, Vec::new()) {
-            match update {
+        for update in updates.iter() {
+            match *update {
                 ResourceUpdate::AddImage(ref img) => {
                     if let ImageData::Blob(ref blob_data) = img.data {
                         self.add_blob_image(
@@ -541,7 +541,7 @@ impl ResourceCache {
                         );
                     }
                 }
-                ResourceUpdate::SetImageVisibleArea(key, area) => {
+                ResourceUpdate::SetImageVisibleArea(ref key, ref area) => {
                     if let Some(template) = self.blob_image_templates.get_mut(&key) {
                         if let Some(tile_size) = template.tiling {
                             template.viewport_tiles = Some(compute_tile_range(
@@ -554,8 +554,17 @@ impl ResourceCache {
                 }
                 _ => {}
             }
+        }
 
-            match update {
+        drain_filter(
+            updates,
+            |update| match *update {
+                ResourceUpdate::AddFont(_) |
+                ResourceUpdate::AddFontInstance(_) => true,
+                _ => false,
+            },
+            // Updates that were moved out of the array:
+            |update: ResourceUpdate| match update {
                 ResourceUpdate::AddFont(font) => {
                     match font {
                         AddFont::Raw(id, bytes, index) => {
@@ -567,7 +576,7 @@ impl ResourceCache {
                         }
                     }
                 }
-                ResourceUpdate::AddFontInstance(mut instance) => {
+                ResourceUpdate::AddFontInstance(instance) => {
                     self.add_font_instance(
                         instance.key,
                         instance.font_key,
@@ -577,13 +586,9 @@ impl ResourceCache {
                         instance.variations,
                     );
                 }
-                other => {
-                    new_updates.push(other);
-                }
+                _ => { unreachable!(); }
             }
-        }
-
-        *updates = new_updates;
+        );
     }
 
     pub fn set_blob_rasterizer(&mut self, rasterizer: Box<AsyncBlobImageRasterizer>) {

webrender/src/util.rs

@@ -508,3 +508,63 @@ pub fn world_rect_to_device_pixels(
     let device_rect = rect * device_pixel_scale;
     device_rect.round_out()
 }
+
+/// Run the first callback over all elements in the array. If the callback returns true,
+/// the element is removed from the array and moved to a second callback.
+///
+/// This is a simple implementation waiting for Vec::drain_filter to be stable.
+/// When that happens, code like:
+///
+/// let filter = |op| {
+///     match *op {
+///         Enum::Foo | Enum::Bar => true,
+///         Enum::Baz => false,
+///     }
+/// };
+/// drain_filter(
+///     &mut ops,
+///     filter,
+///     |op| {
+///         match op {
+///             Enum::Foo => { foo(); }
+///             Enum::Bar => { bar(); }
+///             Enum::Baz => { unreachable!(); }
+///         }
+///     },
+/// );
+///
+/// Can be rewritten as:
+///
+/// let filter = |op| {
+///     match *op {
+///         Enum::Foo | Enum::Bar => true,
+///         Enum::Baz => false,
+///     }
+/// };
+/// for op in ops.drain_filter(filter) {
+///     match op {
+///         Enum::Foo => { foo(); }
+///         Enum::Bar => { bar(); }
+///         Enum::Baz => { unreachable!(); }
+///     }
+/// }
+///
+/// See https://doc.rust-lang.org/std/vec/struct.Vec.html#method.drain_filter
+pub fn drain_filter<T, Filter, Action>(
+    vec: &mut Vec<T>,
+    mut filter: Filter,
+    mut action: Action,
+)
+where
+    Filter: FnMut(&mut T) -> bool,
+    Action: FnMut(T)
+{
+    let mut i = 0;
+    while i != vec.len() {
+        if filter(&mut vec[i]) {
+            action(vec.remove(i));
+        } else {
+            i += 1;
+        }
+    }
+}