Backed out 4 changesets (bug 1538710) for webrender-lint
authorDaniel Varga <dvarga@mozilla.com>
Mon, 15 Apr 2019 23:18:19 +0300
changeset 469557 2acb3832e7e5
parent 469556 fb9ff7baed43
child 469558 fca4cf358f16
push id35874
push userccoroiu@mozilla.com
push dateTue, 16 Apr 2019 04:04:58 +0000
treeherdermozilla-central@be3f40425b52 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1538710
milestone68.0a1
backs out6f3f506c7740
1a529f967061
afa5cc2c6032
ab2083ff97f4
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out 4 changesets (bug 1538710) for webrender-lint Backed out changeset 6f3f506c7740 (bug 1538710) Backed out changeset 1a529f967061 (bug 1538710) Backed out changeset afa5cc2c6032 (bug 1538710) Backed out changeset ab2083ff97f4 (bug 1538710)
gfx/layers/apz/public/CompositorController.h
gfx/layers/ipc/CompositorBridgeParent.cpp
gfx/layers/ipc/CompositorBridgeParent.h
gfx/layers/wr/WebRenderBridgeParent.cpp
gfx/layers/wr/WebRenderBridgeParent.h
gfx/thebes/gfxPlatform.cpp
gfx/webrender_bindings/RenderThread.cpp
gfx/webrender_bindings/WebRenderAPI.cpp
gfx/webrender_bindings/WebRenderAPI.h
gfx/webrender_bindings/src/bindings.rs
gfx/wr/webrender/src/record.rs
gfx/wr/webrender/src/render_backend.rs
gfx/wr/webrender/src/renderer.rs
gfx/wr/webrender/src/resource_cache.rs
gfx/wr/webrender/src/scene_builder.rs
gfx/wr/webrender/src/texture_cache.rs
gfx/wr/webrender_api/src/api.rs
gfx/wr/wrench/reftests/border/border-suite-2.png
gfx/wr/wrench/reftests/boxshadow/box-shadow-cache.png
gfx/wr/wrench/src/binary_frame_reader.rs
gfx/wr/wrench/src/json_frame_writer.rs
gfx/wr/wrench/src/ron_frame_writer.rs
gfx/wr/wrench/src/yaml_frame_writer.rs
modules/libpref/init/all.js
--- a/gfx/layers/apz/public/CompositorController.h
+++ b/gfx/layers/apz/public/CompositorController.h
@@ -14,18 +14,17 @@
 namespace mozilla {
 namespace layers {
 
 class CompositorController {
  public:
   NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING
 
   virtual void ScheduleRenderOnCompositorThread(
-      const nsTArray<wr::RenderRoot>& aRenderRoots =
-          nsTArray<wr::RenderRoot>()) = 0;
+      const Maybe<wr::RenderRoot>& aRenderRootid = Nothing()) = 0;
   virtual void ScheduleHideAllPluginWindows() = 0;
   virtual void ScheduleShowAllPluginWindows() = 0;
 
  protected:
   virtual ~CompositorController() = default;
 };
 
 }  // namespace layers
--- a/gfx/layers/ipc/CompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/CompositorBridgeParent.cpp
@@ -645,21 +645,21 @@ void CompositorBridgeParent::ActorDestro
   // handling message reception is finished on this thread.
   mSelfRef = this;
   MessageLoop::current()->PostTask(
       NewRunnableMethod("layers::CompositorBridgeParent::DeferredDestroy", this,
                         &CompositorBridgeParent::DeferredDestroy));
 }
 
 void CompositorBridgeParent::ScheduleRenderOnCompositorThread(
-    const nsTArray<wr::RenderRoot>& aRenderRoots) {
+    const Maybe<wr::RenderRoot>& aRenderRoot) {
   MOZ_ASSERT(CompositorLoop());
-  CompositorLoop()->PostTask(NewRunnableMethod<nsTArray<wr::RenderRoot>>(
+  CompositorLoop()->PostTask(NewRunnableMethod<Maybe<wr::RenderRoot>>(
       "layers::CompositorBridgeParent::ScheduleComposition", this,
-      &CompositorBridgeParent::ScheduleComposition, aRenderRoots));
+      &CompositorBridgeParent::ScheduleComposition, aRenderRoot));
 }
 
 void CompositorBridgeParent::InvalidateOnCompositorThread() {
   MOZ_ASSERT(CompositorLoop());
   CompositorLoop()->PostTask(
       NewRunnableMethod("layers::CompositorBridgeParent::Invalidate", this,
                         &CompositorBridgeParent::Invalidate));
 }
@@ -859,24 +859,28 @@ void CompositorBridgeParent::NotifyShado
     mLayerManager->NotifyShadowTreeTransaction();
   }
   if (aScheduleComposite) {
     ScheduleComposition();
   }
 }
 
 void CompositorBridgeParent::ScheduleComposition(
-    const nsTArray<wr::RenderRoot>& aRenderRoots) {
+    const Maybe<wr::RenderRoot>& aRenderRoot) {
   MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
   if (mPaused) {
     return;
   }
 
   if (mWrBridge) {
-    mWrBridge->ScheduleGenerateFrame(aRenderRoots);
+    if (aRenderRoot.isSome()) {
+      mWrBridge->ScheduleGenerateFrame(aRenderRoot);
+    } else {
+      mWrBridge->ScheduleGenerateFrameAllRenderRoots();
+    }
   } else {
     mCompositorScheduler->ScheduleComposition();
   }
 }
 
 // Go down the composite layer tree, setting properties to match their
 // content-side counterparts.
 /* static */
