author | Botond Ballo <botond@mozilla.com> |
Fri, 06 Nov 2015 22:13:40 -0500 | |
changeset 272143 | 374b5bb34c32bfd228a686ca5f073387415be047 |
parent 272142 | a8c552ad326f9659168f15c939e9e7749660377d |
child 272144 | 6128a9e0aab0ea7c7c15e0515758c5c052a67d2c |
push id | 67886 |
push user | bballo@mozilla.com |
push date | Wed, 11 Nov 2015 21:35:40 +0000 |
treeherder | mozilla-inbound@72ee46faee9e [default view] [failures only] |
perfherder | [talos] [build metrics] [platform microbench] (compared to previous push) |
reviewers | nical |
bugs | 1222661 |
milestone | 45.0a1 |
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
|
--- a/dom/events/IMEContentObserver.cpp +++ b/dom/events/IMEContentObserver.cpp @@ -802,19 +802,19 @@ IMEContentObserver::OnMouseButtonEvent(n charAtPt.refPoint += aMouseEvent->widget->WidgetToScreenOffset() - mWidget->WidgetToScreenOffset(); } IMENotification notification(NOTIFY_IME_OF_MOUSE_BUTTON_EVENT); notification.mMouseButtonEventData.mEventMessage = aMouseEvent->mMessage; notification.mMouseButtonEventData.mOffset = charAtPt.mReply.mOffset; notification.mMouseButtonEventData.mCursorPos.Set( - LayoutDeviceIntPoint::ToUntyped(charAtPt.refPoint)); + charAtPt.refPoint.ToUnknownPoint()); notification.mMouseButtonEventData.mCharRect.Set( - LayoutDevicePixel::ToUntyped(charAtPt.mReply.mRect)); + charAtPt.mReply.mRect.ToUnknownRect()); notification.mMouseButtonEventData.mButton = aMouseEvent->button; notification.mMouseButtonEventData.mButtons = aMouseEvent->buttons; notification.mMouseButtonEventData.mModifiers = aMouseEvent->modifiers; nsresult rv = IMEStateManager::NotifyIME(notification, mWidget); if (NS_WARN_IF(NS_FAILED(rv))) { return false; }
--- a/dom/events/WheelHandlingHelper.cpp +++ b/dom/events/WheelHandlingHelper.cpp @@ -333,18 +333,18 @@ WheelTransaction::SetTimeout() NS_WARN_IF_FALSE(NS_SUCCEEDED(rv), "nsITimer::InitWithFuncCallback failed"); } /* static */ nsIntPoint WheelTransaction::GetScreenPoint(WidgetGUIEvent* aEvent) { NS_ASSERTION(aEvent, "aEvent is null"); NS_ASSERTION(aEvent->widget, "aEvent-widget is null"); - return LayoutDeviceIntPoint::ToUntyped(aEvent->refPoint + - aEvent->widget->WidgetToScreenOffset()); + return (aEvent->refPoint + aEvent->widget->WidgetToScreenOffset()) + .ToUnknownPoint(); } /* static */ uint32_t WheelTransaction::GetTimeoutTime() { return Preferences::GetUint("mousewheel.transaction.timeout", 1500); }
--- a/gfx/layers/LayerTreeInvalidation.cpp +++ b/gfx/layers/LayerTreeInvalidation.cpp @@ -219,17 +219,17 @@ struct LayerPropertiesBase : public Laye mAncestorMaskLayers[i]->ComputeChange(aCallback, aGeometryChanged), mTransform); } if (mUseClipRect && otherClip) { if (!mClipRect.IsEqualInterior(*otherClip)) { aGeometryChanged = true; nsIntRegion tmp; - tmp.Xor(ParentLayerIntRect::ToUntyped(mClipRect), ParentLayerIntRect::ToUntyped(*otherClip)); + tmp.Xor(mClipRect.ToUnknownRect(), otherClip->ToUnknownRect()); AddRegion(result, tmp); } } mLayer->ClearInvalidRect(); return result; }
--- a/gfx/layers/Layers.cpp +++ b/gfx/layers/Layers.cpp @@ -1036,17 +1036,17 @@ Layer::GetVisibleRegionRelativeToRootLay // Translate the accumulated visible region of |this| by the offset of // |layer|. aResult.MoveBy(currentLayerOffset.x, currentLayerOffset.y); // If the parent layer clips its lower layers, clip the visible region // we're accumulating. if (layer->GetEffectiveClipRect()) { - aResult.AndWith(ParentLayerIntRect::ToUntyped(*layer->GetEffectiveClipRect())); + aResult.AndWith(layer->GetEffectiveClipRect()->ToUnknownRect()); } // Now we need to walk across the list of siblings for this parent layer, // checking to see if any of these layer trees obscure |this|. If so, // remove these areas from the visible region as well. This will pick up // chrome overlays like a tab modal prompt. Layer* sibling; for (sibling = layer->GetNextSibling(); sibling; @@ -1062,17 +1062,17 @@ Layer::GetVisibleRegionRelativeToRootLay IntPoint siblingOffset = RoundedToInt(siblingMatrix.GetTranslation()); nsIntRegion siblingVisibleRegion(sibling->GetEffectiveVisibleRegion()); // Translate the siblings region to |layer|'s origin. siblingVisibleRegion.MoveBy(-siblingOffset.x, -siblingOffset.y); // Apply the sibling's clip. // Layer clip rects are not affected by the layer's transform. Maybe<ParentLayerIntRect> clipRect = sibling->GetEffectiveClipRect(); if (clipRect) { - siblingVisibleRegion.AndWith(ParentLayerIntRect::ToUntyped(*clipRect)); + siblingVisibleRegion.AndWith(clipRect->ToUnknownRect()); } // Subtract the sibling visible region from the visible region of |this|. aResult.SubOut(siblingVisibleRegion); } // Keep track of the total offset for aLayerOffset. We use this in plugin // positioning code. offset += currentLayerOffset;
--- a/gfx/layers/apz/src/APZCTreeManager.cpp +++ b/gfx/layers/apz/src/APZCTreeManager.cpp @@ -301,17 +301,17 @@ APZCTreeManager::AttachNodeToTree(HitTes } } static EventRegions GetEventRegions(const LayerMetricsWrapper& aLayer) { if (aLayer.IsScrollInfoLayer()) { ParentLayerIntRect compositionBounds(RoundedToInt(aLayer.Metrics().GetCompositionBounds())); - nsIntRegion hitRegion(ParentLayerIntRect::ToUntyped(compositionBounds)); + nsIntRegion hitRegion(compositionBounds.ToUnknownRect()); EventRegions eventRegions(hitRegion); eventRegions.mDispatchToContentHitRegion = eventRegions.mHitRegion; return eventRegions; } return aLayer.GetEventRegions(); } already_AddRefed<HitTestingTreeNode>
--- a/gfx/layers/apz/test/gtest/TestAsyncPanZoomController.cpp +++ b/gfx/layers/apz/test/gtest/TestAsyncPanZoomController.cpp @@ -1923,17 +1923,17 @@ protected: metrics.SetAllowVerticalScrollWithWheel(); aLayer->SetFrameMetrics(metrics); aLayer->SetClipRect(Some(ViewAs<ParentLayerPixel>(layerBound))); if (!aScrollableRect.IsEqualEdges(CSSRect(-1, -1, -1, -1))) { // The purpose of this is to roughly mimic what layout would do in the // case of a scrollable frame with the event regions and clip. This lets // us exercise the hit-testing code in APZCTreeManager EventRegions er = aLayer->GetEventRegions(); - IntRect scrollRect = LayerIntRect::ToUntyped(RoundedToInt(aScrollableRect * metrics.LayersPixelsPerCSSPixel())); + IntRect scrollRect = RoundedToInt(aScrollableRect * metrics.LayersPixelsPerCSSPixel()).ToUnknownRect(); er.mHitRegion = nsIntRegion(IntRect(layerBound.TopLeft(), scrollRect.Size())); aLayer->SetEventRegions(er); } } void SetScrollHandoff(Layer* aChild, Layer* aParent) { FrameMetrics metrics = aChild->GetFrameMetrics(0); metrics.SetScrollParentId(aParent->GetFrameMetrics(0).GetScrollId());
--- a/gfx/layers/basic/BasicContainerLayer.cpp +++ b/gfx/layers/basic/BasicContainerLayer.cpp @@ -120,17 +120,17 @@ BasicContainerLayer::ChildrenPartitionVi if (!l->GetEffectiveTransform().CanDraw2D(&childTransform) || ThebesMatrix(childTransform).HasNonIntegerTranslation() || l->GetEffectiveOpacity() != 1.0) return false; nsIntRegion childRegion = l->GetEffectiveVisibleRegion(); childRegion.MoveBy(int32_t(childTransform._31), int32_t(childTransform._32)); childRegion.And(childRegion, rect); if (l->GetClipRect()) { - childRegion.And(childRegion, ParentLayerIntRect::ToUntyped(*l->GetClipRect()) + offset); + childRegion.And(childRegion, l->GetClipRect()->ToUnknownRect() + offset); } nsIntRegion intersection; intersection.And(covered, childRegion); if (!intersection.IsEmpty()) return false; covered.Or(covered, childRegion); }
--- a/gfx/layers/basic/BasicLayerManager.cpp +++ b/gfx/layers/basic/BasicLayerManager.cpp @@ -396,17 +396,17 @@ MarkLayersHidden(Layer* aLayer, const In // only if it's opaque. if (aLayer->GetOpacity() != 1.0f) { newFlags &= ~ALLOW_OPAQUE; } { const Maybe<ParentLayerIntRect>& clipRect = aLayer->GetEffectiveClipRect(); if (clipRect) { - IntRect cr = ParentLayerIntRect::ToUntyped(*clipRect); + IntRect cr = clipRect->ToUnknownRect(); // clipRect is in the container's coordinate system. Get it into the // global coordinate system. if (aLayer->GetParent()) { Matrix tr; if (aLayer->GetParent()->GetEffectiveTransform().CanDraw2D(&tr)) { // Clip rect is applied after aLayer's transform, i.e., in the coordinate // system of aLayer's parent. TransformIntRect(cr, tr, ToInsideIntRect); @@ -476,17 +476,17 @@ ApplyDoubleBuffering(Layer* aLayer, cons if (data->IsHidden()) return; IntRect newVisibleRect(aVisibleRect); { const Maybe<ParentLayerIntRect>& clipRect = aLayer->GetEffectiveClipRect(); if (clipRect) { - IntRect cr = ParentLayerIntRect::ToUntyped(*clipRect); + IntRect cr = clipRect->ToUnknownRect(); // clipRect is in the container's coordinate system. Get it into the // global coordinate system. if (aLayer->GetParent()) { Matrix tr; if (aLayer->GetParent()->GetEffectiveTransform().CanDraw2D(&tr)) { NS_ASSERTION(!ThebesMatrix(tr).HasNonIntegerTranslation(), "Parent can only have an integer translation"); cr += nsIntPoint(int32_t(tr._31), int32_t(tr._32));
--- a/gfx/layers/client/ClientTiledPaintedLayer.cpp +++ b/gfx/layers/client/ClientTiledPaintedLayer.cpp @@ -301,30 +301,30 @@ ClientTiledPaintedLayer::RenderHighPreci if (UseProgressiveDraw() && mContentClient->GetTiledBuffer()->GetFrameResolution() == mPaintData.mResolution) { // Store the old valid region, then clear it before painting. // We clip the old valid region to the visible region, as it only gets // used to decide stale content (currently valid and previously visible) nsIntRegion oldValidRegion = mContentClient->GetTiledBuffer()->GetValidRegion(); oldValidRegion.And(oldValidRegion, aVisibleRegion); if (!mPaintData.mCriticalDisplayPort.IsEmpty()) { - oldValidRegion.And(oldValidRegion, LayerIntRect::ToUntyped(mPaintData.mCriticalDisplayPort)); + oldValidRegion.And(oldValidRegion, mPaintData.mCriticalDisplayPort.ToUnknownRect()); } TILING_LOG("TILING %p: Progressive update with old valid region %s\n", this, Stringify(oldValidRegion).c_str()); return mContentClient->GetTiledBuffer()->ProgressiveUpdate(mValidRegion, aInvalidRegion, oldValidRegion, &mPaintData, aCallback, aCallbackData); } // Otherwise do a non-progressive paint mValidRegion = aVisibleRegion; if (!mPaintData.mCriticalDisplayPort.IsEmpty()) { - mValidRegion.And(mValidRegion, LayerIntRect::ToUntyped(mPaintData.mCriticalDisplayPort)); + mValidRegion.And(mValidRegion, mPaintData.mCriticalDisplayPort.ToUnknownRect()); } TILING_LOG("TILING %p: Non-progressive paint invalid region %s\n", this, Stringify(aInvalidRegion).c_str()); TILING_LOG("TILING %p: Non-progressive paint new valid region %s\n", this, Stringify(mValidRegion).c_str()); mContentClient->GetTiledBuffer()->SetFrameResolution(mPaintData.mResolution); mContentClient->GetTiledBuffer()->PaintThebes(mValidRegion, aInvalidRegion, aInvalidRegion, aCallback, aCallbackData); @@ -335,17 +335,17 @@ ClientTiledPaintedLayer::RenderHighPreci bool ClientTiledPaintedLayer::RenderLowPrecision(nsIntRegion& aInvalidRegion, const nsIntRegion& aVisibleRegion, LayerManager::DrawPaintedLayerCallback aCallback, void* aCallbackData) { // Render the low precision buffer, if the visible region is larger than the // critical display port. - if (!nsIntRegion(LayerIntRect::ToUntyped(mPaintData.mCriticalDisplayPort)).Contains(aVisibleRegion)) { + if (!nsIntRegion(mPaintData.mCriticalDisplayPort.ToUnknownRect()).Contains(aVisibleRegion)) { nsIntRegion oldValidRegion = mContentClient->GetLowPrecisionTiledBuffer()->GetValidRegion(); oldValidRegion.And(oldValidRegion, aVisibleRegion); bool updatedBuffer = false; // If the frame resolution or format have changed, invalidate the buffer if (mContentClient->GetLowPrecisionTiledBuffer()->GetFrameResolution() != mPaintData.mResolution || mContentClient->GetLowPrecisionTiledBuffer()->HasFormatChanged()) { @@ -482,25 +482,25 @@ ClientTiledPaintedLayer::RenderLayer() return; } // Make sure that tiles that fall outside of the visible region or outside of the // critical displayport are discarded on the first update. Also make sure that we // only draw stuff inside the critical displayport on the first update. mValidRegion.And(mValidRegion, neededRegion); if (!mPaintData.mCriticalDisplayPort.IsEmpty()) { - mValidRegion.And(mValidRegion, LayerIntRect::ToUntyped(mPaintData.mCriticalDisplayPort)); - invalidRegion.And(invalidRegion, LayerIntRect::ToUntyped(mPaintData.mCriticalDisplayPort)); + mValidRegion.And(mValidRegion, mPaintData.mCriticalDisplayPort.ToUnknownRect()); + invalidRegion.And(invalidRegion, mPaintData.mCriticalDisplayPort.ToUnknownRect()); } TILING_LOG("TILING %p: First-transaction valid region %s\n", this, Stringify(mValidRegion).c_str()); TILING_LOG("TILING %p: First-transaction invalid region %s\n", this, Stringify(invalidRegion).c_str()); } else { if (!mPaintData.mCriticalDisplayPort.IsEmpty()) { - invalidRegion.And(invalidRegion, LayerIntRect::ToUntyped(mPaintData.mCriticalDisplayPort)); + invalidRegion.And(invalidRegion, mPaintData.mCriticalDisplayPort.ToUnknownRect()); } TILING_LOG("TILING %p: Repeat-transaction invalid region %s\n", this, Stringify(invalidRegion).c_str()); } nsIntRegion lowPrecisionInvalidRegion; if (mContentClient->GetLowPrecisionTiledBuffer()) { // Calculate the invalid region for the low precision buffer. Make sure // to remove the valid high-precision area so we don't double-paint it.
--- a/gfx/layers/client/TiledContentClient.cpp +++ b/gfx/layers/client/TiledContentClient.cpp @@ -1503,23 +1503,23 @@ ClientMultiTiledLayerBuffer::ComputeProg // single transaction. This is to avoid rendering glitches on animated // page content, and when layers change size/shape. // On Fennec uploads are more expensive because we're not using gralloc, so // we use a coherent update rect that is intersected with the screen at the // time of issuing the draw command. This will paint faster but also potentially // make the progressive paint more visible to the user while scrolling. // On B2G uploads are cheaper and we value coherency more, especially outside // the browser, so we always use the entire user-visible area. - IntRect coherentUpdateRect(LayerIntRect::ToUntyped(RoundedOut( + IntRect coherentUpdateRect(RoundedOut( #ifdef MOZ_WIDGET_ANDROID transformedCompositionBounds->Intersect(aPaintData->mCompositionBounds) #else *transformedCompositionBounds #endif - ))); + ).ToUnknownRect()); TILING_LOG("TILING %p: Progressive update final coherency rect %s\n", mPaintedLayer, Stringify(coherentUpdateRect).c_str()); aRegionToPaint.And(aInvalidRegion, coherentUpdateRect); aRegionToPaint.Or(aRegionToPaint, staleRegion); bool drawingStale = !aRegionToPaint.IsEmpty(); if (!drawingStale) { aRegionToPaint = aInvalidRegion;
--- a/gfx/layers/composite/ContainerLayerComposite.cpp +++ b/gfx/layers/composite/ContainerLayerComposite.cpp @@ -404,17 +404,17 @@ ContainerPrepare(ContainerT* aContainer, } if (!surface) { // If we don't need a copy we can render to the intermediate now to avoid // unecessary render target switching. This brings a big perf boost on mobile gpus. surface = CreateOrRecycleTarget(aContainer, aManager); MOZ_PERFORMANCE_WARNING("gfx", "[%p] Container layer requires intermediate surface rendering\n", aContainer); - RenderIntermediate(aContainer, aManager, RenderTargetPixel::ToUntyped(aClipRect), surface); + RenderIntermediate(aContainer, aManager, aClipRect.ToUnknownRect(), surface); aContainer->SetChildrenChanged(false); } aContainer->mPrepared->mTmpTarget = surface; } else { MOZ_PERFORMANCE_WARNING("gfx", "[%p] Container layer requires intermediate surface copy\n", aContainer); aContainer->mPrepared->mNeedsSurfaceCopy = true; aContainer->mLastIntermediateSurface = nullptr; @@ -556,17 +556,17 @@ RenderLayers(ContainerT* aContainer, gfx::IntRect clearRect = layerToRender->GetClearRect(); if (!clearRect.IsEmpty()) { // Clear layer's visible rect on FrameBuffer with transparent pixels gfx::Rect fbRect(clearRect.x, clearRect.y, clearRect.width, clearRect.height); compositor->ClearRect(fbRect); layerToRender->SetClearRect(gfx::IntRect(0, 0, 0, 0)); } } else { - layerToRender->RenderLayer(RenderTargetPixel::ToUntyped(clipRect)); + layerToRender->RenderLayer(clipRect.ToUnknownRect()); } if (gfxPrefs::UniformityInfo()) { PrintUniformityInfo(layer); } if (gfxPrefs::DrawLayerInfo()) { DrawLayerInfo(clipRect, aManager, layer);
--- a/gfx/layers/composite/LayerManagerComposite.cpp +++ b/gfx/layers/composite/LayerManagerComposite.cpp @@ -242,17 +242,17 @@ LayerManagerComposite::ApplyOcclusionCul !aLayer->HasMaskLayers() && aLayer->IsOpaqueForVisibility()) { if (aLayer->GetContentFlags() & Layer::CONTENT_OPAQUE) { localOpaque.Or(localOpaque, composite->GetFullyRenderedRegion()); } localOpaque.MoveBy(transform2d._31, transform2d._32); const Maybe<ParentLayerIntRect>& clip = aLayer->GetEffectiveClipRect(); if (clip) { - localOpaque.And(localOpaque, ParentLayerIntRect::ToUntyped(*clip)); + localOpaque.And(localOpaque, clip->ToUnknownRect()); } aOpaqueRegion.Or(aOpaqueRegion, localOpaque); } } void LayerManagerComposite::EndTransaction(const TimeStamp& aTimeStamp, EndTransactionFlags aFlags) @@ -788,29 +788,29 @@ LayerManagerComposite::Render(const nsIn if (haveLayerEffects) { previousTarget = PushGroupForLayerEffects(); } else { mTwoPassTmpTarget = nullptr; } // Render our layers. RootLayer()->Prepare(ViewAs<RenderTargetPixel>(clipRect, PixelCastJustification::RenderTargetIsParentLayerForRoot)); - RootLayer()->RenderLayer(ParentLayerIntRect::ToUntyped(clipRect)); + RootLayer()->RenderLayer(clipRect.ToUnknownRect()); if (!mRegionToClear.IsEmpty()) { nsIntRegionRectIterator iter(mRegionToClear); const IntRect *r; while ((r = iter.Next())) { mCompositor->ClearRect(Rect(r->x, r->y, r->width, r->height)); } } if (mTwoPassTmpTarget) { MOZ_ASSERT(haveLayerEffects); - PopGroupForLayerEffects(previousTarget, ParentLayerIntRect::ToUntyped(clipRect), + PopGroupForLayerEffects(previousTarget, clipRect.ToUnknownRect(), grayscaleVal, invertVal, contrastVal); } // Allow widget to render a custom foreground. mCompositor->GetWidget()->DrawWindowOverlay(this, IntRect(actualBounds.x, actualBounds.y, actualBounds.width, actualBounds.height));
--- a/layout/base/FrameLayerBuilder.cpp +++ b/layout/base/FrameLayerBuilder.cpp @@ -3956,17 +3956,17 @@ ContainerState::ProcessDisplayItems(nsDi bool prerenderedTransform = itemType == nsDisplayItem::TYPE_TRANSFORM && static_cast<nsDisplayTransform*>(item)->ShouldPrerender(mBuilder); ParentLayerIntRect clipRect; const DisplayItemClip& itemClip = item->GetClip(); if (itemClip.HasClip()) { itemContent.IntersectRect(itemContent, itemClip.GetClipRect()); clipRect = ViewAs<ParentLayerPixel>(ScaleToNearestPixels(itemClip.GetClipRect())); if (!prerenderedTransform) { - itemDrawRect.IntersectRect(itemDrawRect, ParentLayerIntRect::ToUntyped(clipRect)); + itemDrawRect.IntersectRect(itemDrawRect, clipRect.ToUnknownRect()); } clipRect.MoveBy(ViewAs<ParentLayerPixel>(mParameters.mOffset)); } #ifdef DEBUG nsRect bounds = itemContent; bool dummy; if (itemType == nsDisplayItem::TYPE_LAYER_EVENT_REGIONS) { bounds = item->GetBounds(mBuilder, &dummy); @@ -4043,17 +4043,17 @@ ContainerState::ProcessDisplayItems(nsDi nscolor* uniformColorPtr = !mayDrawOutOfOrder ? &uniformColor : nullptr; nsIntRect clipRectUntyped; const DisplayItemClip& layerClip = shouldFixToViewport ? fixedToViewportClip : itemClip; ParentLayerIntRect layerClipRect; nsIntRect* clipPtr = nullptr; if (layerClip.HasClip()) { layerClipRect = ViewAs<ParentLayerPixel>( ScaleToNearestPixels(layerClip.GetClipRect()) + mParameters.mOffset); - clipRectUntyped = ParentLayerIntRect::ToUntyped(layerClipRect); + clipRectUntyped = layerClipRect.ToUnknownRect(); clipPtr = &clipRectUntyped; } if (animatedGeometryRoot == item->Frame() && animatedGeometryRoot != mBuilder->RootReferenceFrame()) { // This is the case for scrollbar thumbs, for example. In that case the // clip we care about is the overflow:hidden clip on the scrollbar. const nsIFrame* clipAnimatedGeometryRoot = mPaintedLayerDataTree.GetParentAnimatedGeometryRoot(animatedGeometryRoot); @@ -4883,17 +4883,17 @@ ContainerState::PostprocessRetainedLayer SetupScrollingMetadata(e); if (hideAll) { e->mVisibleRegion.SetEmpty(); } else if (!e->mLayer->IsScrollbarContainer()) { const Maybe<ParentLayerIntRect>& clipRect = GetStationaryClipInContainer(e->mLayer); if (clipRect && opaqueRegionForContainer >= 0 && - opaqueRegions[opaqueRegionForContainer].mOpaqueRegion.Contains(ParentLayerIntRect::ToUntyped(*clipRect))) { + opaqueRegions[opaqueRegionForContainer].mOpaqueRegion.Contains(clipRect->ToUnknownRect())) { e->mVisibleRegion.SetEmpty(); } else if (data) { e->mVisibleRegion.Sub(e->mVisibleRegion, data->mOpaqueRegion); } } SetOuterVisibleRegionForLayer(e->mLayer, e->mVisibleRegion, @@ -4924,17 +4924,17 @@ ContainerState::PostprocessRetainedLayer data = opaqueRegions.AppendElement(); data->mAnimatedGeometryRoot = animatedGeometryRootToCover; data->mFixedPosFrameForLayerData = e->mFixedPosFrameForLayerData; } nsIntRegion clippedOpaque = e->mOpaqueRegion; Maybe<ParentLayerIntRect> clipRect = e->mLayer->GetCombinedClipRect(); if (clipRect) { - clippedOpaque.AndWith(ParentLayerIntRect::ToUntyped(*clipRect)); + clippedOpaque.AndWith(clipRect->ToUnknownRect()); } if (e->mLayer->GetIsFixedPosition() && !e->mLayer->IsClipFixed()) { // The clip can move asynchronously, so we can't rely on opaque parts // staying in the same place. clippedOpaque.SetEmpty(); } data->mOpaqueRegion.Or(data->mOpaqueRegion, clippedOpaque); if (e->mHideAllLayersBelow) {
--- a/layout/base/Units.h +++ b/layout/base/Units.h @@ -234,28 +234,20 @@ struct CSSPixel { * 1) the "full zoom" (see nsPresContext::SetFullZoom) * 2) the "widget scale" (see nsIWidget::GetDefaultScale) */ struct LayoutDevicePixel { static LayoutDeviceIntPoint FromUntyped(const nsIntPoint& aPoint) { return LayoutDeviceIntPoint(aPoint.x, aPoint.y); } - static nsIntPoint ToUntyped(const LayoutDeviceIntPoint& aPoint) { - return nsIntPoint(aPoint.x, aPoint.y); - } - static LayoutDeviceIntRect FromUntyped(const nsIntRect& aRect) { return LayoutDeviceIntRect(aRect.x, aRect.y, aRect.width, aRect.height); } - static nsIntRect ToUntyped(const LayoutDeviceIntRect& aRect) { - return nsIntRect(aRect.x, aRect.y, aRect.width, aRect.height); - } - static LayoutDeviceRect FromAppUnits(const nsRect& aRect, nscoord aAppUnitsPerDevPixel) { return LayoutDeviceRect(NSAppUnitsToFloatPixels(aRect.x, float(aAppUnitsPerDevPixel)), NSAppUnitsToFloatPixels(aRect.y, float(aAppUnitsPerDevPixel)), NSAppUnitsToFloatPixels(aRect.width, float(aAppUnitsPerDevPixel)), NSAppUnitsToFloatPixels(aRect.height, float(aAppUnitsPerDevPixel))); } static LayoutDevicePoint FromAppUnits(const nsPoint& aPoint, nscoord aAppUnitsPerDevPixel) { @@ -317,24 +309,16 @@ struct LayoutDevicePixel { * These also are generally referred to as "device pixels" in layout code. * Conversion between CSS pixels and LayerPixels is affected by: * 1) the "display resolution" (see nsIPresShell::SetResolution) * 2) the "full zoom" (see nsPresContext::SetFullZoom) * 3) the "widget scale" (see nsIWidget::GetDefaultScale) * 4) rasterizing at a different scale in the presence of some CSS transforms */ struct LayerPixel { - static nsIntRect ToUntyped(const LayerIntRect& aRect) { - return nsIntRect(aRect.x, aRect.y, aRect.width, aRect.height); - } - - static nsIntPoint ToUntyped(const LayerIntPoint& aPoint) { - return nsIntPoint(aPoint.x, aPoint.y); - } - static gfx::IntRect ToUnknown(const LayerIntRect& aRect) { return gfx::IntRect(aRect.x, aRect.y, aRect.width, aRect.height); } static gfx::Rect ToUnknown(const LayerRect& aRect) { return gfx::Rect(aRect.x, aRect.y, aRect.width, aRect.height); } @@ -350,24 +334,16 @@ struct LayerPixel { /* * Layers are always composited to a render target. This unit * represents one pixel in the render target. Note that for the * root render target RenderTargetPixel == ScreenPixel. Also * any ContainerLayer providing an intermediate surface will * have RenderTargetPixel == LayerPixel. */ struct RenderTargetPixel { - static nsIntPoint ToUntyped(const RenderTargetIntPoint& aPoint) { - return nsIntPoint(aPoint.x, aPoint.y); - } - - static nsIntRect ToUntyped(const RenderTargetIntRect& aRect) { - return nsIntRect(aRect.x, aRect.y, aRect.width, aRect.height); - } - static gfx::IntRect ToUnknown(const RenderTargetIntRect& aRect) { return gfx::IntRect(aRect.x, aRect.y, aRect.width, aRect.height); } static gfx::Rect ToUnknown(const RenderTargetRect& aRect) { return gfx::Rect(aRect.x, aRect.y, aRect.width, aRect.height); } @@ -385,20 +361,16 @@ struct RenderTargetPixel { * On non-OMTC platforms this should be equivalent to LayerPixel units. * On OMTC platforms these may diverge from LayerPixel units temporarily, * while an asynchronous zoom is happening, but should eventually converge * back to LayerPixel units. Some variables (such as those representing * chrome UI element sizes) that are not subject to content zoom should * generally be represented in ScreenPixel units. */ struct ScreenPixel { - static nsIntSize ToUntyped(const ScreenIntSize& aSize) { - return nsIntSize(aSize.width, aSize.height); - } - static ScreenIntPoint FromUntyped(const nsIntPoint& aPoint) { return ScreenIntPoint(aPoint.x, aPoint.y); } }; /* The layer coordinates of the parent frame. * This can be arrived at in three ways: * - Start with the CSS coordinates of the parent frame, multiply by the @@ -407,19 +379,16 @@ struct ScreenPixel { * scale, the cumulative resolution of the current frame, and the scales * from the CSS and async transforms of the current frame. * - Start with global screen coordinates and unapply all CSS and async * transforms from the root down to and including the parent. * It's helpful to look at https://wiki.mozilla.org/Platform/GFX/APZ#Coordinate_systems * to get a picture of how the various coordinate systems relate to each other. */ struct ParentLayerPixel { - static nsIntRect ToUntyped(const ParentLayerIntRect& aRect) { - return nsIntRect(aRect.x, aRect.y, aRect.width, aRect.height); - } }; // Operators to apply ScaleFactors directly to Coords, Points, Rects, Sizes and Margins template<class src, class dst> gfx::CoordTyped<dst> operator*(const gfx::CoordTyped<src>& aCoord, const gfx::ScaleFactor<src, dst>& aScale) { return gfx::CoordTyped<dst>(aCoord.value * aScale.scale); }
--- a/layout/base/nsDisplayList.cpp +++ b/layout/base/nsDisplayList.cpp @@ -1185,19 +1185,19 @@ nsDisplayListBuilder::AdjustWindowDraggi LayoutDevicePixel::FromAppUnits(borderBox, aFrame->PresContext()->AppUnitsPerDevPixel()); LayoutDeviceRect transformedDevPixelBorderBox = TransformTo<LayoutDevicePixel>(referenceFrameToRootReferenceFrame, devPixelBorderBox); transformedDevPixelBorderBox.Round(); LayoutDeviceIntRect transformedDevPixelBorderBoxInt; if (transformedDevPixelBorderBox.ToIntRect(&transformedDevPixelBorderBoxInt)) { const nsStyleUserInterface* styleUI = aFrame->StyleUserInterface(); if (styleUI->mWindowDragging == NS_STYLE_WINDOW_DRAGGING_DRAG) { - mWindowDraggingRegion.OrWith(LayoutDevicePixel::ToUntyped(transformedDevPixelBorderBoxInt)); + mWindowDraggingRegion.OrWith(transformedDevPixelBorderBoxInt.ToUnknownRect()); } else { - mWindowDraggingRegion.SubOut(LayoutDevicePixel::ToUntyped(transformedDevPixelBorderBoxInt)); + mWindowDraggingRegion.SubOut(transformedDevPixelBorderBoxInt.ToUnknownRect()); } } } } const uint32_t gWillChangeAreaMultiplier = 3; static uint32_t GetWillChangeCost(nsIFrame* aFrame, const nsSize& aSize) {
--- a/layout/xul/nsResizerFrame.cpp +++ b/layout/xul/nsResizerFrame.cpp @@ -233,17 +233,17 @@ nsResizerFrame::HandleEvent(nsPresContex rect.IntersectRect(rect, LayoutDevicePixel::FromUntyped(screenRectPixels)); } if (contentToResize) { // convert the rectangle into css pixels. When changing the size in a // direction, don't allow the new size to be less that the resizer's // size. This ensures that content isn't resized too small as to make // the resizer invisible. - nsRect appUnitsRect = ToAppUnits(LayoutDevicePixel::ToUntyped(rect), aPresContext->AppUnitsPerDevPixel()); + nsRect appUnitsRect = ToAppUnits(rect.ToUnknownRect(), aPresContext->AppUnitsPerDevPixel()); if (appUnitsRect.width < mRect.width && mouseMove.x) appUnitsRect.width = mRect.width; if (appUnitsRect.height < mRect.height && mouseMove.y) appUnitsRect.height = mRect.height; nsIntRect cssRect = appUnitsRect.ToInsidePixels(nsPresContext::AppUnitsPerCSSPixel()); LayoutDeviceIntRect oldRect; nsWeakFrame weakFrame(menuPopupFrame);
--- a/widget/PuppetWidget.cpp +++ b/widget/PuppetWidget.cpp @@ -1150,17 +1150,17 @@ PuppetWidget::SetNativeData(uint32_t aDa nsIntPoint PuppetWidget::GetChromeDimensions() { if (!GetOwningTabChild()) { NS_WARNING("PuppetWidget without Tab does not have chrome information."); return nsIntPoint(); } - return LayoutDeviceIntPoint::ToUntyped(GetOwningTabChild()->GetChromeDisplacement()); + return GetOwningTabChild()->GetChromeDisplacement().ToUnknownPoint(); } nsIntPoint PuppetWidget::GetWindowPosition() { if (!GetOwningTabChild()) { return nsIntPoint(); }
--- a/widget/cocoa/TextInputHandler.mm +++ b/widget/cocoa/TextInputHandler.mm @@ -3311,17 +3311,17 @@ IMEInputHandler::FirstRectForCharacterRa nsIWidget* rootWidget = mWidget->GetTopLevelWidget(); NSWindow* rootWindow = static_cast<NSWindow*>(rootWidget->GetNativeData(NS_NATIVE_WINDOW)); NSView* rootView = static_cast<NSView*>(rootWidget->GetNativeData(NS_NATIVE_WIDGET)); if (!rootWindow || !rootView) { return rect; } - rect = nsCocoaUtils::DevPixelsToCocoaPoints(LayoutDevicePixel::ToUntyped(r), + rect = nsCocoaUtils::DevPixelsToCocoaPoints(r.ToUnknownRect(), mWidget->BackingScaleFactor()); rect = [rootView convertRect:rect toView:nil]; rect.origin = [rootWindow convertBaseToScreen:rect.origin]; if (aActualRange) { *aActualRange = actualRange; }
--- a/widget/gonk/HwcComposer2D.cpp +++ b/widget/gonk/HwcComposer2D.cpp @@ -295,18 +295,17 @@ HwcComposer2D::PrepareLayerList(Layer* a } if (aLayer->GetMaskLayer()) { LOGD("%s Layer has MaskLayer which is unsupported by hwcomposer", aLayer->Name()); return false; } nsIntRect clip; - nsIntRect layerClip = aLayer->GetEffectiveClipRect() ? - ParentLayerIntRect::ToUntyped(*aLayer->GetEffectiveClipRect()) : nsIntRect(); + nsIntRect layerClip = aLayer->GetEffectiveClipRect().valueOr(ParentLayerIntRect()).ToUnknownRect(); nsIntRect* layerClipPtr = aLayer->GetEffectiveClipRect() ? &layerClip : nullptr; if (!HwcUtils::CalculateClipRect(aParentTransform, layerClipPtr, aClip, &clip)) { LOGD("%s Clip rect is empty. Skip layer", aLayer->Name()); return true;
--- a/widget/gtk/IMContextWrapper.cpp +++ b/widget/gtk/IMContextWrapper.cpp @@ -1866,17 +1866,17 @@ IMContextWrapper::SetCursorPosition(GtkI // Get the position of IM context owner window in screen. LayoutDeviceIntPoint owner = mOwnerWindow->WidgetToScreenOffset(); // Compute the caret position in the IM owner window. LayoutDeviceIntRect rect = charRect.mReply.mRect + root - owner; rect.width = 0; GdkRectangle area = rootWindow->DevicePixelsToGdkRectRoundOut( - LayoutDeviceIntRect::ToUntyped(rect)); + rect.ToUnknownRect()); gtk_im_context_set_cursor_location(aContext, &area); } nsresult IMContextWrapper::GetCurrentParagraph(nsAString& aText, uint32_t& aCursorPos) {
--- a/widget/gtk/nsWindow.cpp +++ b/widget/gtk/nsWindow.cpp @@ -1471,17 +1471,17 @@ nsWindow::SetFocus(bool aRaise) NS_IMETHODIMP nsWindow::GetScreenBoundsUntyped(nsIntRect &aRect) { if (mIsTopLevel && mContainer) { // use the point including window decorations gint x, y; gdk_window_get_root_origin(gtk_widget_get_window(GTK_WIDGET(mContainer)), &x, &y); - aRect.MoveTo(LayoutDevicePixel::ToUntyped(GdkPointToDevicePixels({ x, y }))); + aRect.MoveTo(GdkPointToDevicePixels({ x, y }).ToUnknownPoint()); } else { aRect.MoveTo(WidgetToScreenOffsetUntyped()); } // mBounds.Size() is the window bounds, not the window-manager frame // bounds (bug 581863). gdk_window_get_frame_extents would give the // frame bounds, but mBounds.Size() is returned here for consistency // with Resize.
--- a/widget/nsIWidget.h +++ b/widget/nsIWidget.h @@ -1369,17 +1369,17 @@ class nsIWidget : public nsISupports { * Return this widget's origin in screen coordinates. The untyped version * exists temporarily to ease conversion to typed coordinates. * * @return screen coordinates stored in the x,y members */ virtual mozilla::LayoutDeviceIntPoint WidgetToScreenOffset() = 0; virtual nsIntPoint WidgetToScreenOffsetUntyped() { - return mozilla::LayoutDeviceIntPoint::ToUntyped(WidgetToScreenOffset()); + return WidgetToScreenOffset().ToUnknownPoint(); } /** * Given the specified client size, return the corresponding window size, * which includes the area for the borders and titlebar. This method * should work even when the window is not yet visible. */ virtual mozilla::LayoutDeviceIntSize ClientToWindowSize(
--- a/widget/windows/IMMHandler.cpp +++ b/widget/windows/IMMHandler.cpp @@ -1657,18 +1657,17 @@ IMMHandler::HandleQueryCharPosition(nsWi WidgetQueryContentEvent editorRect(true, eQueryEditorRect, aWindow); aWindow->InitEvent(editorRect); aWindow->DispatchWindowEvent(&editorRect); if (NS_WARN_IF(!editorRect.mSucceeded)) { MOZ_LOG(gIMMLog, LogLevel::Error, ("IMM: HandleQueryCharPosition, eQueryEditorRect failed")); ::GetWindowRect(aWindow->GetWindowHandle(), &pCharPosition->rcDocument); } else { - nsIntRect editorRectInWindow = - LayoutDevicePixel::ToUntyped(editorRect.mReply.mRect); + nsIntRect editorRectInWindow = editorRect.mReply.mRect.ToUnknownRect(); nsWindow* window = editorRect.mReply.mFocusedWidget ? static_cast<nsWindow*>(editorRect.mReply.mFocusedWidget) : aWindow; nsIntRect editorRectInScreen; ResolveIMECaretPos(window, editorRectInWindow, nullptr, editorRectInScreen); ::SetRect(&pCharPosition->rcDocument, editorRectInScreen.x, editorRectInScreen.y, editorRectInScreen.XMost(), editorRectInScreen.YMost()); } @@ -2165,17 +2164,17 @@ IMMHandler::GetCharacterRectOfSelectedTe // If there is a caret and retrieving offset is same as the caret offset, // we should use the caret rect. if (offset != caretOffset) { WidgetQueryContentEvent charRect(true, eQueryTextRect, aWindow); charRect.InitForQueryTextRect(offset, 1); aWindow->InitEvent(charRect, &point); aWindow->DispatchWindowEvent(&charRect); if (charRect.mSucceeded) { - aCharRect = LayoutDevicePixel::ToUntyped(charRect.mReply.mRect); + aCharRect = charRect.mReply.mRect.ToUnknownRect(); if (aWritingMode) { *aWritingMode = charRect.GetWritingMode(); } MOZ_LOG(gIMMLog, LogLevel::Debug, ("IMM: GetCharacterRectOfSelectedTextAt, Succeeded, aOffset=%u, " "aCharRect={ x: %ld, y: %ld, width: %ld, height: %ld }, " "charRect.GetWritingMode()=%s", aOffset, aCharRect.x, aCharRect.y, aCharRect.width, aCharRect.height, @@ -2206,17 +2205,17 @@ IMMHandler::GetCaretRect(nsWindow* aWind caretRect.InitForQueryCaretRect(selection.mOffset); aWindow->InitEvent(caretRect, &point); aWindow->DispatchWindowEvent(&caretRect); if (!caretRect.mSucceeded) { MOZ_LOG(gIMMLog, LogLevel::Info, ("IMM: GetCaretRect, FAILED, due to eQueryCaretRect failure")); return false; } - aCaretRect = LayoutDevicePixel::ToUntyped(caretRect.mReply.mRect); + aCaretRect = caretRect.mReply.mRect.ToUnknownRect(); if (aWritingMode) { *aWritingMode = caretRect.GetWritingMode(); } MOZ_LOG(gIMMLog, LogLevel::Info, ("IMM: GetCaretRect, SUCCEEDED, " "aCaretRect={ x: %ld, y: %ld, width: %ld, height: %ld }, " "caretRect.GetWritingMode()=%s", aCaretRect.x, aCaretRect.y, aCaretRect.width, aCaretRect.height,