1455422 - (async-blob) Make blob rendering not block the render thread.

Status: RESOLVED FIXED

(Core :: Graphics: WebRender, enhancement, P1)

Description

[Jeff Muizelaar [:jrmuizel]]

I recall Nical thinking this would be easy.

Comment 1

[Nicolas Silva [:nical]]

Attachment: (WIP) Provide webrender with the visible are of each blob image.

This is the Gecko side of things, most of the work being in https://github.com/servo/webrender/pull/2785

It doesn't currently work: WebRender sometimes to requests tiles outside of the area generated by intersecting the viewport and the image display item so I guess something is wrong in the way I am trying to generate this visible rect. Might be that I can't assume that the reference frame of the first display item is enough, might be something else, not sure yet.

Comment 2

[Nicolas Silva [:nical]]

Attachment: (WIP) Provide webrender with the visible are of each blob image.

Another version that uses the wrapping display item's paint rect thanks to mstange's help.

Comment 3

[Nicolas Silva [:nical]]

Comment on attachment 8988686 [details] [diff] [review]
(WIP) Provide webrender with the visible are of each blob image.

># HG changeset patch
># User Nicolas Silva <[e-mail]>
># Parent  d8c4d67e3689c7c9a15baaa3598091f727b99266
>
>diff --git a/gfx/layers/ipc/WebRenderMessages.ipdlh b/gfx/layers/ipc/WebRenderMessages.ipdlh
>--- a/gfx/layers/ipc/WebRenderMessages.ipdlh
>+++ b/gfx/layers/ipc/WebRenderMessages.ipdlh
>@@ -21,16 +21,17 @@ using mozilla::wr::MaybeFontInstanceOpti
> using mozilla::wr::MaybeFontInstancePlatformOptions from "mozilla/webrender/WebRenderTypes.h";
> using mozilla::wr::FontInstanceKey from "mozilla/webrender/WebRenderTypes.h";
> using mozilla::wr::FontKey from "mozilla/webrender/WebRenderTypes.h";
> using mozilla::wr::ImageKey from "mozilla/webrender/WebRenderTypes.h";
> using mozilla::wr::PipelineId from "mozilla/webrender/WebRenderTypes.h";
> using mozilla::gfx::MaybeIntSize from "mozilla/gfx/Point.h";
> using mozilla::LayoutDeviceRect from "Units.h";
> using mozilla::ImageIntRect from "Units.h";
>+using mozilla::gfx::Rect from "mozilla/gfx/Rect.h";
> using class mozilla::gfx::Matrix4x4 from "mozilla/gfx/Matrix.h";
> using struct mozilla::void_t from "ipc/IPCMessageUtils.h";
> 
> namespace mozilla {
> namespace layers {
> 
> struct RefCountedShmem {
>   Shmem buffer;
>@@ -121,16 +122,21 @@ struct OpUpdateImage {
> 
> struct OpUpdateBlobImage {
>   ImageDescriptor descriptor;
>   OffsetRange bytes;
>   ImageKey key;
>   ImageIntRect dirtyRect;
> };
> 
>+struct OpSetImageVisibleArea {
>+  Rect area;
>+  ImageKey key;
>+};
>+
> struct OpDeleteImage {
>   ImageKey key;
> };
> 
> struct OpAddRawFont {
>   OffsetRange bytes;
>   uint32_t fontIndex;
>   FontKey key;
>@@ -159,16 +165,17 @@ struct OpDeleteFontInstance {
>   FontInstanceKey key;
> };
> 
> union OpUpdateResource {
>   OpAddImage;
>   OpAddBlobImage;
>   OpUpdateImage;
>   OpUpdateBlobImage;
>+  OpSetImageVisibleArea;
>   OpDeleteImage;
>   OpAddRawFont;
>   OpAddFontDescriptor;
>   OpDeleteFont;
>   OpAddFontInstance;
>   OpDeleteFontInstance;
>   OpAddExternalImage;
> };
>diff --git a/gfx/layers/wr/IpcResourceUpdateQueue.cpp b/gfx/layers/wr/IpcResourceUpdateQueue.cpp
>--- a/gfx/layers/wr/IpcResourceUpdateQueue.cpp
>+++ b/gfx/layers/wr/IpcResourceUpdateQueue.cpp
>@@ -302,16 +302,22 @@ IpcResourceUpdateQueue::UpdateBlobImage(
>   if (!bytes.length()) {
>     return false;
>   }
>   mUpdates.AppendElement(layers::OpUpdateBlobImage(aDescriptor, bytes, aKey, aDirtyRect));
>   return true;
> }
> 
> void
>+IpcResourceUpdateQueue::SetImageVisibleArea(ImageKey aKey, const gfx::Rect& aArea)
>+{
>+  mUpdates.AppendElement(layers::OpSetImageVisibleArea(aArea, aKey));
>+}
>+
>+void
> IpcResourceUpdateQueue::DeleteImage(ImageKey aKey)
> {
>   mUpdates.AppendElement(layers::OpDeleteImage(aKey));
> }
> 
> bool
> IpcResourceUpdateQueue::AddRawFont(wr::FontKey aKey, Range<uint8_t> aBytes, uint32_t aIndex)
> {
>diff --git a/gfx/layers/wr/IpcResourceUpdateQueue.h b/gfx/layers/wr/IpcResourceUpdateQueue.h
>--- a/gfx/layers/wr/IpcResourceUpdateQueue.h
>+++ b/gfx/layers/wr/IpcResourceUpdateQueue.h
>@@ -93,16 +93,18 @@ public:
>                        ImageIntRect aDirtyRect);
> 
>   void UpdateExternalImage(ImageKey aKey,
>                            const ImageDescriptor& aDescriptor,
>                            ExternalImageId aExtID,
>                            wr::WrExternalImageBufferType aBufferType,
>                            uint8_t aChannelIndex = 0);
> 
>+  void SetImageVisibleArea(ImageKey aKey, const gfx::Rect& aArea);
>+
>   void DeleteImage(wr::ImageKey aKey);
> 
>   bool AddRawFont(wr::FontKey aKey, Range<uint8_t> aBytes, uint32_t aIndex);
> 
>   bool AddFontDescriptor(wr::FontKey aKey, Range<uint8_t> aBytes, uint32_t aIndex);
> 
>   void DeleteFont(wr::FontKey aKey);
> 
>diff --git a/gfx/layers/wr/WebRenderBridgeParent.cpp b/gfx/layers/wr/WebRenderBridgeParent.cpp
>--- a/gfx/layers/wr/WebRenderBridgeParent.cpp
>+++ b/gfx/layers/wr/WebRenderBridgeParent.cpp
>@@ -309,16 +309,26 @@ WebRenderBridgeParent::UpdateResources(c
>         const auto& op = cmd.get_OpUpdateBlobImage();
>         wr::Vec<uint8_t> bytes;
>         if (!reader.Read(op.bytes(), bytes)) {
>           return false;
>         }
>         aUpdates.UpdateBlobImage(op.key(), op.descriptor(), bytes, wr::ToDeviceUintRect(op.dirtyRect()));
>         break;
>       }
>+      case OpUpdateResource::TOpSetImageVisibleArea: {
>+        const auto& op = cmd.get_OpSetImageVisibleArea();
>+        wr::NormalizedRect area;
>+        area.origin.x = op.area().x;
>+        area.origin.y = op.area().y;
>+        area.size.width = op.area().width;
>+        area.size.height = op.area().height;
>+        aUpdates.SetImageVisibleArea(op.key(), area);
>+        break;
>+      }
>       case OpUpdateResource::TOpAddExternalImage: {
>         const auto& op = cmd.get_OpAddExternalImage();
>         if (!AddExternalImage(op.externalImageId(), op.key(), aUpdates)) {
>           return false;
>         }
>         break;
>       }
>       case OpUpdateResource::TOpAddRawFont: {
>diff --git a/gfx/layers/wr/WebRenderCommandBuilder.cpp b/gfx/layers/wr/WebRenderCommandBuilder.cpp
>--- a/gfx/layers/wr/WebRenderCommandBuilder.cpp
>+++ b/gfx/layers/wr/WebRenderCommandBuilder.cpp
>@@ -58,16 +58,54 @@ static void GP(const char *fmt, ...) {
> // and the invalid rect will be the new area
> 
> struct BlobItemData;
> static void DestroyBlobGroupDataProperty(nsTArray<BlobItemData*>* aArray);
> NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(BlobGroupDataProperty,
>                                     nsTArray<BlobItemData*>,
>                                     DestroyBlobGroupDataProperty);
> 
>+static Maybe<nsRect>
>+GetViewportRectRelativeToFrame(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame)
>+{
>+  nsIFrame* rootFrame = aFrame->PresShell()->GetRootFrame();
>+  nsRect rootRect = rootFrame->GetRectRelativeToSelf();
>+  if (nsLayoutUtils::TransformRect(rootFrame, aFrame, rootRect) == nsLayoutUtils::TRANSFORM_SUCCEEDED) {
>+    return Some(rootRect + aBuilder->ToReferenceFrame(aFrame));
>+  }
>+  return Nothing();
>+}
>+
>+static void
>+SetBlobImageVisibleArea(nsDisplayListBuilder* aDisplayListBuilder,
>+                        wr::IpcResourceUpdateQueue& aResources,
>+                        nsIFrame* aReferenceFrame,
>+                        wr::ImageKey aImageKey,
>+                        const LayoutDeviceRect& aImageRect)
>+{
>+  // nsIFrame* frame = aItem->Frame();
>+  if (Maybe<nsRect> viewportRect = GetViewportRectRelativeToFrame(aDisplayListBuilder,
>+                                                                  aReferenceFrame)) {
>+    const int32_t appUnitsPerDevPixel = aReferenceFrame->PresContext()->AppUnitsPerDevPixel();
>+    LayoutDeviceRect visibleRect = LayoutDeviceRect::FromAppUnits(
>+      viewportRect.value(),
>+      appUnitsPerDevPixel
>+    ).Intersect(aImageRect);
>+
>+    // Send the visible rect in normalized coordinates.
>+    Rect visibleArea = Rect((visibleRect.x - aImageRect.x) / aImageRect.width,
>+                            (visibleRect.y - aImageRect.y) / aImageRect.height,
>+                            visibleRect.width / aImageRect.width,
>+                            visibleRect.height / aImageRect.height);
>+
>+    aResources.SetImageVisibleArea(aImageKey, visibleArea);
>+  }
>+}
>+
>+
> // These are currently manually allocated and ownership is help by the mDisplayItems
> // hash table in DIGroup
> struct BlobItemData
> {
>   // a weak pointer to the frame for this item.
>   // DisplayItemData has a mFrameList to deal with merged frames. Hopefully we
>   // don't need to worry about that.
>   nsIFrame* mFrame;
>@@ -214,17 +252,18 @@ struct Grouper
>   Matrix mTransform;
> 
>   // Paint the list of aChildren display items.
>   void PaintContainerItem(DIGroup* aGroup, nsDisplayItem* aItem, const IntRect& aItemBounds,
>                           nsDisplayList* aChildren, gfxContext* aContext,
>                           WebRenderDrawEventRecorder* aRecorder);
> 
>   // Builds groups of display items split based on 'layer activity'
>-  void ConstructGroups(WebRenderCommandBuilder* aCommandBuilder,
>+  void ConstructGroups(nsDisplayListBuilder* aDisplayListBuilder,
>+                       WebRenderCommandBuilder* aCommandBuilder,
>                        wr::DisplayListBuilder& aBuilder,
>                        wr::IpcResourceUpdateQueue& aResources,
>                        DIGroup* aGroup, nsDisplayList* aList,
>                        const StackingContextHelper& aSc);
>   // Builds a group of display items without promoting anything to active.
>   void ConstructGroupInsideInactive(WebRenderCommandBuilder* aCommandBuilder,
>                                        wr::DisplayListBuilder& aBuilder,
>                                        wr::IpcResourceUpdateQueue& aResources,
>@@ -537,16 +576,17 @@ struct DIGroup
>     aData->mClip = clip;
>     aData->mMatrix = aMatrix;
>     aData->mGroupOffset = mLayerBounds.TopLeft();
>     aData->mImageRect = imageRect;
>     GP("post mInvalidRect: %d %d %d %d\n", mInvalidRect.x, mInvalidRect.y, mInvalidRect.width, mInvalidRect.height);
>   }
> 
>   void EndGroup(WebRenderLayerManager* aWrManager,
>+                nsDisplayListBuilder* aDisplayListBuilder,
>                 wr::DisplayListBuilder& aBuilder,
>                 wr::IpcResourceUpdateQueue& aResources,
>                 Grouper* aGrouper,
>                 nsDisplayItem* aStartItem,
>                 nsDisplayItem* aEndItem)
>   {
>     mLastAnimatedGeometryRootOrigin = mAnimatedGeometryRootOrigin;
>     GP("\n\n");
>@@ -573,16 +613,21 @@ struct DIGroup
>     IntSize dtSize = layerBounds.Size().ToUnknownSize();
>     LayoutDeviceRect bounds = (LayerRect(layerBounds) - mResidualOffset) / scale;
> 
>     if (mInvalidRect.IsEmpty()) {
>       GP("Not repainting group because it's empty\n");
>       GP("End EndGroup\n");
>       if (mKey) {
>         PushImage(aBuilder, bounds);
>+        SetBlobImageVisibleArea(aDisplayListBuilder,
>+                                aResources,
>+                                aStartItem->Frame(),
>+                                mKey.value(),
>+                                bounds);
>       }
>       return;
>     }
> 
>     gfx::SurfaceFormat format = gfx::SurfaceFormat::B8G8R8A8;
>     RefPtr<WebRenderDrawEventRecorder> recorder =
>       MakeAndAddRef<WebRenderDrawEventRecorder>(
>         [&](MemStream& aStream, std::vector<RefPtr<UnscaledFont>>& aUnscaledFonts) {
>@@ -641,16 +686,21 @@ struct DIGroup
>       MOZ_RELEASE_ASSERT(bottomRight.x <= dtSize.width && bottomRight.y <= dtSize.height);
>       GP("Update Blob %d %d %d %d\n", mInvalidRect.x, mInvalidRect.y, mInvalidRect.width, mInvalidRect.height);
>       if (!aResources.UpdateBlobImage(mKey.value(), descriptor, bytes, ViewAs<ImagePixel>(mInvalidRect))) {
>         return;
>       }
>     }
>     mInvalidRect.SetEmpty();
>     PushImage(aBuilder, bounds);
>+    SetBlobImageVisibleArea(aDisplayListBuilder,
>+                            aResources,
>+                            aStartItem->Frame(),
>+                            mKey.value(),
>+                            bounds);
>     GP("End EndGroup\n\n");
>   }
> 
>   void PushImage(wr::DisplayListBuilder& aBuilder, const LayoutDeviceRect& bounds)
>   {
>     wr::LayoutRect dest = wr::ToLayoutRect(bounds);
>     GP("PushImage: %f %f %f %f\n", dest.origin.x, dest.origin.y, dest.size.width, dest.size.height);
>     gfx::SamplingFilter sampleFilter = gfx::SamplingFilter::LINEAR; //nsLayoutUtils::GetSamplingFilterForFrame(aItem->Frame());
>@@ -909,30 +959,31 @@ GetBlobItemDataForGroup(nsDisplayItem* a
>   }
>   data->mUsed = true;
>   return data;
> }
> 
> // This does a pass over the display lists and will join the display items
> // into groups as well as paint them
> void
>-Grouper::ConstructGroups(WebRenderCommandBuilder* aCommandBuilder,
>+Grouper::ConstructGroups(nsDisplayListBuilder* aDisplayListBuilder,
>+                         WebRenderCommandBuilder* aCommandBuilder,
>                          wr::DisplayListBuilder& aBuilder,
>                          wr::IpcResourceUpdateQueue& aResources,
>                          DIGroup* aGroup, nsDisplayList* aList,
>                          const StackingContextHelper& aSc)
> {
>   DIGroup* currentGroup = aGroup;
> 
>   nsDisplayItem* item = aList->GetBottom();
>   nsDisplayItem* startOfCurrentGroup = item;
>   while (item) {
>     nsDisplayList* children = item->GetChildren();
>     if (IsItemProbablyActive(item, mDisplayListBuilder)) {
>-      currentGroup->EndGroup(aCommandBuilder->mManager, aBuilder, aResources, this, startOfCurrentGroup, item);
>+      currentGroup->EndGroup(aCommandBuilder->mManager, aDisplayListBuilder, aBuilder, aResources, this, startOfCurrentGroup, item);
>       mClipManager.BeginItem(item, aSc);
>       sIndent++;
>       // Note: this call to CreateWebRenderCommands can recurse back into
>       // this function.
>       bool createdWRCommands =
>         item->CreateWebRenderCommands(aBuilder, aResources, aSc, aCommandBuilder->mManager,
>                                       mDisplayListBuilder);
>       sIndent--;
>@@ -996,17 +1047,17 @@ Grouper::ConstructGroups(WebRenderComman
> 
>       BlobItemData* data = GetBlobItemDataForGroup(item, currentGroup);
>       currentGroup->ComputeGeometryChange(item, data, mTransform, mDisplayListBuilder); // we compute the geometry change here because we have the transform around still
>     }
> 
>     item = item->GetAbove();
>   }
> 
>-  currentGroup->EndGroup(aCommandBuilder->mManager, aBuilder, aResources, this, startOfCurrentGroup, nullptr);
>+  currentGroup->EndGroup(aCommandBuilder->mManager, aDisplayListBuilder, aBuilder, aResources, this, startOfCurrentGroup, nullptr);
> }
> 
> // This does a pass over the display lists and will join the display items
> // into a single group.
> void
> Grouper::ConstructGroupInsideInactive(WebRenderCommandBuilder* aCommandBuilder,
>                                        wr::DisplayListBuilder& aBuilder,
>                                        wr::IpcResourceUpdateQueue& aResources,
>@@ -1131,17 +1182,17 @@ WebRenderCommandBuilder::DoGroupingForDi
>                                                                                 scale.height,
>                                                                                 group.mAppUnitsPerDevPixel,
>                                                                                 residualOffset));
>   g.mTransform = Matrix::Scaling(scale.width, scale.height)
>                                 .PostTranslate(residualOffset.x, residualOffset.y);
>   group.mScale = scale;
>   group.mScrollId = scrollId;
>   group.mAnimatedGeometryRootOrigin = group.mGroupBounds.TopLeft();
>-  g.ConstructGroups(this, aBuilder, aResources, &group, aList, aSc);
>+  g.ConstructGroups(aDisplayListBuilder, this, aBuilder, aResources, &group, aList, aSc);
>   mClipManager.EndList(aSc);
> }
> 
> void
> WebRenderCommandBuilder::Destroy()
> {
>   mLastCanvasDatas.Clear();
>   ClearCachedResources();
>diff --git a/gfx/webrender/src/render_backend.rs b/gfx/webrender/src/render_backend.rs
>--- a/gfx/webrender/src/render_backend.rs
>+++ b/gfx/webrender/src/render_backend.rs
>@@ -269,16 +269,17 @@ impl Document {
> 
>     fn render(
>         &mut self,
>         resource_cache: &mut ResourceCache,
>         gpu_cache: &mut GpuCache,
>         resource_profile: &mut ResourceProfileCounters,
>         is_new_scene: bool,
>     ) -> RenderedDocument {
>+        println!("---------------------------------------------------");
>         let accumulated_scale_factor = self.view.accumulated_scale_factor();
>         let pan = self.view.pan.to_f32() / accumulated_scale_factor;
> 
>         let frame = {
>             let frame_builder = self.frame_builder.as_mut().unwrap();
>             let frame = frame_builder.build(
>                 resource_cache,
>                 gpu_cache,
>diff --git a/gfx/webrender/src/resource_cache.rs b/gfx/webrender/src/resource_cache.rs
>--- a/gfx/webrender/src/resource_cache.rs
>+++ b/gfx/webrender/src/resource_cache.rs
>@@ -499,16 +499,17 @@ impl ResourceCache {
>             }
>         }
> 
>         *updates = new_updates;
>     }
> 
>     pub fn add_rasterized_blob_images(&mut self, images: Vec<(BlobImageRequest, BlobImageResult)>) {
>         for (request, result) in images {
>+            println!("  > add rasterized blob {:?}", request);
>             let image = self.rasterized_blob_images.entry(request.key).or_insert_with(
>                 || { RasterizedBlobImage { data: FastHashMap::default() } }
>             );
>             image.data.insert(request.tile, result);
>         }
>     }
> 
>     pub fn add_font_template(&mut self, font_key: FontKey, template: FontTemplate) {
>@@ -648,17 +649,17 @@ impl ResourceCache {
>         let max_texture_size = self.max_texture_size();
>         if tiling.is_none() &&
>             (descriptor.size.width > max_texture_size ||
>              descriptor.size.height > max_texture_size) {
>             tiling = Some(DEFAULT_TILE_SIZE);
>         }
> 
>         self.blob_image_renderer.as_mut().unwrap().add(key, data, tiling);
>-
>+        println!(" -- add blob image template (key={:?})", key);
>         self.blob_image_templates.insert(
>             key,
>             BlobImageTemplate {
>                 descriptor: *descriptor,
>                 tiling,
>                 dirty_rect: Some(
>                     DeviceUintRect::new(
>                         DeviceUintPoint::zero(),
>@@ -711,16 +712,17 @@ impl ResourceCache {
> 
>         self.cached_images
>             .clear_keys(|request| request.key == image_key);
> 
>         match value {
>             Some(image) => if image.data.is_blob() {
>                 self.blob_image_renderer.as_mut().unwrap().delete(image_key);
>                 self.blob_image_templates.remove(&image_key);
>+                println!(" -- remove blob image template (key={:?})", image_key);
>             },
>             None => {
>                 warn!("Delete the non-exist key");
>                 debug!("key={:?}", image_key);
>             }
>         }
>     }
> 
>@@ -775,16 +777,17 @@ impl ResourceCache {
>             }
>         };
> 
>         self.texture_cache.request(
>             &entry.as_ref().unwrap().texture_cache_handle,
>             gpu_cache
>         );
> 
>+        println!(" + request {:?} from resource cache: {:?}", request, entry.as_ref().unwrap().texture_cache_handle);
>         self.pending_image_requests.insert(request);
>     }
> 
>     pub fn create_blob_scene_builder_request(&mut self, requests: &[BlobImageRequest]) -> Option<Box<AsyncBlobImageRenderer>> {
>         if requests.is_empty() || self.blob_image_renderer.is_none() {
>             return None;
>         }
> 
>@@ -885,34 +888,47 @@ impl ResourceCache {
>         )
>     }
> 
>     fn discard_tiles_outside_visible_area(
>         &mut self,
>         key: ImageKey,
>         area: &NormalizedRect
>     ) {
>-        let template = self.blob_image_templates.get(&key).unwrap();
>+        let template = match self.blob_image_templates.get(&key) {
>+            Some(template) => template,
>+            None => {
>+                println!("Missing image template (key={:?})!", key);
>+                return;
>+            }
>+        };
>         let tile_size = match template.tiling {
>             Some(size) => size,
>             None => { return; }
>         };
>-        let image = self.rasterized_blob_images.get_mut(&key).unwrap();
>+        let image = match self.rasterized_blob_images.get_mut(&key) {
>+            Some(image) => image,
>+            None => {
>+                println!("Missing rasterized blob (key={:?})!", key);
>+                return;
>+            }
>+        };
>         let tile_range = compute_tile_range(
>             &area,
>             &template.descriptor.size,
>             tile_size,
>         );
>         image.data.retain(|tile, _| {
>             match tile {
>-                Some(offset) => !tile_range.contains(offset),
>+                Some(offset) => tile_range.contains(offset),
>                 // This would be a bug. If we get here the blob should be tiled.
>                 None => false,
>             }
>         });
>+        println!(" === blob {:?} has {:?} tiles in range ({:?})", key, tile_range, area);
>     }
> 
>     pub fn request_glyphs(
>         &mut self,
>         mut font: FontInstance,
>         glyph_keys: &[GlyphKey],
>         gpu_cache: &mut GpuCache,
>         render_task_tree: &mut RenderTaskTree,
>@@ -1059,16 +1075,17 @@ impl ResourceCache {
>         request: ImageRequest,
>     ) -> Result<CacheItem, ()> {
>         debug_assert_eq!(self.state, State::QueryResources);
> 
>         // TODO(Jerry): add a debug option to visualize the corresponding area for
>         // the Err() case of CacheItem.
>         match *self.cached_images.get(&request) {
>             Ok(ref image_info) => {
>+                println!(" * get cached image {:?} from texture cache", request);
>                 Ok(self.texture_cache.get(&image_info.texture_cache_handle))
>             }
>             Err(_) => {
>                 Err(())
>             }
>         }
>     }
> 
>@@ -1166,31 +1183,34 @@ impl ResourceCache {
>                                 .as_ref()
>                                 .expect("Failed to render a blob image");
> 
>                             // TODO: we may want to not panic and show a placeholder instead.
> 
>                             ImageData::Raw(Arc::clone(&result.data))
>                         }
>                         None => {
>+                            println!(" --- invalid blob image request during frame building: {:?}", request);
>+                            println!("     this image has {} tiles", blob_image.data.len());
>                             debug_assert!(false, "invalid blob image request during frame building");
>                             continue;
>                         }
>                     }
>                 }
>             };
>             let descriptor = if let Some(tile) = request.tile {
>                 let tile_size = image_template.tiling.unwrap();
>                 let image_descriptor = &image_template.descriptor;
> 
>                 let clipped_tile_size = compute_tile_size(image_descriptor, tile_size, tile);
> 
>                 if let Some(dirty) = dirty_rect {
>                     dirty_rect = intersect_for_tile(dirty, clipped_tile_size, tile_size, tile);
>                     if dirty_rect.is_none() {
>+                        println!(" --- update texture cache bailed because of empty dirty rect {:?}", request);
>                         continue
>                     }
>                 }
> 
>                 // The tiled image could be stored on the CPU as one large image or be
>                 // already broken up into tiles. This affects the way we compute the stride
>                 // and offset.
>                 let tiled_on_cpu = image_template.data.is_blob();
>diff --git a/gfx/webrender_bindings/WebRenderAPI.cpp b/gfx/webrender_bindings/WebRenderAPI.cpp
>--- a/gfx/webrender_bindings/WebRenderAPI.cpp
>+++ b/gfx/webrender_bindings/WebRenderAPI.cpp
>@@ -629,16 +629,21 @@ TransactionBuilder::UpdateExternalImage(
>   wr_resource_updates_update_external_image(mTxn,
>                                             aKey,
>                                             &aDescriptor,
>                                             aExtID,
>                                             aBufferType,
>                                             aChannelIndex);
> }
> 
>+void TransactionBuilder::SetImageVisibleArea(ImageKey aKey, const wr::NormalizedRect& aArea)
>+{
>+  wr_resource_updates_set_image_visible_area(mTxn, aKey, &aArea);
>+}
>+
> void
> TransactionBuilder::DeleteImage(ImageKey aKey)
> {
>   wr_resource_updates_delete_image(mTxn, aKey);
> }
> 
> void
> TransactionBuilder::AddRawFont(wr::FontKey aKey, wr::Vec<uint8_t>& aBytes, uint32_t aIndex)
>diff --git a/gfx/webrender_bindings/WebRenderAPI.h b/gfx/webrender_bindings/WebRenderAPI.h
>--- a/gfx/webrender_bindings/WebRenderAPI.h
>+++ b/gfx/webrender_bindings/WebRenderAPI.h
>@@ -115,16 +115,18 @@ public:
>                        const wr::DeviceUintRect& aDirtyRect);
> 
>   void UpdateExternalImage(ImageKey aKey,
>                            const ImageDescriptor& aDescriptor,
>                            ExternalImageId aExtID,
>                            wr::WrExternalImageBufferType aBufferType,
>                            uint8_t aChannelIndex = 0);
> 
>+  void SetImageVisibleArea(ImageKey aKey, const wr::NormalizedRect& aArea);
>+
>   void DeleteImage(wr::ImageKey aKey);
> 
>   void AddRawFont(wr::FontKey aKey, wr::Vec<uint8_t>& aBytes, uint32_t aIndex);
> 
>   void AddFontDescriptor(wr::FontKey aKey, wr::Vec<uint8_t>& aBytes, uint32_t aIndex);
> 
>   void DeleteFont(wr::FontKey aKey);
> 
>diff --git a/gfx/webrender_bindings/src/bindings.rs b/gfx/webrender_bindings/src/bindings.rs
>--- a/gfx/webrender_bindings/src/bindings.rs
>+++ b/gfx/webrender_bindings/src/bindings.rs
>@@ -1215,17 +1215,20 @@ pub extern "C" fn wr_resource_updates_ad
>     image_key: WrImageKey,
>     descriptor: &WrImageDescriptor,
>     bytes: &mut WrVecU8,
> ) {
>     txn.add_image(
>         image_key,
>         descriptor.into(),
>         ImageData::new_blob_image(bytes.flush_into_vec()),
>-        None
>+        match descriptor.format {
>+            ImageFormat::BGRA8 => Some(256),
>+            _ => None,
>+        },
>     );
> }
> 
> #[no_mangle]
> pub extern "C" fn wr_resource_updates_add_external_image(
>     txn: &mut Transaction,
>     image_key: WrImageKey,
>     descriptor: &WrImageDescriptor,
>@@ -1258,16 +1261,25 @@ pub extern "C" fn wr_resource_updates_up
>         key,
>         descriptor.into(),
>         ImageData::new(bytes.flush_into_vec()),
>         None
>     );
> }
> 
> #[no_mangle]
>+pub extern "C" fn wr_resource_updates_set_image_visible_area(
>+    txn: &mut Transaction,
>+    key: WrImageKey,
>+    area: &NormalizedRect,
>+) {
>+    txn.set_image_visible_area(key, *area);
>+}
>+
>+#[no_mangle]
> pub extern "C" fn wr_resource_updates_update_external_image(
>     txn: &mut Transaction,
>     key: WrImageKey,
>     descriptor: &WrImageDescriptor,
>     external_image_id: WrExternalImageId,
>     image_type: WrExternalImageBufferType,
>     channel_index: u8
> ) {
>diff --git a/gfx/webrender_bindings/src/lib.rs b/gfx/webrender_bindings/src/lib.rs
>--- a/gfx/webrender_bindings/src/lib.rs
>+++ b/gfx/webrender_bindings/src/lib.rs
>@@ -1,13 +1,13 @@
> /* 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(warnings)]
>+//#![deny(warnings)]
> 
> extern crate webrender;
> extern crate euclid;
> extern crate app_units;
> extern crate gleam;
> extern crate nsstring;
> extern crate rayon;
> extern crate thread_profiler;
>diff --git a/gfx/webrender_bindings/src/moz2d_renderer.rs b/gfx/webrender_bindings/src/moz2d_renderer.rs
>--- a/gfx/webrender_bindings/src/moz2d_renderer.rs
>+++ b/gfx/webrender_bindings/src/moz2d_renderer.rs
>@@ -1,20 +1,20 @@
> use webrender::api::*;
> use bindings::{ByteSlice, MutByteSlice, wr_moz2d_render_cb, ArcVecU8};
> use rayon::ThreadPool;
>+use rayon::prelude::*;
> 
> use std::collections::hash_map::HashMap;
> use std::collections::hash_map;
> use std::collections::btree_map::BTreeMap;
> use std::collections::Bound::Included;
> use std::mem;
> use std::os::raw::c_void;
> use std::ptr;
>-use std::sync::mpsc::{channel, Sender, Receiver};
> use std::sync::Arc;
> use std;
> 
> #[cfg(target_os = "windows")]
> use dwrote;
> 
> #[cfg(target_os = "macos")]
> use foreign_types::ForeignType;
>@@ -23,25 +23,18 @@ use foreign_types::ForeignType;
> use std::ffi::CString;
> 
> macro_rules! dlog {
>     ($($e:expr),*) => { {$(let _ = $e;)*} }
>     //($($t:tt)*) => { println!($($t)*) }
> }
> 
> pub struct Moz2dImageRenderer {
>+    workers: Arc<ThreadPool>,
>     blob_commands: HashMap<ImageKey, (Arc<BlobImageData>, Option<TileSize>)>,
>-
>-    // The images rendered in the current frame (not kept here between frames)
>-    rendered_images: HashMap<BlobImageRequest, Option<BlobImageResult>>,
>-
>-    tx: Sender<(BlobImageRequest, BlobImageResult)>,
>-    rx: Receiver<(BlobImageRequest, BlobImageResult)>,
>-
>-    workers: Arc<ThreadPool>,
> }
> 
> fn option_to_nullable<T>(option: &Option<T>) -> *const T {
>     match option {
>         &Some(ref x) => { x as *const T }
>         &None => { ptr::null() }
>     }
> }
>@@ -335,17 +328,78 @@ fn merge_blob_images(old_buf: &[u8], new
> 
>     assert!(old_reader.cache.is_empty());
> 
>     let result = result.finish();
>     check_result(&result);
>     result
> }
> 
>-impl BlobImageRenderer for Moz2dImageRenderer {
>+struct RequestItem {
>+    request: BlobImageRequest,
>+    descriptor: BlobImageDescriptor,
>+    commands: Arc<BlobImageData>,
>+    dirty_rect: Option<DeviceUintRect>,
>+    tile_size: Option<TileSize>,
>+}
>+
>+struct SceneBuilderRequest {
>+    workers: Arc<ThreadPool>,
>+    requests: Vec<RequestItem>,
>+}
>+
>+impl AsyncBlobImageRenderer for SceneBuilderRequest {
>+    fn run(&mut self) -> Vec<(BlobImageRequest, BlobImageResult)> {
>+        println!(" -- scene builder callback {}", self.requests.len());
>+        let requests = mem::replace(&mut self.requests, Vec::new());
>+        let workers = Arc::clone(&self.workers);
>+        workers.install(||{
>+            requests.into_par_iter().map(|item| {
>+                let descriptor = item.descriptor;
>+                let buf_size = (descriptor.size.width
>+                    * descriptor.size.height
>+                    * descriptor.format.bytes_per_pixel()) as usize;
>+
>+                let mut output = vec![0u8; buf_size];
>+
>+                let result = unsafe {
>+                    if wr_moz2d_render_cb(
>+                        ByteSlice::new(&item.commands[..]),
>+                        descriptor.size.width,
>+                        descriptor.size.height,
>+                        descriptor.format,
>+                        option_to_nullable(&item.tile_size),
>+                        option_to_nullable(&item.request.tile),
>+                        option_to_nullable(&item.dirty_rect),
>+                        MutByteSlice::new(output.as_mut_slice()),
>+                    ) {
>+                        // (nical) just tinting the output so I can see
>+                        // what things are blobs.
>+                        let mut i = 0;
>+                        for byte in &mut output {
>+                            if i % 4 == 1 { *byte = 0 };
>+                            i += 1;
>+                        }
>+
>+                        Ok(RasterizedBlobImage {
>+                            size: descriptor.size,
>+                            data: Arc::new(output),
>+                        })
>+                    } else {
>+                        panic!("Moz2D replay problem");
>+                    }
>+                };
>+
>+                (item.request, result)
>+            }).collect()
>+        })
>+    }
>+}
>+
>+impl BlobImageHandler for Moz2dImageRenderer {
>     fn add(&mut self, key: ImageKey, data: Arc<BlobImageData>, tiling: Option<TileSize>) {
>         {
>             let index = BlobReader::new(&data);
>             assert!(index.reader.has_more());
>         }
>         self.blob_commands.insert(key, (Arc::clone(&data), tiling));
>     }
> 
>@@ -359,36 +413,73 @@ impl BlobImageRenderer for Moz2dImageRen
>             _ => { panic!("missing image key"); }
>         }
>     }
> 
>     fn delete(&mut self, key: ImageKey) {
>         self.blob_commands.remove(&key);
>     }
> 
>-    fn request(&mut self,
>-               resources: &BlobImageResources,
>-               request: BlobImageRequest,
>-               descriptor: &BlobImageDescriptor,
>-               dirty_rect: Option<DeviceUintRect>) {
>-        debug_assert!(!self.rendered_images.contains_key(&request), "{:?}", request);
>-        // TODO: implement tiling.
>+    fn create_blob_renderer(
>+        &mut self,
>+        resources: &BlobImageResources,
>+        requests: Vec<BlobImageParams>,
>+    ) -> Option<Box<AsyncBlobImageRenderer>> {
>+
>+        let mut items = Vec::new();
>+        for params in &requests {
>+            let commands = &self.blob_commands[&params.request.key];
>+            let blob = Arc::clone(&commands.0);
>+            self.prepare_request(&blob, resources);
>+            items.push(RequestItem {
>+                request: params.request,
>+                descriptor: params.descriptor,
>+                commands: blob,
>+                dirty_rect: params.dirty_rect,
>+                tile_size: commands.1,
>+            });
>+        }
>+
>+        Some(Box::new(SceneBuilderRequest {
>+            workers: Arc::clone(&self.workers),
>+            requests: items,
>+        }))
>+    }
> 
>-        // Add None in the map of rendered images. This makes it possible to differentiate
>-        // between commands that aren't finished yet (entry in the map is equal to None) and
>-        // keys that have never been requested (entry not in the map), which would cause deadlocks
>-        // if we were to block upon receving their result in resolve!
>-        self.rendered_images.insert(request, None);
>+    fn delete_font(&mut self, font: FontKey) {
>+        unsafe { DeleteFontData(font); }
>+    }
>+
>+    fn delete_font_instance(&mut self, _key: FontInstanceKey) {
>+    }
>+
>+    fn clear_namespace(&mut self, namespace: IdNamespace) {
>+        unsafe { ClearBlobImageResources(namespace); }
>+    }
>+}
>+
>+use bindings::{WrFontKey, WrIdNamespace};
> 
>-        let tx = self.tx.clone();
>-        let descriptor = descriptor.clone();
>-        let blob = &self.blob_commands[&request.key];
>-        let tile_size = blob.1;
>-        let commands = Arc::clone(&blob.0);
>+#[allow(improper_ctypes)] // this is needed so that rustc doesn't complain about passing the &Arc<Vec> to an extern function
>+extern "C" {
>+    fn AddFontData(key: WrFontKey, data: *const u8, size: usize, index: u32, vec: &ArcVecU8);
>+    fn AddNativeFontHandle(key: WrFontKey, handle: *mut c_void, index: u32);
>+    fn DeleteFontData(key: WrFontKey);
>+    fn ClearBlobImageResources(namespace: WrIdNamespace);
>+}
> 
>+impl Moz2dImageRenderer {
>+    pub fn new(workers: Arc<ThreadPool>) -> Self {
>+        Moz2dImageRenderer {
>+            blob_commands: HashMap::new(),
>+            workers: workers,
>+        }
>+    }
>+
>+    fn prepare_request(&self, blob: &[u8], resources: &BlobImageResources) {
>         #[cfg(target_os = "windows")]
>         fn process_native_font_handle(key: FontKey, handle: &NativeFontHandle) {
>             let system_fc = dwrote::FontCollection::system();
>             let font = system_fc.get_font_from_descriptor(handle).unwrap();
>             let face = font.create_font_face();
>             unsafe { AddNativeFontHandle(key, face.as_ptr() as *mut c_void, 0) };
>         }
> 
>@@ -415,109 +506,17 @@ impl BlobImageRenderer for Moz2dImageRen
>                     &FontTemplate::Native(ref handle) => {
>                         process_native_font_handle(key, handle);
>                     }
>                 }
>                 resources.get_font_data(key);
>             }
>         }
>         {
>-            let mut index = BlobReader::new(&commands);
>+            let mut index = BlobReader::new(blob);
>             while index.reader.pos < index.reader.buf.len() {
>                 let e  = index.read_entry();
>-                process_fonts(BufReader::new(&commands[e.end..e.extra_end]), resources);
>-            }
>-        }
>-
>-        self.workers.spawn(move || {
>-            let buf_size = (descriptor.size.width
>-                * descriptor.size.height
>-                * descriptor.format.bytes_per_pixel()) as usize;
>-            let mut output = vec![0u8; buf_size];
>-
>-            let result = unsafe {
>-                if wr_moz2d_render_cb(
>-                    ByteSlice::new(&commands[..]),
>-                    descriptor.size.width,
>-                    descriptor.size.height,
>-                    descriptor.format,
>-                    option_to_nullable(&tile_size),
>-                    option_to_nullable(&request.tile),
>-                    option_to_nullable(&dirty_rect),
>-                    MutByteSlice::new(output.as_mut_slice())
>-                ) {
>-
>-                    Ok(RasterizedBlobImage {
>-                        size: descriptor.size,
>-                        data: output,
>-                    })
>-                } else {
>-                    panic!("Moz2D replay problem");
>-                }
>-            };
>-
>-            tx.send((request, result)).unwrap();
>-        });
>-    }
>-
>-    fn resolve(&mut self, request: BlobImageRequest) -> BlobImageResult {
>-
>-        match self.rendered_images.entry(request) {
>-            hash_map::Entry::Vacant(_) => {
>-                return Err(BlobImageError::InvalidKey);
>+                process_fonts(BufReader::new(&blob[e.end..e.extra_end]), resources);
>             }
>-            hash_map::Entry::Occupied(entry) => {
>-                // None means we haven't yet received the result.
>-                if entry.get().is_some() {
>-                    let result = entry.remove();
>-                    return result.unwrap();
>-                }
>-            }
>-        }
>-
>-        // We haven't received it yet, pull from the channel until we receive it.
>-        while let Ok((req, result)) = self.rx.recv() {
>-            if req == request {
>-                // There it is!
>-                self.rendered_images.remove(&request);
>-                return result
>-            }
>-            self.rendered_images.insert(req, Some(result));
>-        }
>-
>-        // If we break out of the loop above it means the channel closed unexpectedly.
>-        Err(BlobImageError::Other("Channel closed".into()))
>-    }
>-    fn delete_font(&mut self, font: FontKey) {
>-        unsafe { DeleteFontData(font); }
>-    }
>-
>-    fn delete_font_instance(&mut self, _key: FontInstanceKey) {
>-    }
>-
>-    fn clear_namespace(&mut self, namespace: IdNamespace) {
>-        unsafe { ClearBlobImageResources(namespace); }
>-    }
>-}
>-
>-use bindings::{WrFontKey, WrIdNamespace};
>-
>-#[allow(improper_ctypes)] // this is needed so that rustc doesn't complain about passing the &Arc<Vec> to an extern function
>-extern "C" {
>-    fn AddFontData(key: WrFontKey, data: *const u8, size: usize, index: u32, vec: &ArcVecU8);
>-    fn AddNativeFontHandle(key: WrFontKey, handle: *mut c_void, index: u32);
>-    fn DeleteFontData(key: WrFontKey);
>-    fn ClearBlobImageResources(namespace: WrIdNamespace);
>-}
>-
>-impl Moz2dImageRenderer {
>-    pub fn new(workers: Arc<ThreadPool>) -> Self {
>-        let (tx, rx) = channel();
>-        Moz2dImageRenderer {
>-            blob_commands: HashMap::new(),
>-            rendered_images: HashMap::new(),
>-            workers: workers,
>-            tx: tx,
>-            rx: rx,
>         }
>     }
> }
> 
>diff --git a/gfx/webrender_bindings/webrender_ffi_generated.h b/gfx/webrender_bindings/webrender_ffi_generated.h
>--- a/gfx/webrender_bindings/webrender_ffi_generated.h
>+++ b/gfx/webrender_bindings/webrender_ffi_generated.h
>@@ -213,16 +213,19 @@ struct Arc;
> // surface) in physical pixels.
> struct DevicePixel;
> 
> struct DocumentHandle;
> 
> // Geometry in a stacking context's local coordinate space (logical pixels).
> struct LayoutPixel;
> 
>+// Coordinates in normalized space (between zero and one).
>+struct NormalizedCoordinates;
>+
> // The renderer is responsible for submitting to the GPU the work prepared by the
> // RenderBackend.
> struct Renderer;
> 
> // Offset in number of tiles.
> struct Tiles;
> 
> // A Transaction is a group of commands to apply atomically to a document.
>@@ -921,16 +924,18 @@ struct FontInstancePlatformOptions {
> 
>   bool operator==(const FontInstancePlatformOptions& aOther) const {
>     return lcd_filter == aOther.lcd_filter &&
>            hinting == aOther.hinting;
>   }
> };
> #endif
> 
>+using NormalizedRect = TypedRect<float, NormalizedCoordinates>;
>+
> struct WrTransformProperty {
>   uint64_t id;
>   LayoutTransform transform;
> };
> 
> struct WrOpacityProperty {
>   uint64_t id;
>   float opacity;
>@@ -1537,16 +1542,22 @@ void wr_resource_updates_delete_font_ins
> WR_FUNC;
> 
> WR_INLINE
> void wr_resource_updates_delete_image(Transaction *aTxn,
>                                       WrImageKey aKey)
> WR_FUNC;
> 
> WR_INLINE
>+void wr_resource_updates_set_image_visible_area(Transaction *aTxn,
>+                                                WrImageKey aKey,
>+                                                const NormalizedRect *aArea)
>+WR_FUNC;
>+
>+WR_INLINE
> void wr_resource_updates_update_blob_image(Transaction *aTxn,
>                                            WrImageKey aImageKey,
>                                            const WrImageDescriptor *aDescriptor,
>                                            WrVecU8 *aBytes,
>                                            DeviceUintRect aDirtyRect)
> WR_FUNC;
> 
> WR_INLINE

Comment 4

[Nicolas Silva [:nical]]

Oh boy what did I just do?

Comment 5

[Nicolas Silva [:nical]]

Attachment: (WIP) Provide webrender with the visible are of each blob image.

I tried to use the intersection of the bounds and paint rect of the blob image display items to apply a local clip on the display item. This helps a lot with preventing webrender from requesting tiles that are not in Gecko's computed visible area, but it appears to cause some issues. The main one I saw was the animated map at the bottom of http://digitalocean.com/ rendering very differently.

Comment 6

[Nicolas Silva [:nical]]

Try push is (almost surprisingly) green https://treeherder.mozilla.org/#/jobs?repo=try&revision=a4c648a8899b053966f116bb2db9e0a6e0de95bf

Comment 7

[Nicolas Silva [:nical]]

Attachment: Implement the new async blob handler/rasterizer API.

Up to date patch that is in this try push https://treeherder.mozilla.org/#/jobs?repo=try&revision=a167b8873fba6c7b9a6802b88b6046d6580686c3

Comment 8

[Jeff Muizelaar [:jrmuizel]]

Comment on attachment 8992648 [details] [diff] [review]
Implement the new async blob handler/rasterizer API.

Review of attachment 8992648 [details] [diff] [review]:
-----------------------------------------------------------------

::: gfx/layers/wr/WebRenderCommandBuilder.cpp
@@ +69,5 @@
> +                        const LayoutDeviceRect& aImageRect,
> +                        const LayoutDeviceRect& aPaintRect)
> +{
> +  LayoutDeviceRect visibleRect = aImageRect.Intersect(aPaintRect);
> +  // Send the visible rect in normalized coordinates.

I'd prefer to not use normalized coordinates and instead use integer device pixels

Comment 9

[Aria Beingessner [:Gankra]]

Comment on attachment 8992648 [details] [diff] [review]
Implement the new async blob handler/rasterizer API.

Review of attachment 8992648 [details] [diff] [review]:
-----------------------------------------------------------------

There's too many kinds of visible rect for me to be certain that part is right, so mostly just reviewing the piping and stuff assuming that's right.

::: gfx/layers/wr/WebRenderCommandBuilder.cpp
@@ +1164,5 @@
>    group.mGroupBounds = groupBounds;
> +  group.mPaintRect = LayoutDeviceRect::FromAppUnits(
> +    aWrappingItem->GetPaintRect(),
> +    appUnitsPerDevPixel
> +  );

should you also pipe this value through at https://searchfox.org/mozilla-central/source/gfx/layers/wr/WebRenderCommandBuilder.cpp#979

?

::: gfx/webrender_bindings/src/moz2d_renderer.rs
@@ +432,5 @@
> +        unsafe { DeleteFontData(font); }
> +    }
> +
> +    fn delete_font_instance(&mut self, _key: FontInstanceKey) {
> +    }

can you explain (comment?) why this is blank?

Comment 10

[Nicolas Silva [:nical]]

Comment on attachment 8992648 [details] [diff] [review]
Implement the new async blob handler/rasterizer API.

Review of attachment 8992648 [details] [diff] [review]:
-----------------------------------------------------------------

::: gfx/layers/wr/WebRenderCommandBuilder.cpp
@@ +1164,5 @@
>    group.mGroupBounds = groupBounds;
> +  group.mPaintRect = LayoutDeviceRect::FromAppUnits(
> +    aWrappingItem->GetPaintRect(),
> +    appUnitsPerDevPixel
> +  );

Yeah I think so.

::: gfx/webrender_bindings/src/moz2d_renderer.rs
@@ +432,5 @@
> +        unsafe { DeleteFontData(font); }
> +    }
> +
> +    fn delete_font_instance(&mut self, _key: FontInstanceKey) {
> +    }

I can't explain it but this function already existed and was already blank before this patch.

Comment 11

[Kartikaya Gupta (email:[e-mail])]

Comment on attachment 8992648 [details] [diff] [review]
Implement the new async blob handler/rasterizer API.

Review of attachment 8992648 [details] [diff] [review]:
-----------------------------------------------------------------

Looks like some flags got reset. Restoring them

Comment 12

[Nicolas Silva [:nical]]

Attachment: Implement the new async blob handler/rasterizer API. carrying r=kats, gankro

Same patch with Alexi's comment addressed and a proper commit title.

Comment 13

[Pulsebot]

Pushed by [e-mail]:
https://hg.mozilla.org/integration/mozilla-inbound/rev/80efe717b563
Implement the new blob image rasterization hooks. r=kats, gankro

Comment 14

[Bogdan Tara[:bogdan_tara | bogdant]]

https://hg.mozilla.org/mozilla-central/rev/80efe717b563