@@ -2055,25 +2059,24 @@ void CompositorBridgeParent::DidComposit
     mTxnStartTime = TimeStamp();
     mFwdTime = TimeStamp();
 #endif
     mPendingTransaction = TransactionId{0};
   }
 }
 
 void CompositorBridgeParent::NotifyDidSceneBuild(
-    const nsTArray<wr::RenderRoot>& aRenderRoots,
-    RefPtr<wr::WebRenderPipelineInfo> aInfo) {
+    wr::RenderRoot aRenderRoot, RefPtr<wr::WebRenderPipelineInfo> aInfo) {
   MOZ_ASSERT(CompositorThreadHolder::IsInCompositorThread());
   if (mPaused) {
     return;
   }
 
   if (mWrBridge) {
-    mWrBridge->NotifyDidSceneBuild(aRenderRoots, aInfo);
+    mWrBridge->NotifyDidSceneBuild(aRenderRoot, aInfo);
   } else {
     mCompositorScheduler->ScheduleComposition();
   }
 }
 
 void CompositorBridgeParent::NotifyPipelineRendered(
     const wr::PipelineId& aPipelineId, const wr::Epoch& aEpoch,
     const VsyncId& aCompositeStartId, TimeStamp& aCompositeStart,
--- a/gfx/layers/ipc/CompositorBridgeParent.h
+++ b/gfx/layers/ipc/CompositorBridgeParent.h
@@ -394,17 +394,17 @@ class CompositorBridgeParent final : pub
   void NotifyWebRenderError(wr::WebRenderError aError);
   void NotifyWebRenderContextPurge();
   void NotifyPipelineRendered(const wr::PipelineId& aPipelineId,
                               const wr::Epoch& aEpoch,
                               const VsyncId& aCompositeStartId,
                               TimeStamp& aCompositeStart,
                               TimeStamp& aRenderStart, TimeStamp& aCompositeEnd,
                               wr::RendererStats* aStats = nullptr);
-  void NotifyDidSceneBuild(const nsTArray<wr::RenderRoot>& aRenderRoots,
+  void NotifyDidSceneBuild(wr::RenderRoot aRenderRoot,
                            RefPtr<wr::WebRenderPipelineInfo> aInfo);
   RefPtr<AsyncImagePipelineManager> GetAsyncImagePipelineManager() const;
 
   PCompositorWidgetParent* AllocPCompositorWidgetParent(
       const CompositorWidgetInitData& aInitData) override;
   bool DeallocPCompositorWidgetParent(PCompositorWidgetParent* aActor) override;
 
   void ObserveLayersUpdate(LayersId aLayersId, LayersObserverEpoch aEpoch,
@@ -422,30 +422,28 @@ class CompositorBridgeParent final : pub
   static void SetShadowProperties(Layer* aLayer);
 
   void NotifyChildCreated(LayersId aChild);
 
   void AsyncRender();
 
   // Can be called from any thread
   void ScheduleRenderOnCompositorThread(
-      const nsTArray<wr::RenderRoot>& aRenderRoots =
-          nsTArray<wr::RenderRoot>()) override;
+      const Maybe<wr::RenderRoot>& aRenderRoot = Nothing()) override;
   void SchedulePauseOnCompositorThread();
   void InvalidateOnCompositorThread();
   /**
    * Returns true if a surface was obtained and the resume succeeded; false
    * otherwise.
    */
   bool ScheduleResumeOnCompositorThread();
   bool ScheduleResumeOnCompositorThread(int x, int y, int width, int height);
 
-  void ScheduleComposition(const nsTArray<wr::RenderRoot>& aRenderRoots =
-                               nsTArray<wr::RenderRoot>());
-
+  void ScheduleComposition(
+      const Maybe<wr::RenderRoot>& aRenderRoot = Nothing());
   void NotifyShadowTreeTransaction(LayersId aId, bool aIsFirstPaint,
                                    const FocusTarget& aFocusTarget,
                                    bool aScheduleComposite,
                                    uint32_t aPaintSequenceNumber,
                                    bool aIsRepeatTransaction,
                                    bool aHitTestUpdate);
 
   void UpdatePaintTime(LayerTransactionParent* aLayerTree,
--- a/gfx/layers/wr/WebRenderBridgeParent.cpp
+++ b/gfx/layers/wr/WebRenderBridgeParent.cpp
@@ -1997,29 +1997,26 @@ void WebRenderBridgeParent::MaybeGenerat
       Api(wr::RenderRoot::Default)->GetId(), aId, start, framesGenerated);
 
 #if defined(ENABLE_FRAME_LATENCY_LOG)
   auto startTime = TimeStamp::Now();
   Api(wr::RenderRoot::Default)->SetFrameStartTime(startTime);
 #endif
 
   MOZ_ASSERT(framesGenerated > 0);
-  wr::RenderRootArray<wr::TransactionBuilder*> generateFrameTxns;
   for (auto& api : mApis) {
     if (!api) {
       continue;
     }
     auto renderRoot = api->GetRenderRoot();
     if (generateFrame[renderRoot]) {
       fastTxns[renderRoot]->GenerateFrame();
-      generateFrameTxns[renderRoot] = fastTxns[renderRoot].ptr();
+      api->SendTransaction(*fastTxns[renderRoot]);
     }
   }
-  wr::WebRenderAPI::SendTransactions(mApis, generateFrameTxns);
-
   mMostRecentComposite = TimeStamp::Now();
 }
 
 void WebRenderBridgeParent::HoldPendingTransactionId(
     const wr::Epoch& aWrEpoch, TransactionId aTransactionId,
     bool aContainsSVGGroup, const VsyncId& aVsyncId,
     const TimeStamp& aVsyncStartTime, const TimeStamp& aRefreshStartTime,
     const TimeStamp& aTxnStartTime, const nsCString& aTxnURL,
@@ -2057,26 +2054,23 @@ void WebRenderBridgeParent::NotifySceneB
     if (id.mEpoch.mHandle == aEpoch.mHandle) {
       id.mSceneBuiltTime = aEndTime;
       break;
     }
   }
 }
 
 void WebRenderBridgeParent::NotifyDidSceneBuild(
-    const nsTArray<wr::RenderRoot>& aRenderRoots,
-    RefPtr<wr::WebRenderPipelineInfo> aInfo) {
+    wr::RenderRoot aRenderRoot, RefPtr<wr::WebRenderPipelineInfo> aInfo) {
   MOZ_ASSERT(IsRootWebRenderBridgeParent());
   if (!mCompositorScheduler) {
     return;
   }
 
-  for (auto renderRoot : aRenderRoots) {
-    mAsyncImageManager->SetWillGenerateFrame(renderRoot);
-  }
+  mAsyncImageManager->SetWillGenerateFrame(aRenderRoot);
 
   // If the scheduler has a composite more recent than our last composite (which
   // we missed), and we're within the threshold ms of the last vsync, then
   // kick of a late composite.
   TimeStamp lastVsync = mCompositorScheduler->GetLastVsyncTime();
   VsyncId lastVsyncId = mCompositorScheduler->GetLastVsyncId();
   if (lastVsyncId == VsyncId() || !mMostRecentComposite ||
       mMostRecentComposite >= lastVsync ||
@@ -2197,29 +2191,16 @@ void WebRenderBridgeParent::ScheduleGene
   if (mCompositorScheduler) {
     if (aRenderRoot.isSome()) {
       mAsyncImageManager->SetWillGenerateFrame(*aRenderRoot);
     }
     mCompositorScheduler->ScheduleComposition();
   }
 }
 
-void WebRenderBridgeParent::ScheduleGenerateFrame(
-    const nsTArray<wr::RenderRoot>& aRenderRoots) {
-  if (mCompositorScheduler) {
-    if (aRenderRoots.IsEmpty()) {
-      mAsyncImageManager->SetWillGenerateFrameAllRenderRoots();
-    }
-    for (auto renderRoot : aRenderRoots) {
-      mAsyncImageManager->SetWillGenerateFrame(renderRoot);
-    }
-    mCompositorScheduler->ScheduleComposition();
-  }
-}
-
 void WebRenderBridgeParent::FlushRendering(bool aWaitForPresent) {
   if (mDestroyed) {
     return;
   }
 
   // This gets called during e.g. window resizes, so we need to flush the
   // scene (which has the display list at the new window size).
   FlushSceneBuilds();
--- a/gfx/layers/wr/WebRenderBridgeParent.h
+++ b/gfx/layers/wr/WebRenderBridgeParent.h
@@ -226,28 +226,27 @@ class WebRenderBridgeParent final
    * to AsyncImagePipelines. If there is no update, WebRenderBridgeParent skips
    * to generate frame. If we need to generate new frame at next composite
    * timing, call this method.
    *
    * Call CompositorVsyncScheduler::ScheduleComposition() directly, if we just
    * want to trigger AsyncImagePipelines update checks.
    */
   void ScheduleGenerateFrame(const Maybe<wr::RenderRoot>& aRenderRoot);
-  void ScheduleGenerateFrame(const nsTArray<wr::RenderRoot>& aRenderRoots);
   void ScheduleGenerateFrameAllRenderRoots();
 
   /**
    * Schedule forced frame rendering at next composite timing.
    *
    * WebRender could skip frame rendering if there is no update.
    * This function is used to force rendering even when there is not update.
    */
   void ScheduleForcedGenerateFrame();
 
-  void NotifyDidSceneBuild(const nsTArray<wr::RenderRoot>& aRenderRoots,
+  void NotifyDidSceneBuild(wr::RenderRoot aRenderRoot,
                            RefPtr<wr::WebRenderPipelineInfo> aInfo);
 
   wr::Epoch UpdateWebRender(
       CompositorVsyncScheduler* aScheduler,
       nsTArray<RefPtr<wr::WebRenderAPI>>&& aApis,
       AsyncImagePipelineManager* aImageMgr,
       CompositorAnimationStorage* aAnimStorage,
       const TextureFactoryIdentifier& aTextureFactoryIdentifier);
--- a/gfx/thebes/gfxPlatform.cpp
+++ b/gfx/thebes/gfxPlatform.cpp
@@ -562,16 +562,18 @@ static void WebRenderDebugPrefChangeCall
                       wr::DebugFlags_NEW_SCENE_INDICATOR)
   GFX_WEBRENDER_DEBUG(".show-overdraw", wr::DebugFlags_SHOW_OVERDRAW)
   GFX_WEBRENDER_DEBUG(".gpu-cache", wr::DebugFlags_GPU_CACHE_DBG)
   GFX_WEBRENDER_DEBUG(".slow-frame-indicator",
                       wr::DebugFlags_SLOW_FRAME_INDICATOR)
   GFX_WEBRENDER_DEBUG(".texture-cache.clear-evicted",
                       wr::DebugFlags_TEXTURE_CACHE_DBG_CLEAR_EVICTED)
   GFX_WEBRENDER_DEBUG(".picture-caching", wr::DebugFlags_PICTURE_CACHING_DBG)
+  GFX_WEBRENDER_DEBUG(".texture-cache.disable-shrink",
+                      wr::DebugFlags_TEXTURE_CACHE_DBG_DISABLE_SHRINK)
   GFX_WEBRENDER_DEBUG(".primitives", wr::DebugFlags_PRIMITIVE_DBG)
   // Bit 18 is for the zoom display, which requires the mouse position and thus
   // currently only works in wrench.
   GFX_WEBRENDER_DEBUG(".small-screen", wr::DebugFlags_SMALL_SCREEN)
 #undef GFX_WEBRENDER_DEBUG
 
   gfx::gfxVars::SetWebRenderDebugFlags(flags.bits);
 }
--- a/gfx/webrender_bindings/RenderThread.cpp
+++ b/gfx/webrender_bindings/RenderThread.cpp
@@ -936,47 +936,36 @@ void wr_notifier_external_event(mozilla:
                                 size_t aRawEvent) {
   mozilla::UniquePtr<mozilla::wr::RendererEvent> evt(
       reinterpret_cast<mozilla::wr::RendererEvent*>(aRawEvent));
   mozilla::wr::RenderThread::Get()->RunEvent(mozilla::wr::WindowId(aWindowId),
                                              std::move(evt));
 }
 
 void wr_schedule_render(mozilla::wr::WrWindowId aWindowId,
-                        const mozilla::wr::WrDocumentId* aDocumentIds,
-                        size_t aDocumentIdsCount) {
+                        mozilla::wr::WrDocumentId aDocumentId) {
   RefPtr<mozilla::layers::CompositorBridgeParent> cbp = mozilla::layers::
       CompositorBridgeParent::GetCompositorBridgeParentFromWindowId(aWindowId);
   if (cbp) {
-    InfallibleTArray<wr::RenderRoot> renderRoots;
-    renderRoots.SetLength(aDocumentIdsCount);
-    for (size_t i = 0; i < aDocumentIdsCount; ++i) {
-      renderRoots[i] = wr::RenderRootFromId(aDocumentIds[i]);
-    }
-    cbp->ScheduleRenderOnCompositorThread(renderRoots);
+    cbp->ScheduleRenderOnCompositorThread(
+        Some(wr::RenderRootFromId(aDocumentId)));
   }
 }
 
 static void NotifyDidSceneBuild(RefPtr<layers::CompositorBridgeParent> aBridge,
-                                const nsTArray<wr::RenderRoot>& aRenderRoots,
+                                wr::DocumentId aRenderRootId,
                                 RefPtr<wr::WebRenderPipelineInfo> aInfo) {
-  aBridge->NotifyDidSceneBuild(aRenderRoots, aInfo);
+  aBridge->NotifyDidSceneBuild(wr::RenderRootFromId(aRenderRootId), aInfo);
 }
 
 void wr_finished_scene_build(mozilla::wr::WrWindowId aWindowId,
-                             const mozilla::wr::WrDocumentId* aDocumentIds,
-                             size_t aDocumentIdsCount,
+                             mozilla::wr::WrDocumentId aDocumentId,
                              mozilla::wr::WrPipelineInfo aInfo) {
   RefPtr<mozilla::layers::CompositorBridgeParent> cbp = mozilla::layers::
       CompositorBridgeParent::GetCompositorBridgeParentFromWindowId(aWindowId);
   RefPtr<wr::WebRenderPipelineInfo> info = new wr::WebRenderPipelineInfo(aInfo);
   if (cbp) {
-    InfallibleTArray<wr::RenderRoot> renderRoots;
-    renderRoots.SetLength(aDocumentIdsCount);
-    for (size_t i = 0; i < aDocumentIdsCount; ++i) {
-      renderRoots[i] = wr::RenderRootFromId(aDocumentIds[i]);
-    }
     layers::CompositorThreadHolder::Loop()->PostTask(NewRunnableFunction(
-        "NotifyDidSceneBuild", &NotifyDidSceneBuild, cbp, renderRoots, info));
+        "NotifyDidSceneBuild", &NotifyDidSceneBuild, cbp, aDocumentId, info));
   }
 }
 
 }  // extern C
--- a/gfx/webrender_bindings/WebRenderAPI.cpp
+++ b/gfx/webrender_bindings/WebRenderAPI.cpp
@@ -361,49 +361,16 @@ void WebRenderAPI::UpdateDebugFlags(uint
   }
 }
 
 void WebRenderAPI::SendTransaction(TransactionBuilder& aTxn) {
   UpdateDebugFlags(gfx::gfxVars::WebRenderDebugFlags());
   wr_api_send_transaction(mDocHandle, aTxn.Raw(), aTxn.UseSceneBuilderThread());
 }
 
