void CrossProcessCompositorParent::ShadowLayersUpdated( LayerTransactionParent* aLayerTree, const uint64_t& aTransactionId, const TargetConfig& aTargetConfig, bool aIsFirstPaint, bool aScheduleComposite, uint32_t aPaintSequenceNumber) { uint64_t id = aLayerTree->GetId(); MOZ_ASSERT(id != 0); const CompositorParent::LayerTreeState* state = CompositorParent::GetIndirectShadowTree(id); if (!state) { return; } MOZ_ASSERT(state->mParent); state->mParent->ScheduleRotationOnCompositorThread(aTargetConfig, aIsFirstPaint); Layer* shadowRoot = aLayerTree->GetRoot(); if (shadowRoot) { SetShadowProperties(shadowRoot); } UpdateIndirectTree(id, shadowRoot, aTargetConfig); state->mParent->NotifyShadowTreeTransaction(id, aIsFirstPaint, aScheduleComposite, aPaintSequenceNumber); aLayerTree->SetPendingTransactionId(aTransactionId); }
void CompositorParent::ShadowLayersUpdated(LayerTransactionParent* aLayerTree, const uint64_t& aTransactionId, const TargetConfig& aTargetConfig, bool aIsFirstPaint, bool aScheduleComposite, uint32_t aPaintSequenceNumber) { ScheduleRotationOnCompositorThread(aTargetConfig, aIsFirstPaint); // Instruct the LayerManager to update its render bounds now. Since all the orientation // change, dimension change would be done at the stage, update the size here is free of // race condition. mLayerManager->UpdateRenderBounds(aTargetConfig.clientBounds()); mLayerManager->SetRegionToClear(aTargetConfig.clearRegion()); mCompositionManager->Updated(aIsFirstPaint, aTargetConfig); Layer* root = aLayerTree->GetRoot(); mLayerManager->SetRoot(root); if (mApzcTreeManager) { AutoResolveRefLayers resolve(mCompositionManager); mApzcTreeManager->UpdatePanZoomControllerTree(this, root, aIsFirstPaint, mRootLayerTreeID, aPaintSequenceNumber); } MOZ_ASSERT(aTransactionId > mPendingTransaction); mPendingTransaction = aTransactionId; if (root) { SetShadowProperties(root); } if (aScheduleComposite) { ScheduleComposition(); if (mPaused) { DidComposite(); } // When testing we synchronously update the shadow tree with the animated // values to avoid race conditions when calling GetAnimationTransform etc. // (since the above SetShadowProperties will remove animation effects). // However, we only do this update when a composite operation is already // scheduled in order to better match the behavior under regular sampling // conditions. if (mIsTesting && root && mCurrentCompositeTask) { AutoResolveRefLayers resolve(mCompositionManager); bool requestNextFrame = mCompositionManager->TransformShadowTree(mTestTime); if (!requestNextFrame) { CancelCurrentCompositeTask(); // Pretend we composited in case someone is wating for this event. DidComposite(); } } } mLayerManager->NotifyShadowTreeTransaction(); }
// Go down shadow layer tree, setting properties to match their non-shadow // counterparts. static void SetShadowProperties(Layer* aLayer) { // FIXME: Bug 717688 -- Do these updates in ShadowLayersParent::RecvUpdate. ShadowLayer* shadow = aLayer->AsShadowLayer(); shadow->SetShadowTransform(aLayer->GetTransform()); shadow->SetShadowVisibleRegion(aLayer->GetVisibleRegion()); shadow->SetShadowClipRect(aLayer->GetClipRect()); for (Layer* child = aLayer->GetFirstChild(); child; child = child->GetNextSibling()) { SetShadowProperties(child); } }
void CompositorParent::ShadowLayersUpdated(bool isFirstPaint) { mIsFirstPaint = mIsFirstPaint || isFirstPaint; mLayersUpdated = true; const nsTArray<PLayersParent*>& shadowParents = ManagedPLayersParent(); NS_ABORT_IF_FALSE(shadowParents.Length() <= 1, "can only support at most 1 ShadowLayersParent"); if (shadowParents.Length()) { Layer* root = static_cast<ShadowLayersParent*>(shadowParents[0])->GetRoot(); mLayerManager->SetRoot(root); SetShadowProperties(root); } ScheduleComposition(); }
// Go down the composite layer tree, setting properties to match their // content-side counterparts. static void SetShadowProperties(Layer* aLayer) { // FIXME: Bug 717688 -- Do these updates in LayerTransactionParent::RecvUpdate. LayerComposite* layerComposite = aLayer->AsLayerComposite(); // Set the layerComposite's base transform to the layer's base transform. layerComposite->SetShadowTransform(aLayer->GetBaseTransform()); layerComposite->SetShadowTransformSetByAnimation(false); layerComposite->SetShadowVisibleRegion(aLayer->GetVisibleRegion()); layerComposite->SetShadowClipRect(aLayer->GetClipRect()); layerComposite->SetShadowOpacity(aLayer->GetOpacity()); for (Layer* child = aLayer->GetFirstChild(); child; child = child->GetNextSibling()) { SetShadowProperties(child); } }
// Do a breadth-first search to find the first layer in the tree that is // scrollable. Layer* CompositorParent::GetPrimaryScrollableLayer() { Layer* root = mLayerManager->GetRoot(); // FIXME: We're currently getting passed layers that are not part of our content, but // we are drawing them anyway. This is causing severe rendering corruption to our background // and checkerboarding. The real fix here is to assert that we don't have any useless layers // and ensure that layout isn't giving us any. This is being tracked in bug 728284. // For now just clip them to the empty rect so we don't draw them. Layer* discardLayer = root->GetFirstChild(); while (discardLayer) { if (!discardLayer->AsContainerLayer()) { discardLayer->IntersectClipRect(nsIntRect()); SetShadowProperties(discardLayer); } discardLayer = discardLayer->GetNextSibling(); } nsTArray<Layer*> queue; queue.AppendElement(root); while (queue.Length()) { ContainerLayer* containerLayer = queue[0]->AsContainerLayer(); queue.RemoveElementAt(0); if (!containerLayer) { continue; } const FrameMetrics& frameMetrics = containerLayer->GetFrameMetrics(); if (frameMetrics.IsScrollable()) { return containerLayer; } Layer* child = containerLayer->GetFirstChild(); while (child) { queue.AppendElement(child); child = child->GetNextSibling(); } } return root; }