-/* static */
-void WebRenderAPI::SendTransactions(
-    const RenderRootArray<RefPtr<WebRenderAPI>>& aApis,
-    RenderRootArray<TransactionBuilder*>& aTxns) {
-  if (!aApis[RenderRoot::Default]) {
-    return;
-  }
-
-  aApis[RenderRoot::Default]->UpdateDebugFlags(gfx::gfxVars::WebRenderDebugFlags());
-  AutoTArray<DocumentHandle*, kRenderRootCount> documentHandles;
-  AutoTArray<Transaction*, kRenderRootCount> txns;
-  Maybe<bool> useSceneBuilderThread;
-  for (auto& api : aApis) {
-    if (!api) {
-      continue;
-    }
-    auto& txn = aTxns[api->GetRenderRoot()];
-    if (txn) {
-      documentHandles.AppendElement(api->mDocHandle);
-      txns.AppendElement(txn->Raw());
-      if (useSceneBuilderThread.isSome()) {
-        MOZ_ASSERT(txn->UseSceneBuilderThread() == *useSceneBuilderThread);
-      } else {
-        useSceneBuilderThread.emplace(txn->UseSceneBuilderThread());
-      }
-    }
-  }
-  if (!txns.IsEmpty()) {
-    wr_api_send_transactions(documentHandles.Elements(), txns.Elements(),
-                             txns.Length(), *useSceneBuilderThread);
-  }
-}
-
 bool WebRenderAPI::HitTest(const wr::WorldPoint& aPoint,
                            wr::WrPipelineId& aOutPipelineId,
                            layers::ScrollableLayerGuid::ViewID& aOutScrollId,
                            gfx::CompositorHitTestInfo& aOutHitInfo) {
   static_assert(DoesCompositorHitTestInfoFitIntoBits<16>(),
                 "CompositorHitTestFlags MAX value has to be less than number "
                 "of bits in uint16_t");
 
--- a/gfx/webrender_bindings/WebRenderAPI.h
+++ b/gfx/webrender_bindings/WebRenderAPI.h
@@ -204,19 +204,16 @@ class WebRenderAPI final {
 
  public:
   /// This can be called on the compositor thread only.
   static already_AddRefed<WebRenderAPI> Create(
       layers::CompositorBridgeParent* aBridge,
       RefPtr<widget::CompositorWidget>&& aWidget,
       const wr::WrWindowId& aWindowId, LayoutDeviceIntSize aSize);
 
-  static void SendTransactions(const RenderRootArray<RefPtr<WebRenderAPI>>& aApis,
-                               RenderRootArray<TransactionBuilder*>& aTxns);
-
   already_AddRefed<WebRenderAPI> CreateDocument(LayoutDeviceIntSize aSize,
                                                 int8_t aLayerIndex,
                                                 wr::RenderRoot aRenderRoot);
 
   already_AddRefed<WebRenderAPI> Clone();
 
   wr::WindowId GetId() const { return mId; }
 
--- a/gfx/webrender_bindings/src/bindings.rs
+++ b/gfx/webrender_bindings/src/bindings.rs
@@ -576,23 +576,18 @@ struct CppNotifier {
 unsafe impl Send for CppNotifier {}
 
 extern "C" {
     fn wr_notifier_wake_up(window_id: WrWindowId);
     fn wr_notifier_new_frame_ready(window_id: WrWindowId);
     fn wr_notifier_nop_frame_done(window_id: WrWindowId);
     fn wr_notifier_external_event(window_id: WrWindowId,
                                   raw_event: usize);
-    fn wr_schedule_render(window_id: WrWindowId,
-                          document_id_array: *const WrDocumentId,
-                          document_id_count: usize);
-    fn wr_finished_scene_build(window_id: WrWindowId,
-                               document_id_array: *const WrDocumentId,
-                               document_id_count: usize,
-                               pipeline_info: WrPipelineInfo);
+    fn wr_schedule_render(window_id: WrWindowId, document_id: WrDocumentId);
+    fn wr_finished_scene_build(window_id: WrWindowId, document_id: WrDocumentId, pipeline_info: WrPipelineInfo);
 
     fn wr_transaction_notification_notified(handler: usize, when: Checkpoint);
 }
 
 impl RenderNotifier for CppNotifier {
     fn clone(&self) -> Box<RenderNotifier> {
         Box::new(CppNotifier {
             window_id: self.window_id,
@@ -916,33 +911,33 @@ impl SceneBuilderHooks for APZCallbacks 
 
     fn pre_scene_swap(&self, scenebuild_time: u64) {
         unsafe {
             record_telemetry_time(TelemetryProbe::SceneBuildTime, scenebuild_time);
             apz_pre_scene_swap(self.window_id);
         }
     }
 
-    fn post_scene_swap(&self, document_ids: &Vec<DocumentId>, info: PipelineInfo, sceneswap_time: u64) {
+    fn post_scene_swap(&self, document_id: DocumentId, info: PipelineInfo, sceneswap_time: u64) {
         unsafe {
             let info = WrPipelineInfo::new(&info);
             record_telemetry_time(TelemetryProbe::SceneSwapTime, sceneswap_time);
             apz_post_scene_swap(self.window_id, info);
         }
         let info = WrPipelineInfo::new(&info);
 
         // After a scene swap we should schedule a render for the next vsync,
         // otherwise there's no guarantee that the new scene will get rendered
         // anytime soon
-        unsafe { wr_finished_scene_build(self.window_id, document_ids.as_ptr(), document_ids.len(), info) }
+        unsafe { wr_finished_scene_build(self.window_id, document_id, info) }
         unsafe { gecko_profiler_end_marker(b"SceneBuilding\0".as_ptr() as *const c_char); }
     }
 
-    fn post_resource_update(&self, document_ids: &Vec<DocumentId>) {
-        unsafe { wr_schedule_render(self.window_id, document_ids.as_ptr(), document_ids.len()) }
+    fn post_resource_update(&self, document_id: DocumentId) {
+        unsafe { wr_schedule_render(self.window_id, document_id) }
         unsafe { gecko_profiler_end_marker(b"SceneBuilding\0".as_ptr() as *const c_char); }
     }
 
     fn post_empty_scene_build(&self) {
         unsafe { gecko_profiler_end_marker(b"SceneBuilding\0".as_ptr() as *const c_char); }
     }
 
     fn poke(&self) {
@@ -1721,40 +1716,16 @@ pub extern "C" fn wr_api_send_transactio
         return;
     }
     let new_txn = make_transaction(is_async);
     let txn = mem::replace(transaction, new_txn);
     dh.api.send_transaction(dh.document_id, txn);
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn wr_api_send_transactions(
-    document_handles: *const *const DocumentHandle,
-    transactions: *const *mut Transaction,
-    transaction_count: usize,
-    is_async: bool
-) {
-    if transaction_count == 0 {
-        return;
-    }
-    let mut out_transactions = Vec::with_capacity(transaction_count);
-    let mut out_documents = Vec::with_capacity(transaction_count);
-    for i in 0..transaction_count {
-        let txn = &mut **transactions.offset(i as isize);
-        debug_assert!(!txn.is_empty());
-        let new_txn = make_transaction(is_async);
-        out_transactions.push(mem::replace(txn, new_txn));
-        out_documents.push((**document_handles.offset(i as isize)).document_id);
-    }
-    (**document_handles).api.send_transactions(
-        out_documents,
-        out_transactions);
-}
-
-#[no_mangle]
 pub unsafe extern "C" fn wr_transaction_clear_display_list(
     txn: &mut Transaction,
     epoch: WrEpoch,
     pipeline_id: WrPipelineId,
 ) {
     let preserve_frame_state = true;
     let frame_builder = WebRenderFrameBuilder::new(pipeline_id, LayoutSize::zero());
 
--- a/gfx/wr/webrender/src/record.rs
+++ b/gfx/wr/webrender/src/record.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/. */
 
-use api::{ApiMsg, FrameMsg, SceneMsg, TransactionMsg};
+use api::{ApiMsg, FrameMsg, SceneMsg};
 use bincode::serialize;
 use byteorder::{LittleEndian, WriteBytesExt};
 use std::any::TypeId;
 use std::fmt::Debug;
 use std::fs::File;
 use std::io::Write;
 use std::mem;
 use std::path::PathBuf;
@@ -56,48 +56,39 @@ impl ApiRecordingReceiver for BinaryReco
 
     fn write_payload(&mut self, _: u32, data: &[u8]) {
         // signal payload with a 0 length
         self.file.write_u32::<LittleEndian>(0).ok();
         self.write_length_and_data(data);
     }
 }
 
-fn should_record_transaction_msg(msgs: &TransactionMsg) -> bool {
-    if msgs.generate_frame {
-        return true;
-    }
-
-    for msg in &msgs.scene_ops {
-        match *msg {
-            SceneMsg::SetDisplayList { .. } |
-            SceneMsg::SetRootPipeline { .. } => return true,
-            _ => {}
-        }
-    }
-
-    for msg in &msgs.frame_ops {
-        match *msg {
-            FrameMsg::GetScrollNodeState(..) |
-            FrameMsg::HitTest(..) => {}
-            _ => return true,
-        }
-    }
-
-    false
-}
-
 pub fn should_record_msg(msg: &ApiMsg) -> bool {
     match *msg {
         ApiMsg::UpdateResources(..) |
         ApiMsg::AddDocument { .. } |
         ApiMsg::DeleteDocument(..) => true,
-        ApiMsg::UpdateDocuments(_, ref msgs) => {
-            for msg in msgs {
-                if should_record_transaction_msg(msg) {
-                    return true;
+        ApiMsg::UpdateDocument(_, ref msgs) => {
+            if msgs.generate_frame {
+                return true;
+            }
+
+            for msg in &msgs.scene_ops {
+                match *msg {
+                    SceneMsg::SetDisplayList { .. } |
+                    SceneMsg::SetRootPipeline { .. } => return true,
+                    _ => {}
                 }
             }
+
+            for msg in &msgs.frame_ops {
+                match *msg {
+                    FrameMsg::GetScrollNodeState(..) |
+                    FrameMsg::HitTest(..) => {}
+                    _ => return true,
+                }
+            }
+
             false
         }
         _ => false,
     }
 }
--- a/gfx/wr/webrender/src/render_backend.rs
+++ b/gfx/wr/webrender/src/render_backend.rs
@@ -857,76 +857,67 @@ impl RenderBackend {
             sampler.register();
         }
 
         while keep_going {
             profile_scope!("handle_msg");
 
             while let Ok(msg) = self.scene_rx.try_recv() {
                 match msg {
-                    SceneBuilderResult::Transactions(mut txns, result_tx) => {
-                        self.resource_cache.before_frames(SystemTime::now());
-                        self.maybe_force_nop_documents(
+                    SceneBuilderResult::Transaction(mut txn, result_tx) => {
+                        let has_built_scene = txn.built_scene.is_some();
+                        if let Some(doc) = self.documents.get_mut(&txn.document_id) {
+
+                            doc.removed_pipelines.append(&mut txn.removed_pipelines);
+
+                            if let Some(mut built_scene) = txn.built_scene.take() {
+                                doc.new_async_scene_ready(
+                                    built_scene,
+                                    &mut self.recycler,
+                                );
+                            }
+
+                            if let Some(tx) = result_tx {
+                                let (resume_tx, resume_rx) = channel();
+                                tx.send(SceneSwapResult::Complete(resume_tx)).unwrap();
+                                // Block until the post-swap hook has completed on
+                                // the scene builder thread. We need to do this before
+                                // we can sample from the sampler hook which might happen
+                                // in the update_document call below.
+                                resume_rx.recv().ok();
+                            }
+                        } else {
+                            // The document was removed while we were building it, skip it.
+                            // TODO: we might want to just ensure that removed documents are
+                            // always forwarded to the scene builder thread to avoid this case.
+                            if let Some(tx) = result_tx {
+                                tx.send(SceneSwapResult::Aborted).unwrap();
+                            }
+                            continue;
+                        }
+
+                        self.resource_cache.add_rasterized_blob_images(
+                            txn.rasterized_blobs.take()
+                        );
+                        if let Some((rasterizer, info)) = txn.blob_rasterizer.take() {
+                            self.resource_cache.set_blob_rasterizer(rasterizer, info);
+                        }
+
+                        self.update_document(
+                            txn.document_id,
+                            txn.resource_updates.take(),
+                            txn.interner_updates.take(),
+                            txn.frame_ops.take(),
+                            txn.notifications.take(),
+                            txn.render_frame,
+                            txn.invalidate_rendered_frame,
                             &mut frame_counter,
                             &mut profile_counters,
-                            |document_id| txns.iter().any(|txn| txn.document_id == document_id));
-
-                        for mut txn in txns.drain(..) {
-                            let has_built_scene = txn.built_scene.is_some();
-                            if let Some(doc) = self.documents.get_mut(&txn.document_id) {
-
-                                doc.removed_pipelines.append(&mut txn.removed_pipelines);
-
-                                if let Some(mut built_scene) = txn.built_scene.take() {
-                                    doc.new_async_scene_ready(
-                                        built_scene,
-                                        &mut self.recycler,
-                                    );
-                                }
-
-                                if let Some(ref tx) = result_tx {
-                                    let (resume_tx, resume_rx) = channel();
-                                    tx.send(SceneSwapResult::Complete(resume_tx)).unwrap();
-                                    // Block until the post-swap hook has completed on
-                                    // the scene builder thread. We need to do this before
-                                    // we can sample from the sampler hook which might happen
-                                    // in the update_document call below.
-                                    resume_rx.recv().ok();
-                                }
-                            } else {
-                                // The document was removed while we were building it, skip it.
-                                // TODO: we might want to just ensure that removed documents are
-                                // always forwarded to the scene builder thread to avoid this case.
-                                if let Some(ref tx) = result_tx {
-                                    tx.send(SceneSwapResult::Aborted).unwrap();
-                                }
-                                continue;
-                            }
-
-                            self.resource_cache.add_rasterized_blob_images(
-                                txn.rasterized_blobs.take()
-                            );
-                            if let Some((rasterizer, info)) = txn.blob_rasterizer.take() {
-                                self.resource_cache.set_blob_rasterizer(rasterizer, info);
-                            }
-
-                            self.update_document(
-                                txn.document_id,
-                                txn.resource_updates.take(),
-                                txn.interner_updates.take(),
-                                txn.frame_ops.take(),
-                                txn.notifications.take(),
-                                txn.render_frame,
-                                txn.invalidate_rendered_frame,
-                                &mut frame_counter,
-                                &mut profile_counters,
-                                has_built_scene,
-                            );
-                        }
-                        self.resource_cache.after_frames();
+                            has_built_scene,
+                        );
                     },
                     SceneBuilderResult::FlushComplete(tx) => {
                         tx.send(()).ok();
                     }
                     SceneBuilderResult::ExternalEvent(evt) => {
                         self.notifier.external_event(evt);
                     }
                     SceneBuilderResult::ClearNamespace(id) => {
@@ -1124,17 +1115,17 @@ impl RenderBackend {
                                     epoch,
                                     pipeline_id,
                                     background: pipeline.background_color,
                                     viewport_size: pipeline.viewport_size,
                                     content_size: pipeline.content_size,
                                     preserve_frame_state: false,
                                 };
                                 let txn = TransactionMsg::scene_message(scene_msg);
-                                r.write_msg(*frame_counter, &ApiMsg::UpdateDocuments(vec![*id], vec![txn]));
+                                r.write_msg(*frame_counter, &ApiMsg::UpdateDocument(*id, txn));
                                 r.write_payload(*frame_counter, &Payload::construct_data(
                                     epoch,
                                     pipeline_id,
                                     pipeline.display_list.data(),
                                 ));
                             }
                         }
 
@@ -1181,175 +1172,122 @@ impl RenderBackend {
                 };
                 self.result_tx.send(msg).unwrap();
                 self.notifier.wake_up();
             }
             ApiMsg::ShutDown => {
                 info!("Recycling stats: {:?}", self.recycler);
                 return false;
             }
-            ApiMsg::UpdateDocuments(document_ids, transaction_msgs) => {
-                self.prepare_transactions(
-                    document_ids,
-                    transaction_msgs,
+            ApiMsg::UpdateDocument(document_id, transaction_msg) => {
+                self.prepare_transaction(
+                    document_id,
+                    transaction_msg,
                     frame_counter,
                     profile_counters,
                 );
             }
         }
 
         true
     }
 
-    fn prepare_transactions(
+    fn prepare_transaction(
         &mut self,
-        document_ids: Vec<DocumentId>,
-        mut transaction_msgs: Vec<TransactionMsg>,
+        document_id: DocumentId,
+        mut transaction_msg: TransactionMsg,
         frame_counter: &mut u32,
         profile_counters: &mut BackendProfileCounters,
     ) {
-        let mut use_scene_builder = transaction_msgs.iter()
-            .any(|transaction_msg| transaction_msg.use_scene_builder_thread);
-        let use_high_priority = transaction_msgs.iter()
-            .any(|transaction_msg| !transaction_msg.low_priority);
-
-        let mut txns : Vec<Box<Transaction>> = document_ids.iter().zip(transaction_msgs.drain(..))
-            .map(|(&document_id, mut transaction_msg)| {
-                let mut txn = Box::new(Transaction {
-                    document_id,
-                    display_list_updates: Vec::new(),
-                    removed_pipelines: Vec::new(),
-                    epoch_updates: Vec::new(),
-                    request_scene_build: None,
-                    blob_rasterizer: None,
-                    blob_requests: Vec::new(),
-                    resource_updates: transaction_msg.resource_updates,
-                    frame_ops: transaction_msg.frame_ops,
-                    rasterized_blobs: Vec::new(),
-                    notifications: transaction_msg.notifications,
-                    set_root_pipeline: None,
-                    render_frame: transaction_msg.generate_frame,
-                    invalidate_rendered_frame: transaction_msg.invalidate_rendered_frame,
-                });
-
-                self.resource_cache.pre_scene_building_update(
-                    &mut txn.resource_updates,
-                    &mut profile_counters.resources,
-                );
-
-                // If we've been above the threshold for reclaiming GPU cache memory for
-                // long enough, drop it and rebuild it. This needs to be done before any
-                // updates for this frame are made.
-                if self.gpu_cache.should_reclaim_memory() {
-                    self.gpu_cache.clear();
-                }
-
-                for scene_msg in transaction_msg.scene_ops.drain(..) {
-                    let _timer = profile_counters.total_time.timer();
-                    self.process_scene_msg(
-                        document_id,
-                        scene_msg,
-                        *frame_counter,
-                        &mut txn,
-                        &mut profile_counters.ipc,
-                    )
-                }
-
-                let blobs_to_rasterize = get_blob_image_updates(&txn.resource_updates);
-                if !blobs_to_rasterize.is_empty() {
-                    let (blob_rasterizer, blob_requests) = self.resource_cache
-                        .create_blob_scene_builder_requests(&blobs_to_rasterize);
-
-                    txn.blob_requests = blob_requests;
-                    txn.blob_rasterizer = blob_rasterizer;
-                }
-                txn
-            }).collect();
-
-        use_scene_builder = use_scene_builder || txns.iter().any(|txn| {
-            !txn.can_skip_scene_builder() || txn.blob_rasterizer.is_some()
+        let mut txn = Box::new(Transaction {
+            document_id,
+            display_list_updates: Vec::new(),
+            removed_pipelines: Vec::new(),
+            epoch_updates: Vec::new(),
+            request_scene_build: None,
+            blob_rasterizer: None,
+            blob_requests: Vec::new(),
+            resource_updates: transaction_msg.resource_updates,
+            frame_ops: transaction_msg.frame_ops,
+            rasterized_blobs: Vec::new(),
+            notifications: transaction_msg.notifications,
+            set_root_pipeline: None,
+            render_frame: transaction_msg.generate_frame,
+            invalidate_rendered_frame: transaction_msg.invalidate_rendered_frame,
         });
 
-        if use_scene_builder {
-            for txn in txns.iter_mut() {
-                let doc = self.documents.get_mut(&txn.document_id).unwrap();
+        self.resource_cache.pre_scene_building_update(
+            &mut txn.resource_updates,
+            &mut profile_counters.resources,
+        );
+
+        // If we've been above the threshold for reclaiming GPU cache memory for
+        // long enough, drop it and rebuild it. This needs to be done before any
+        // updates for this frame are made.
+        if self.gpu_cache.should_reclaim_memory() {
+            self.gpu_cache.clear();
+        }
 
-                if txn.should_build_scene() {
-                    txn.request_scene_build = Some(SceneRequest {
-                        view: doc.view.clone(),
-                        font_instances: self.resource_cache.get_font_instances(),
-                        output_pipelines: doc.output_pipelines.clone(),
-                    });
-                }
-            }
-        } else {
-            self.resource_cache.before_frames(SystemTime::now());
-            self.maybe_force_nop_documents(
+        for scene_msg in transaction_msg.scene_ops.drain(..) {
+            let _timer = profile_counters.total_time.timer();
+            self.process_scene_msg(
+                document_id,
+                scene_msg,
+                *frame_counter,
+                &mut txn,
+                &mut profile_counters.ipc,
+            )
+        }
+
+        let blobs_to_rasterize = get_blob_image_updates(&txn.resource_updates);
+        if !blobs_to_rasterize.is_empty() {
+            let (blob_rasterizer, blob_requests) = self.resource_cache
+                .create_blob_scene_builder_requests(&blobs_to_rasterize);
+
+            txn.blob_requests = blob_requests;
+            txn.blob_rasterizer = blob_rasterizer;
+        }
+
+        if !transaction_msg.use_scene_builder_thread &&
+            txn.can_skip_scene_builder() &&
+            txn.blob_rasterizer.is_none() {
+
+            self.update_document(
+                txn.document_id,
+                txn.resource_updates.take(),
+                None,
+                txn.frame_ops.take(),
+                txn.notifications.take(),
+                txn.render_frame,
+                txn.invalidate_rendered_frame,
                 frame_counter,
                 profile_counters,
-                |document_id| txns.iter().any(|txn| txn.document_id == document_id));
+                false
+            );
 
-            for mut txn in txns {
-                self.update_document(
-                    txn.document_id,
-                    txn.resource_updates.take(),
-                    None,
-                    txn.frame_ops.take(),
-                    txn.notifications.take(),
-                    txn.render_frame,
-                    txn.invalidate_rendered_frame,
-                    frame_counter,
-                    profile_counters,
-                    false
-                );                
-            }
-
-            self.resource_cache.after_frames();
             return;
         }
 
-        let tx = if use_high_priority {
+        let doc = self.documents.get_mut(&document_id).unwrap();
+
+        if txn.should_build_scene() {
+            txn.request_scene_build = Some(SceneRequest {
+                view: doc.view.clone(),
+                font_instances: self.resource_cache.get_font_instances(),
+                output_pipelines: doc.output_pipelines.clone(),
+            });
+        }
+
+        let tx = if transaction_msg.low_priority {
+            &self.low_priority_scene_tx
+        } else {
             &self.scene_tx
-        } else {
-            &self.low_priority_scene_tx
         };
 
-        tx.send(SceneBuilderRequest::Transactions(txns)).unwrap();
-    }
-
-    /// In certain cases, resources shared by multiple documents have to run
-    /// maintenance operations, like cleaning up unused cache items. In those
-    /// cases, we are forced to build frames for all documents, however we
-    /// may not have a transaction ready for every document - this method
-    /// calls update_document with the details of a fake, nop transaction just
-    /// to force a frame build.
-    fn maybe_force_nop_documents<F>(&mut self,
-                                    frame_counter: &mut u32,
-                                    profile_counters: &mut BackendProfileCounters,
-                                    document_already_present: F) where
-        F: Fn(DocumentId) -> bool {
-        if self.resource_cache.requires_frame_build() {
-            let nop_documents : Vec<DocumentId> = self.documents.keys()
-                .cloned()
-                .filter(|key| !document_already_present(*key))
-                .collect();
-            for &document_id in &nop_documents {
-                self.update_document(
-                    document_id,
-                    Vec::default(),
-                    None,
-                    Vec::default(),
-                    Vec::default(),
-                    false,
-                    false,
-                    frame_counter,
-                    profile_counters,
-                    false);
-            }
-        }
+        tx.send(SceneBuilderRequest::Transaction(txn)).unwrap();
     }
 
     fn update_document(
         &mut self,
         document_id: DocumentId,
         resource_updates: Vec<ResourceUpdate>,
         interner_updates: Option<InternerUpdates>,
         mut frame_ops: Vec<FrameMsg>,
@@ -1410,19 +1348,17 @@ impl RenderBackend {
         if !doc.can_render() {
             // TODO: this happens if we are building the first scene asynchronously and
             // scroll at the same time. we should keep track of the fact that we skipped
             // composition here and do it as soon as we receive the scene.
             render_frame = false;
         }
 
         // Avoid re-building the frame if the current built frame is still valid.
-        let build_frame = (render_frame && !doc.frame_is_valid) ||
-            self.resource_cache.requires_frame_build() &&
-            doc.frame_builder.is_some();
+        let build_frame = render_frame && !doc.frame_is_valid;
 
         // Request composite is true when we want to composite frame even when
         // there is no frame update. This happens when video frame is updated under
         // external image with NativeTexture or when platform requested to composite frame.
         if invalidate_rendered_frame {
             doc.rendered_frame_is_valid = false;
         }
 
--- a/gfx/wr/webrender/src/renderer.rs
+++ b/gfx/wr/webrender/src/renderer.rs
@@ -5491,21 +5491,21 @@ pub trait SceneBuilderHooks {
     fn register(&self);
     /// This is called before each scene build starts.
     fn pre_scene_build(&self);
     /// This is called before each scene swap occurs.
     fn pre_scene_swap(&self, scenebuild_time: u64);
     /// This is called after each scene swap occurs. The PipelineInfo contains
     /// the updated epochs and pipelines removed in the new scene compared to
     /// the old scene.
-    fn post_scene_swap(&self, document_id: &Vec<DocumentId>, info: PipelineInfo, sceneswap_time: u64);
+    fn post_scene_swap(&self, document_id: DocumentId, info: PipelineInfo, sceneswap_time: u64);
     /// This is called after a resource update operation on the scene builder
     /// thread, in the case where resource updates were applied without a scene
     /// build.
-    fn post_resource_update(&self, document_ids: &Vec<DocumentId>);
+    fn post_resource_update(&self, document_id: DocumentId);
     /// This is called after a scene build completes without any changes being
     /// made. We guarantee that each pre_scene_build call will be matched with
     /// exactly one of post_scene_swap, post_resource_update or
     /// post_empty_scene_build.
     fn post_empty_scene_build(&self);
     /// This is a generic callback which provides an opportunity to run code
     /// on the scene builder thread. This is called as part of the main message
     /// loop of the scene builder thread, but outside of any specific message
--- a/gfx/wr/webrender/src/resource_cache.rs
+++ b/gfx/wr/webrender/src/resource_cache.rs
@@ -37,17 +37,16 @@ use std::collections::hash_map::IterMut;
 use std::collections::VecDeque;
 use std::{cmp, mem};
 use std::fmt::Debug;
 use std::hash::Hash;
 use std::os::raw::c_void;
 #[cfg(any(feature = "capture", feature = "replay"))]
 use std::path::PathBuf;
 use std::sync::{Arc, RwLock};
-use std::time::SystemTime;
 use texture_cache::{TextureCache, TextureCacheHandle, Eviction};
 use util::drain_filter;
 
 const DEFAULT_TILE_SIZE: TileSize = 512;
 
 #[cfg_attr(feature = "capture", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
 pub struct GlyphFetchResult {
@@ -1564,28 +1563,16 @@ impl ResourceCache {
             ImageProperties {
                 descriptor: image_template.descriptor,
                 external_image,
                 tiling: image_template.tiling,
             }
         })
     }
 
-    pub fn before_frames(&mut self, time: SystemTime) {
-        self.texture_cache.before_frames(time);
-    }
-
-    pub fn after_frames(&mut self) {
-        self.texture_cache.after_frames();
-    }
-
-    pub fn requires_frame_build(&self) -> bool {
-        self.texture_cache.requires_frame_build()
-    }
-
     pub fn begin_frame(&mut self, stamp: FrameStamp) {
         debug_assert_eq!(self.state, State::Idle);
         self.state = State::AddResources;
         self.texture_cache.begin_frame(stamp);
         self.cached_glyphs.begin_frame(&self.texture_cache, &self.cached_render_tasks, &mut self.glyph_rasterizer);
         self.cached_render_tasks.begin_frame(&mut self.texture_cache);
         self.current_frame_id = stamp.frame_id();
 
--- a/gfx/wr/webrender/src/scene_builder.rs
+++ b/gfx/wr/webrender/src/scene_builder.rs
@@ -23,17 +23,16 @@ use prim_store::gradient::{LinearGradien
 use prim_store::image::{Image, YuvImage};
 use prim_store::line_dec::LineDecoration;
 use prim_store::picture::Picture;
 use prim_store::text_run::TextRun;
 use resource_cache::{AsyncBlobImageInfo, FontInstanceMap};
 use render_backend::DocumentView;
 use renderer::{PipelineInfo, SceneBuilderHooks};
 use scene::Scene;
-use std::iter;
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::mem::replace;
 use time::precise_time_ns;
 use util::drain_filter;
 use std::thread;
 use std::time::Duration;
 
 
@@ -132,17 +131,17 @@ pub struct LoadScene {
 pub struct BuiltScene {
     pub scene: Scene,
     pub frame_builder: FrameBuilder,
     pub clip_scroll_tree: ClipScrollTree,
 }
 
 // Message from render backend to scene builder.
 pub enum SceneBuilderRequest {
-    Transactions(Vec<Box<Transaction>>),
+    Transaction(Box<Transaction>),
     ExternalEvent(ExternalEvent),
     DeleteDocument(DocumentId),
     WakeUp,
     Flush(MsgSender<()>),
     ClearNamespace(IdNamespace),
     SetFrameBuilderConfig(FrameBuilderConfig),
     SimulateLongSceneBuild(u32),
     SimulateLongLowPrioritySceneBuild(u32),
@@ -151,17 +150,17 @@ pub enum SceneBuilderRequest {
     #[cfg(feature = "capture")]
     SaveScene(CaptureConfig),
     #[cfg(feature = "replay")]
     LoadScenes(Vec<LoadScene>),
 }
 
 // Message from scene builder to render backend.
 pub enum SceneBuilderResult {
-    Transactions(Vec<Box<BuiltTransaction>>, Option<Sender<SceneSwapResult>>),
+    Transaction(Box<BuiltTransaction>, Option<Sender<SceneSwapResult>>),
     ExternalEvent(ExternalEvent),
     FlushComplete(MsgSender<()>),
     ClearNamespace(IdNamespace),
     Stopped,
 }
 
 // Message from render backend to scene builder to indicate the
 // scene swap was completed. We need a separate channel for this
@@ -317,21 +316,19 @@ impl SceneBuilder {
         }
 
         loop {
             match self.rx.recv() {
                 Ok(SceneBuilderRequest::WakeUp) => {}
                 Ok(SceneBuilderRequest::Flush(tx)) => {
                     self.send(SceneBuilderResult::FlushComplete(tx));
                 }
-                Ok(SceneBuilderRequest::Transactions(mut txns)) => {
-                    let built_txns : Vec<Box<BuiltTransaction>> = txns.iter_mut()
-                        .map(|txn| self.process_transaction(txn))
-                        .collect();
-                    self.forward_built_transactions(built_txns);
+                Ok(SceneBuilderRequest::Transaction(mut txn)) => {
+                    let built_txn = self.process_transaction(&mut txn);
+                    self.forward_built_transaction(built_txn);
                 }
                 Ok(SceneBuilderRequest::DeleteDocument(document_id)) => {
                     self.documents.remove(&document_id);
                 }
                 Ok(SceneBuilderRequest::SetFrameBuilderConfig(cfg)) => {
                     self.config = cfg;
                 }
                 Ok(SceneBuilderRequest::ClearNamespace(id)) => {
@@ -427,33 +424,33 @@ impl SceneBuilder {
                 item.document_id,
                 Document {
                     scene: item.scene,
                     interners: item.interners,
                     doc_stats: DocumentStats::empty(),
                 },
             );
 
-            let txns = vec![Box::new(BuiltTransaction {
+            let txn = Box::new(BuiltTransaction {
                 document_id: item.document_id,
                 render_frame: item.build_frame,
                 invalidate_rendered_frame: false,
                 built_scene,
                 resource_updates: Vec::new(),
                 rasterized_blobs: Vec::new(),
                 blob_rasterizer: None,
                 frame_ops: Vec::new(),
                 removed_pipelines: Vec::new(),
                 notifications: Vec::new(),
                 scene_build_start_time,
                 scene_build_end_time: precise_time_ns(),
                 interner_updates,
-            })];
+            });
 
-            self.forward_built_transactions(txns);
+            self.forward_built_transaction(txn);
         }
     }
 
     /// Do the bulk of the work of the scene builder thread.
     fn process_transaction(&mut self, txn: &mut Transaction) -> Box<BuiltTransaction> {
         if let &Some(ref hooks) = &self.hooks {
             hooks.pre_scene_build();
         }
@@ -548,78 +545,65 @@ impl SceneBuilder {
             removed_pipelines: replace(&mut txn.removed_pipelines, Vec::new()),
             notifications: replace(&mut txn.notifications, Vec::new()),
             interner_updates,
             scene_build_start_time,
             scene_build_end_time: precise_time_ns(),
         })
     }
 
-    /// Send the results of process_transaction back to the render backend.
-    fn forward_built_transactions(&mut self, txns: Vec<Box<BuiltTransaction>>) {
-        let (pipeline_info, result_tx, result_rx) = match &self.hooks {
-            &Some(ref hooks) => {
-                if txns.iter().any(|txn| txn.built_scene.is_some()) {
-                    let info = PipelineInfo {
-                        epochs: txns.iter()
-                            .filter(|txn| txn.built_scene.is_some())
-                            .map(|txn| {
-                                txn.built_scene.as_ref().unwrap()
-                                    .scene.pipeline_epochs.iter()
-                                    .zip(iter::repeat(txn.document_id))
-                                    .map(|((&pipeline_id, &epoch), document_id)| ((pipeline_id, document_id), epoch))
-                            }).flatten().collect(),
-                        removed_pipelines: txns.iter()
-                            .map(|txn| txn.removed_pipelines.clone())
-                            .flatten().collect(),
-                    };
+    /// Send the result of process_transaction back to the render backend.
+    fn forward_built_transaction(&mut self, txn: Box<BuiltTransaction>) {
+        // We only need the pipeline info and the result channel if we
+        // have a hook callback *and* if this transaction actually built
+        // a new scene that is going to get swapped in. In other cases
+        // pipeline_info can be None and we can avoid some overhead from
+        // invoking the hooks and blocking on the channel.
+        let (pipeline_info, result_tx, result_rx) = match (&self.hooks, &txn.built_scene) {
+            (&Some(ref hooks), &Some(ref built)) => {
+                let info = PipelineInfo {
+                    epochs: built.scene.pipeline_epochs.iter()
+                        .map(|(&pipeline_id, &epoch)| ((pipeline_id, txn.document_id), epoch))
+                        .collect(),
+                    removed_pipelines: txn.removed_pipelines.clone(),
+                };
+                let (tx, rx) = channel();
 
-                    let (tx, rx) = channel();
-                    let txn = txns.iter().find(|txn| txn.built_scene.is_some()).unwrap();
-                    hooks.pre_scene_swap(txn.scene_build_end_time - txn.scene_build_start_time);
+                hooks.pre_scene_swap(txn.scene_build_end_time - txn.scene_build_start_time);
 
-                    (Some(info), Some(tx), Some(rx))
-                } else {
-                    (None, None, None)
-                }
+                (Some(info), Some(tx), Some(rx))
             }
-            _ => (None, None, None)
+            _ => (None, None, None),
         };
 
+        let document_id = txn.document_id;
         let scene_swap_start_time = precise_time_ns();
-        let document_ids = txns.iter().map(|txn| txn.document_id).collect();
-        let have_resources_updates : Vec<DocumentId> = if pipeline_info.is_none() {
-            txns.iter()
-                .filter(|txn| !txn.resource_updates.is_empty() || txn.invalidate_rendered_frame)
-                .map(|txn| txn.document_id.clone())
-                .collect()
-        } else {
-            Vec::new()
-        };
+        let has_resources_updates = !txn.resource_updates.is_empty();
+        let invalidate_rendered_frame = txn.invalidate_rendered_frame;
 
-        self.tx.send(SceneBuilderResult::Transactions(txns, result_tx)).unwrap();
+        self.tx.send(SceneBuilderResult::Transaction(txn, result_tx)).unwrap();
 
         let _ = self.api_tx.send(ApiMsg::WakeUp);
 
         if let Some(pipeline_info) = pipeline_info {
             // Block until the swap is done, then invoke the hook.
             let swap_result = result_rx.unwrap().recv();
             let scene_swap_time = precise_time_ns() - scene_swap_start_time;
-            self.hooks.as_ref().unwrap().post_scene_swap(&document_ids,
+            self.hooks.as_ref().unwrap().post_scene_swap(document_id,
                                                          pipeline_info, scene_swap_time);
             // Once the hook is done, allow the RB thread to resume
             match swap_result {
                 Ok(SceneSwapResult::Complete(resume_tx)) => {
                     resume_tx.send(()).ok();
                 },
                 _ => (),
             };
-        } else if !have_resources_updates.is_empty() {
+        } else if has_resources_updates || invalidate_rendered_frame {
             if let &Some(ref hooks) = &self.hooks {
-                hooks.post_resource_update(&have_resources_updates);
+                hooks.post_resource_update(document_id);
             }
         } else {
             if let &Some(ref hooks) = &self.hooks {
                 hooks.post_empty_scene_build();
             }
         }
     }
 
@@ -645,21 +629,19 @@ pub struct LowPrioritySceneBuilder {
     pub tx: Sender<SceneBuilderRequest>,
     pub simulate_slow_ms: u32,
 }
 
 impl LowPrioritySceneBuilder {
     pub fn run(&mut self) {
         loop {
             match self.rx.recv() {
-                Ok(SceneBuilderRequest::Transactions(mut txns)) => {
-                    let txns : Vec<Box<Transaction>> = txns.drain(..)
-                        .map(|txn| self.process_transaction(txn))
-                        .collect();
-                    self.tx.send(SceneBuilderRequest::Transactions(txns)).unwrap();
+                Ok(SceneBuilderRequest::Transaction(txn)) => {
+                    let txn = self.process_transaction(txn);
+                    self.tx.send(SceneBuilderRequest::Transaction(txn)).unwrap();
                 }
                 Ok(SceneBuilderRequest::DeleteDocument(document_id)) => {
                     self.tx.send(SceneBuilderRequest::DeleteDocument(document_id)).unwrap();
                 }
                 Ok(SceneBuilderRequest::Stop) => {
                     self.tx.send(SceneBuilderRequest::Stop).unwrap();
                     break;
                 }
--- a/gfx/wr/webrender/src/texture_cache.rs
+++ b/gfx/wr/webrender/src/texture_cache.rs
@@ -29,20 +29,16 @@ const PICTURE_TEXTURE_ADD_SLICES: usize 
 
 /// The chosen image format for picture tiles.
 const PICTURE_TILE_FORMAT: ImageFormat = ImageFormat::BGRA8;
 
 /// The number of pixels in a region. Derived from the above.
 const TEXTURE_REGION_PIXELS: usize =
     (TEXTURE_REGION_DIMENSIONS as usize) * (TEXTURE_REGION_DIMENSIONS as usize);
 
-// The minimum number of bytes that we must be able to reclaim in order
-// to justify clearing the entire shared cache in order to shrink it.
-const RECLAIM_THRESHOLD_BYTES: usize = 5 * 1024 * 1024;
-
 /// Items in the texture cache can either be standalone textures,
 /// or a sub-rect inside the shared cache.
 #[derive(Debug)]
 #[cfg_attr(feature = "capture", derive(Serialize))]
 #[cfg_attr(feature = "replay", derive(Deserialize))]
 enum EntryDetails {
     Standalone,
     Picture {
@@ -511,20 +507,16 @@ pub struct TextureCache {
     /// document, then we might end up erroneously evicting items out from
     /// under that document.
     per_doc_data: FastHashMap<DocumentId, PerDocumentData>,
 
     /// The current document's data. This is moved out of per_doc_data in
     /// begin_frame and moved back in end_frame to solve borrow checker issues.
     /// We should try removing this when we require a rustc with NLL.
     doc_data: PerDocumentData,
-
-    /// This indicates that we performed a cleanup operation which requires all
-    /// documents to build a frame.
-    require_frame_build: bool,
 }
 
 impl TextureCache {
     pub fn new(
         max_texture_size: i32,
         mut max_texture_layers: usize,
         picture_tile_size: Option<DeviceIntSize>,
         initial_size: FramebufferIntSize,
@@ -584,17 +576,16 @@ impl TextureCache {
             max_texture_size,
             max_texture_layers,
             debug_flags: DebugFlags::empty(),
             next_id: CacheTextureId(2),
             pending_updates,
             now: FrameStamp::INVALID,
             per_doc_data: FastHashMap::default(),
             doc_data: PerDocumentData::new(),
-            require_frame_build: false,
         }
     }
 
     /// Creates a TextureCache and sets it up with a valid `FrameStamp`, which
     /// is useful for avoiding panics when instantiating the `TextureCache`
     /// directly from unit test code.
     #[cfg(test)]
     pub fn new_for_testing(max_texture_size: i32, max_texture_layers: usize) -> Self {
@@ -606,31 +597,37 @@ impl TextureCache {
     }
 
     pub fn set_debug_flags(&mut self, flags: DebugFlags) {
         self.debug_flags = flags;
     }
 
     /// Clear all entries of the specified kind.
     fn clear_kind(&mut self, kind: EntryKind) {
+        // This pref just helps us avoid crashes when we begin using multiple documents.
+        // What we need to do for clear to work correctly with multiple documents is
+        // to ensure that we generate frames for all documents whenever we do this.
+        if self.debug_flags.contains(DebugFlags::TEXTURE_CACHE_DBG_DISABLE_SHRINK) {
+            return;
+        }
+
         let mut per_doc_data = mem::replace(&mut self.per_doc_data, FastHashMap::default());
         for (&_, doc_data) in per_doc_data.iter_mut() {
             let entry_handles = mem::replace(
                 doc_data.handles.select(kind),
                 Vec::new(),
             );
 
             for handle in entry_handles {
                 let entry = self.entries.free(handle);
                 entry.evict();
                 self.free(&entry);
             }
         }
         self.per_doc_data = per_doc_data;
-        self.require_frame_build = true;
     }
 
     fn clear_standalone(&mut self) {
         debug_assert!(!self.now.is_valid());
         self.clear_kind(EntryKind::Standalone);
     }
 
     fn clear_picture(&mut self) {
@@ -638,16 +635,19 @@ impl TextureCache {
         if let Some(ref mut picture_texture) = self.picture_texture {
             if let Some(texture_id) = picture_texture.reset(PICTURE_TEXTURE_ADD_SLICES) {
                 self.pending_updates.push_realloc(texture_id, picture_texture.to_info());
             }
         }
     }
 
     fn clear_shared(&mut self) {
+        if self.debug_flags.contains(DebugFlags::TEXTURE_CACHE_DBG_DISABLE_SHRINK) {
+            return;
+        }
         self.unset_doc_data();
         self.clear_kind(EntryKind::Shared);
         self.shared_textures.clear(&mut self.pending_updates);
         self.set_doc_data();
     }
 
     /// Clear all entries in the texture cache. This is a fairly drastic
     /// step that should only be called very rarely.
@@ -664,68 +664,31 @@ impl TextureCache {
                             .unwrap_or_else(|| PerDocumentData::new());
     }
 
     fn unset_doc_data(&mut self) {
         self.per_doc_data.insert(self.now.document_id(),
                                  mem::replace(&mut self.doc_data, PerDocumentData::new()));
     }
 
-    pub fn before_frames(&mut self, time: SystemTime) {
-        self.maybe_reclaim_shared_memory(time);
-    }
-
-    pub fn after_frames(&mut self) {
-        self.require_frame_build = false;
-    }
-
-    pub fn requires_frame_build(&self) -> bool {
-        return self.require_frame_build;
-    }
-
     /// Called at the beginning of each frame.
     pub fn begin_frame(&mut self, stamp: FrameStamp) {
         debug_assert!(!self.now.is_valid());
         self.now = stamp;
         self.set_doc_data();
-        self.maybe_do_periodic_gc();
+        self.maybe_reclaim_shared_cache_memory();
     }
 
-    fn maybe_reclaim_shared_memory(&mut self, time: SystemTime) {
-        // If we've had a sufficient number of unused layers for a sufficiently
-        // long time, just blow the whole cache away to shrink it.
-        //
-        // We could do this more intelligently with a resize+blit, but that would
-        // add complexity for a rare case.
-        //
-        // This function must be called before the first begin_frame() for a group
-        // of documents, otherwise documents could end up ignoring the
-        // self.require_frame_build flag which is set if we end up calling
-        // clear_shared.
-        debug_assert!(!self.now.is_valid());
-        if self.shared_textures.empty_region_bytes() >= RECLAIM_THRESHOLD_BYTES {
-            self.reached_reclaim_threshold.get_or_insert(time);
-        } else {
-            self.reached_reclaim_threshold = None;
-        }
-        if let Some(t) = self.reached_reclaim_threshold {
-            let dur = time.duration_since(t).unwrap_or(Duration::default());
-            if dur >= Duration::from_secs(5) {
-                self.clear_shared();
-                self.reached_reclaim_threshold = None;
-            }
-        }
-    }
-
-    /// Called at the beginning of each frame to periodically GC by expiring
-    /// old shared entries. If necessary, the shared memory opened up as a
-    /// result of expiring these entries will be reclaimed before the next
-    /// group of document frames.
-    fn maybe_do_periodic_gc(&mut self) {
+    /// Called at the beginning of each frame to periodically GC and reclaim
+    /// storage if the cache has grown too large.
+    fn maybe_reclaim_shared_cache_memory(&mut self) {
         debug_assert!(self.now.is_valid());
+        // The minimum number of bytes that we must be able to reclaim in order
+        // to justify clearing the entire shared cache in order to shrink it.
+        const RECLAIM_THRESHOLD_BYTES: usize = 5 * 1024 * 1024;
 
         // Normally the shared cache only gets GCed when we fail to allocate.
         // However, we also perform a periodic, conservative GC to ensure that
         // we recover unused memory in bounded time, rather than having it
         // depend on allocation patterns of subsequent content.
         let time_since_last_gc = self.now.time()
             .duration_since(self.doc_data.last_shared_cache_expiration.time())
             .unwrap_or(Duration::default());
@@ -733,16 +696,38 @@ impl TextureCache {
             self.shared_textures.size_in_bytes() >= RECLAIM_THRESHOLD_BYTES * 2;
         if do_periodic_gc {
             let threshold = EvictionThresholdBuilder::new(self.now)
                 .max_frames(1)
                 .max_time_s(10)
                 .build();
             self.maybe_expire_old_shared_entries(threshold);
         }
+
+        // If we've had a sufficient number of unused layers for a sufficiently
+        // long time, just blow the whole cache away to shrink it.
+        //
+        // We could do this more intelligently with a resize+blit, but that would
+        // add complexity for a rare case.
+        //
+        // This block of code is broken with multiple documents, and should be
+        // moved out into a section that runs before building any frames in a
+        // group of documents.
+        if self.shared_textures.empty_region_bytes() >= RECLAIM_THRESHOLD_BYTES {
+            self.reached_reclaim_threshold.get_or_insert(self.now.time());
+        } else {
+            self.reached_reclaim_threshold = None;
+        }
+        if let Some(t) = self.reached_reclaim_threshold {
+            let dur = self.now.time().duration_since(t).unwrap_or(Duration::default());
+            if dur >= Duration::from_secs(5) {
+                self.clear_shared();
+                self.reached_reclaim_threshold = None;
+            }
+        }
     }
 
     pub fn end_frame(&mut self, texture_cache_profile: &mut TextureCacheProfileCounters) {
         debug_assert!(self.now.is_valid());
         // Expire standalone entries.
         //
         // Most of the time, standalone cache entries correspond to images whose
         // width or height is greater than the region size in the shared cache, i.e.
--- a/gfx/wr/webrender_api/src/api.rs
+++ b/gfx/wr/webrender_api/src/api.rs
@@ -434,21 +434,16 @@ impl Transaction {
         self.resource_updates.append(&mut other);
     }
 
     pub fn clear(&mut self) {
         self.resource_updates.clear()
     }
 }
 
-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 {
     pub scene_ops: Vec<SceneMsg>,
     pub frame_ops: Vec<FrameMsg>,
     pub resource_updates: Vec<ResourceUpdate>,
     pub generate_frame: bool,
     pub invalidate_rendered_frame: bool,
@@ -726,17 +721,17 @@ pub enum ApiMsg {
     GetGlyphIndices(font::FontKey, String, MsgSender<Vec<Option<u32>>>),
     /// Adds a new document namespace.
     CloneApi(MsgSender<IdNamespace>),
     /// Adds a new document namespace.
     CloneApiByClient(IdNamespace),
     /// Adds a new document with given initial size.
     AddDocument(DocumentId, FramebufferIntSize, DocumentLayer),
     /// A message targeted at a particular document.
-    UpdateDocuments(Vec<DocumentId>, Vec<TransactionMsg>),
+    UpdateDocument(DocumentId, TransactionMsg),
     /// Deletes an existing document.
     DeleteDocument(DocumentId),
     /// An opaque handle that must be passed to the render notifier. It is used by Gecko
     /// to forward gecko-specific messages to the render thread preserving the ordering
     /// within the other messages.
     ExternalEvent(ExternalEvent),
     /// Removes all resources associated with a namespace.
     ClearNamespace(IdNamespace),
@@ -758,17 +753,17 @@ impl fmt::Debug for ApiMsg {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str(match *self {
             ApiMsg::UpdateResources(..) => "ApiMsg::UpdateResources",
             ApiMsg::GetGlyphDimensions(..) => "ApiMsg::GetGlyphDimensions",
             ApiMsg::GetGlyphIndices(..) => "ApiMsg::GetGlyphIndices",
             ApiMsg::CloneApi(..) => "ApiMsg::CloneApi",
             ApiMsg::CloneApiByClient(..) => "ApiMsg::CloneApiByClient",
             ApiMsg::AddDocument(..) => "ApiMsg::AddDocument",
-            ApiMsg::UpdateDocuments(..) => "ApiMsg::UpdateDocuments",
+            ApiMsg::UpdateDocument(..) => "ApiMsg::UpdateDocument",
             ApiMsg::DeleteDocument(..) => "ApiMsg::DeleteDocument",
             ApiMsg::ExternalEvent(..) => "ApiMsg::ExternalEvent",
             ApiMsg::ClearNamespace(..) => "ApiMsg::ClearNamespace",
             ApiMsg::MemoryPressure => "ApiMsg::MemoryPressure",
             ApiMsg::ReportMemory(..) => "ApiMsg::ReportMemory",
             ApiMsg::DebugCommand(..) => "ApiMsg::DebugCommand",
             ApiMsg::ShutDown => "ApiMsg::ShutDown",
             ApiMsg::WakeUp => "ApiMsg::WakeUp",
@@ -1046,24 +1041,25 @@ bitflags! {
         /// Show an overlay displaying overdraw amount.
         const SHOW_OVERDRAW         = 1 << 11;
         /// Display the contents of GPU cache.
         const GPU_CACHE_DBG         = 1 << 12;
         const SLOW_FRAME_INDICATOR  = 1 << 13;
         const TEXTURE_CACHE_DBG_CLEAR_EVICTED = 1 << 14;
         /// Show picture caching debug overlay
         const PICTURE_CACHING_DBG   = 1 << 15;
+        const TEXTURE_CACHE_DBG_DISABLE_SHRINK = 1 << 16;
         /// Highlight all primitives with colors based on kind.
-        const PRIMITIVE_DBG = 1 << 16;
+        const PRIMITIVE_DBG = 1 << 17;
         /// Draw a zoom widget showing part of the framebuffer zoomed in.
-        const ZOOM_DBG = 1 << 17;
+        const ZOOM_DBG = 1 << 18;
         /// Scale the debug renderer down for a smaller screen. This will disrupt
         /// any mapping between debug display items and page content, so shouldn't
         /// be used with overlays like the picture caching or primitive display.
-        const SMALL_SCREEN = 1 << 18;
+        const SMALL_SCREEN = 1 << 19;
     }
 }
 
 pub struct RenderApi {
     api_sender: MsgSender<ApiMsg>,
     payload_sender: PayloadSender,
     namespace_id: IdNamespace,
     next_id: Cell<ResourceId>,
@@ -1215,53 +1211,36 @@ impl RenderApi {
     }
 
     /// A helper method to send document messages.
     fn send_scene_msg(&self, document_id: DocumentId, msg: SceneMsg) {
         // This assertion fails on Servo use-cases, because it creates different
         // `RenderApi` instances for layout and compositor.
         //assert_eq!(document_id.0, self.namespace_id);
         self.api_sender
-            .send(ApiMsg::UpdateDocuments(vec![document_id], vec![TransactionMsg::scene_message(msg)]))
+            .send(ApiMsg::UpdateDocument(document_id, TransactionMsg::scene_message(msg)))
             .unwrap()
     }
 
     /// A helper method to send document messages.
     fn send_frame_msg(&self, document_id: DocumentId, msg: FrameMsg) {
         // This assertion fails on Servo use-cases, because it creates different
         // `RenderApi` instances for layout and compositor.
         //assert_eq!(document_id.0, self.namespace_id);
         self.api_sender
-            .send(ApiMsg::UpdateDocuments(vec![document_id], vec![TransactionMsg::frame_message(msg)]))
+            .send(ApiMsg::UpdateDocument(document_id, TransactionMsg::frame_message(msg)))
             .unwrap()
     }
 
     pub fn send_transaction(&self, document_id: DocumentId, transaction: Transaction) {
         let (msg, payloads) = transaction.finalize();
         for payload in payloads {
             self.payload_sender.send_payload(payload).unwrap();
         }
-        self.api_sender.send(ApiMsg::UpdateDocuments(vec![document_id], vec![msg])).unwrap();
-    }
-
-    pub fn send_transactions(&self, document_ids: Vec<DocumentId>, mut transactions: Vec<Transaction>) {
-        debug_assert!(document_ids.len() == transactions.len());
-        let length = document_ids.len();
-        let (msgs, mut document_payloads) = transactions.drain(..)
-            .fold((Vec::with_capacity(length), Vec::with_capacity(length)),
-                  |(mut msgs, mut document_payloads), transaction| {
-                    let (msg, payloads) = transaction.finalize();
-                    msgs.push(msg);
-                    document_payloads.push(payloads);
-                    (msgs, document_payloads)
-                  });
-        for payload in document_payloads.drain(..).flatten() {
-            self.payload_sender.send_payload(payload).unwrap();
-        }
-        self.api_sender.send(ApiMsg::UpdateDocuments(document_ids.clone(), msgs)).unwrap();
+        self.api_sender.send(ApiMsg::UpdateDocument(document_id, msg)).unwrap();
     }
 
     /// Does a hit test on display items in the specified document, at the given
     /// point. If a pipeline_id is specified, it is used to further restrict the
     /// hit results so that only items inside that pipeline are matched. If the
     /// HitTestFlags argument contains the FIND_ALL flag, then the vector of hit
     /// results will contain all display items that match, ordered from front
     /// to back.
index 6c38bbd50b0e6fe8a4cef96c88538c8cc70b9ba6..9898246b01231227304158ee3cf41d09cbd04c50
GIT binary patch
literal 48922
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
B!eamc
index 0e47fd3089dd6b35d25ba945f2af183522fa15a3..e70e13c6918ec4a4ee98c9fc7d7b73479821390a
GIT binary patch
literal 35970
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
--- a/gfx/wr/wrench/src/binary_frame_reader.rs
+++ b/gfx/wr/wrench/src/binary_frame_reader.rs
@@ -135,34 +135,31 @@ impl WrenchThing for BinaryFrameReader {
                     let msg = deserialize(&buffer).unwrap();
                     let mut store_message = true;
                     // In order to detect the first valid frame, we
                     // need to find:
                     // (a) SetRootPipeline
                     // (b) SetDisplayList
                     // (c) GenerateFrame that occurs *after* (a) and (b)
                     match msg {
-                        ApiMsg::UpdateDocuments(_, ref txns) => {
-                            for txn in txns {
-                                if txn.generate_frame {
-                                    // TODO: is this appropriate, or do we need a ternary value / something else?
-                                    found_frame_marker = true;
-                                }
-                                for doc_msg in &txn.scene_ops {
-                                    match *doc_msg {
-                                        SceneMsg::SetDisplayList { .. } => {
-                                            found_frame_marker = false;
-                                            found_display_list = true;
-                                        }
-                                        SceneMsg::SetRootPipeline(..) => {
-                                            found_frame_marker = false;
-                                            found_pipeline = true;
-                                        }
-                                        _ => {}
+                        ApiMsg::UpdateDocument(_, ref txn) => {
+                            if txn.generate_frame {
+                                found_frame_marker = true;
+                            }
+                            for doc_msg in &txn.scene_ops {
+                                match *doc_msg {
+                                    SceneMsg::SetDisplayList { .. } => {
+                                        found_frame_marker = false;
+                                        found_display_list = true;
                                     }
+                                    SceneMsg::SetRootPipeline(..) => {
+                                        found_frame_marker = false;
+                                        found_pipeline = true;
+                                    }
+                                    _ => {}
                                 }
                             }
                         }
                         // Wrench depends on the document always existing
                         ApiMsg::DeleteDocument(_) => {
                             store_message = false;
                         }
                         _ => {}
--- a/gfx/wr/wrench/src/json_frame_writer.rs
+++ b/gfx/wr/wrench/src/json_frame_writer.rs
@@ -266,56 +266,51 @@ impl JsonFrameWriter {
             return None;
         }
 
         data.path = Some(path.clone());
         // put it back
         self.images.insert(key, data);
         Some(path)
     }
-
-    fn update_document(&mut self, txn: &TransactionMsg) {
-        self.update_resources(&txn.resource_updates);
-        for doc_msg in &txn.scene_ops {
-            match *doc_msg {
-                SceneMsg::SetDisplayList {
-                    ref epoch,
-                    ref pipeline_id,
-                    ref background,
-                    ref viewport_size,
-                    ref list_descriptor,
-                    ..
-                } => {
-                    self.begin_write_display_list(
-                        epoch,
-                        pipeline_id,
-                        background,
-                        viewport_size,
-                        list_descriptor,
-                    );
-                }
-                _ => {}
-            }
-        }
-    }
 }
 
 impl fmt::Debug for JsonFrameWriter {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "JsonFrameWriter")
     }
 }
 
 impl webrender::ApiRecordingReceiver for JsonFrameWriter {
     fn write_msg(&mut self, _: u32, msg: &ApiMsg) {
         match *msg {
             ApiMsg::UpdateResources(ref updates) => self.update_resources(updates),
-            ApiMsg::UpdateDocuments(_, ref txns) => {
-                for txn in txns {
-                    self.update_document(txn)
+
+            ApiMsg::UpdateDocument(_, ref txn) => {
+                self.update_resources(&txn.resource_updates);
+                for doc_msg in &txn.scene_ops {
+                    match *doc_msg {
+                        SceneMsg::SetDisplayList {
+                            ref epoch,
+                            ref pipeline_id,
+                            ref background,
+                            ref viewport_size,
+                            ref list_descriptor,
+                            ..
+                        } => {
+                            self.begin_write_display_list(
+                                epoch,
+                                pipeline_id,
+                                background,
+                                viewport_size,
+                                list_descriptor,
+                            );
+                        }
+                        _ => {}
+                    }
                 }
             }
             ApiMsg::CloneApi(..) => {}
             _ => {}
         }
     }
 
     fn write_payload(&mut self, frame: u32, data: &[u8]) {
--- a/gfx/wr/wrench/src/ron_frame_writer.rs
+++ b/gfx/wr/wrench/src/ron_frame_writer.rs
@@ -144,56 +144,50 @@ impl RonFrameWriter {
                 },
                 ResourceUpdate::DeleteFont(_) => {}
                 ResourceUpdate::AddFontInstance(_) => {}
                 ResourceUpdate::DeleteFontInstance(_) => {}
                 ResourceUpdate::SetBlobImageVisibleArea(..) => {}
             }
         }
     }
-
-    fn update_document(&mut self, txn: &TransactionMsg) {
-        self.update_resources(&txn.resource_updates);
-        for doc_msg in &txn.scene_ops {
-            match *doc_msg {
-                SceneMsg::SetDisplayList {
-                    ref epoch,
-                    ref pipeline_id,
-                    ref background,
-                    ref viewport_size,
-                    ref list_descriptor,
-                    ..
-                } => {
-                    self.begin_write_display_list(
-                        epoch,
-                        pipeline_id,
-                        background,
-                        viewport_size,
-                        list_descriptor,
-                    );
-                }
-                _ => {}
-            }
-        }
-    }
 }
 
 impl fmt::Debug for RonFrameWriter {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "RonFrameWriter")
     }
 }
 
 impl webrender::ApiRecordingReceiver for RonFrameWriter {
     fn write_msg(&mut self, _: u32, msg: &ApiMsg) {
         match *msg {
             ApiMsg::UpdateResources(ref updates) => self.update_resources(updates),
-            ApiMsg::UpdateDocuments(_, ref txns) => {
-                for txn in txns {
-                    self.update_document(txn)
+            ApiMsg::UpdateDocument(_, ref txn) => {
+                self.update_resources(&txn.resource_updates);
+                for doc_msg in &txn.scene_ops {
+                    match *doc_msg {
+                        SceneMsg::SetDisplayList {
+                            ref epoch,
+                            ref pipeline_id,
+                            ref background,
+                            ref viewport_size,
+                            ref list_descriptor,
+                            ..
+                        } => {
+                            self.begin_write_display_list(
+                                epoch,
+                                pipeline_id,
+                                background,
+                                viewport_size,
+                                list_descriptor,
+                            );
+                        }
+                        _ => {}
+                    }
                 }
             }
             ApiMsg::CloneApi(..) => {}
             _ => {}
         }
     }
 
     fn write_payload(&mut self, frame: u32, data: &[u8]) {
--- a/gfx/wr/wrench/src/yaml_frame_writer.rs
+++ b/gfx/wr/wrench/src/yaml_frame_writer.rs
@@ -438,56 +438,16 @@ pub struct YamlFrameWriterReceiver {
 
 impl YamlFrameWriterReceiver {
     pub fn new(path: &Path) -> YamlFrameWriterReceiver {
         YamlFrameWriterReceiver {
             frame_writer: YamlFrameWriter::new(path),
             scene: Scene::new(),
         }
     }
-
-    fn update_document(&mut self, txn: &TransactionMsg) {
-        self.frame_writer.update_resources(&txn.resource_updates);
-        for doc_msg in &txn.scene_ops {
-            match *doc_msg {
-                SceneMsg::SetDisplayList {
-                    ref epoch,
-                    ref pipeline_id,
-                    ref background,
-                    ref viewport_size,
-                    ref list_descriptor,
-                    ..
-                } => {
-                    self.frame_writer.begin_write_display_list(
-                        &mut self.scene,
-                        epoch,
-                        pipeline_id,
-                        background,
-                        viewport_size,
-                        list_descriptor,
-                    );
-                }
-                SceneMsg::SetRootPipeline(ref pipeline_id) => {
-                    self.scene.set_root_pipeline_id(pipeline_id.clone());
-                }
-                SceneMsg::RemovePipeline(ref pipeline_id) => {
-                    self.scene.remove_pipeline(pipeline_id);
-                }
-                _ => {}
-            }
-        }
-        for doc_msg in &txn.frame_ops {
-            match *doc_msg {
-                FrameMsg::UpdateDynamicProperties(ref properties) => {
-                    self.scene.properties.set_properties(properties);
-                }
-                _ => {}
-            }
-        }
-    }
 }
 
 impl fmt::Debug for YamlFrameWriterReceiver {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "YamlFrameWriterReceiver")
     }
 }
 
@@ -1269,19 +1229,53 @@ impl YamlFrameWriter {
 }
 
 impl webrender::ApiRecordingReceiver for YamlFrameWriterReceiver {
     fn write_msg(&mut self, _: u32, msg: &ApiMsg) {
         match *msg {
             ApiMsg::UpdateResources(ref updates) => {
                 self.frame_writer.update_resources(updates);
             }
-            ApiMsg::UpdateDocuments(_, ref txns) => {
-                for txn in txns {
-                    self.update_document(txn);
+            ApiMsg::UpdateDocument(_, ref txn) => {
+                self.frame_writer.update_resources(&txn.resource_updates);
+                for doc_msg in &txn.scene_ops {
+                    match *doc_msg {
+                        SceneMsg::SetDisplayList {
+                            ref epoch,
+                            ref pipeline_id,
+                            ref background,
+                            ref viewport_size,
+                            ref list_descriptor,
+                            ..
+                        } => {
+                            self.frame_writer.begin_write_display_list(
+                                &mut self.scene,
+                                epoch,
+                                pipeline_id,
+                                background,
+                                viewport_size,
+                                list_descriptor,
+                            );
+                        }
+                        SceneMsg::SetRootPipeline(ref pipeline_id) => {
+                            self.scene.set_root_pipeline_id(pipeline_id.clone());
+                        }
+                        SceneMsg::RemovePipeline(ref pipeline_id) => {
+                            self.scene.remove_pipeline(pipeline_id);
+                        }
+                        _ => {}
+                    }
+                }
+                for doc_msg in &txn.frame_ops {
+                    match *doc_msg {
+                        FrameMsg::UpdateDynamicProperties(ref properties) => {
+                            self.scene.properties.set_properties(properties);
+                        }
+                        _ => {}
+                    }
                 }
             }
             _ => {}
         }
     }
 
     fn write_payload(&mut self, _frame: u32, data: &[u8]) {
         if self.frame_writer.dl_descriptor.is_some() {
--- a/modules/libpref/init/all.js
+++ b/modules/libpref/init/all.js
@@ -944,16 +944,17 @@ pref("gfx.compositor.glcontext.opaque", 
 pref("gfx.webrender.highlight-painted-layers", false);
 pref("gfx.webrender.blob-images", true);
 pref("gfx.webrender.blob.invalidation", true);
 pref("gfx.webrender.blob.paint-flashing", false);
 
 // WebRender debugging utilities.
 pref("gfx.webrender.debug.texture-cache", false);
 pref("gfx.webrender.debug.texture-cache.clear-evicted", true);
+pref("gfx.webrender.debug.texture-cache.disable-shrink", false);
 pref("gfx.webrender.debug.render-targets", false);
 pref("gfx.webrender.debug.gpu-cache", false);
 pref("gfx.webrender.debug.alpha-primitives", false);
 pref("gfx.webrender.debug.profiler", false);
 pref("gfx.webrender.debug.gpu-time-queries", false);
 pref("gfx.webrender.debug.gpu-sample-queries", false);
 pref("gfx.webrender.debug.disable-batching", false);
 pref("gfx.webrender.debug.epochs", false);