The Tor Browser: comparison gfx/layers/composite/ContainerLayerComposite.cpp

--1:000000000000
+:9f8ee54052ac
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+* 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/. */
+#include "ContainerLayerComposite.h"
+#include <algorithm>                    // for min
+#include "FrameMetrics.h"               // for FrameMetrics
+#include "Units.h"                      // for LayerRect, LayerPixel, etc
+#include "gfx2DGlue.h"                  // for ToMatrix4x4
+#include "gfx3DMatrix.h"                // for gfx3DMatrix
+#include "gfxPrefs.h"                   // for gfxPrefs
+#include "gfxUtils.h"                   // for gfxUtils, etc
+#include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc
+#include "mozilla/RefPtr.h"             // for RefPtr
+#include "mozilla/gfx/BaseRect.h"       // for BaseRect
+#include "mozilla/gfx/Matrix.h"         // for Matrix4x4
+#include "mozilla/gfx/Point.h"          // for Point, IntPoint
+#include "mozilla/gfx/Rect.h"           // for IntRect, Rect
+#include "mozilla/layers/Compositor.h"  // for Compositor, etc
+#include "mozilla/layers/CompositorTypes.h"  // for DIAGNOSTIC_CONTAINER
+#include "mozilla/layers/Effects.h"     // for Effect, EffectChain, etc
+#include "mozilla/layers/TextureHost.h"  // for CompositingRenderTarget
+#include "mozilla/mozalloc.h"           // for operator delete, etc
+#include "nsAutoPtr.h"                  // for nsRefPtr
+#include "nsDebug.h"                    // for NS_ASSERTION
+#include "nsISupportsImpl.h"            // for MOZ_COUNT_CTOR, etc
+#include "nsISupportsUtils.h"           // for NS_ADDREF, NS_RELEASE
+#include "nsPoint.h"                    // for nsIntPoint
+#include "nsRect.h"                     // for nsIntRect
+#include "nsRegion.h"                   // for nsIntRegion
+#include "nsTArray.h"                   // for nsAutoTArray
+#include "TextRenderer.h"               // for TextRenderer
+#include <vector>
+namespace mozilla {
+namespace layers {
+/**
+* Returns a rectangle of content painted opaquely by aLayer. Very consertative;
+* bails by returning an empty rect in any tricky situations.
+*/
+static nsIntRect
+GetOpaqueRect(Layer* aLayer)
+{
+nsIntRect result;
+gfx::Matrix matrix;
+bool is2D = aLayer->GetBaseTransform().Is2D(&matrix);
+// Just bail if there's anything difficult to handle.
+if (!is2D || aLayer->GetMaskLayer() ||
+aLayer->GetEffectiveOpacity() != 1.0f ||
+matrix.HasNonIntegerTranslation()) {
+return result;
+}
+if (aLayer->GetContentFlags() & Layer::CONTENT_OPAQUE) {
+result = aLayer->GetEffectiveVisibleRegion().GetLargestRectangle();
+} else {
+// Drill down into RefLayers because that's what we particularly care about;
+// layer construction for aLayer will not have known about the opaqueness
+// of any RefLayer subtrees.
+RefLayer* refLayer = aLayer->AsRefLayer();
+if (refLayer && refLayer->GetFirstChild()) {
+result = GetOpaqueRect(refLayer->GetFirstChild());
+}
+}
+// Translate our opaque region to cover the child
+gfx::Point point = matrix.GetTranslation();
+result.MoveBy(static_cast<int>(point.x), static_cast<int>(point.y));
+const nsIntRect* clipRect = aLayer->GetEffectiveClipRect();
+if (clipRect) {
+result.IntersectRect(result, *clipRect);
+}
+return result;
+}
+struct LayerVelocityUserData : public LayerUserData {
+public:
+LayerVelocityUserData() {
+MOZ_COUNT_CTOR(LayerVelocityUserData);
+}
+~LayerVelocityUserData() {
+MOZ_COUNT_DTOR(LayerVelocityUserData);
+}
+struct VelocityData {
+VelocityData(TimeStamp frameTime, int scrollX, int scrollY)
+: mFrameTime(frameTime)
+, mPoint(scrollX, scrollY)
+{}
+TimeStamp mFrameTime;
+gfx::Point mPoint;
+};
+std::vector<VelocityData> mData;
+};
+static gfx::Point GetScrollData(Layer* aLayer) {
+gfx::Matrix matrix;
+if (aLayer->GetLocalTransform().Is2D(&matrix)) {
+return matrix.GetTranslation();
+}
+gfx::Point origin;
+return origin;
+}
+static void DrawLayerInfo(const nsIntRect& aClipRect,
+LayerManagerComposite* aManager,
+Layer* aLayer)
+{
+if (aLayer->GetType() == Layer::LayerType::TYPE_CONTAINER) {
+// XXX - should figure out a way to render this, but for now this
+// is hard to do, since it will often get superimposed over the first
+// child of the layer, which is bad.
+return;
+}
+nsAutoCString layerInfo;
+aLayer->PrintInfo(layerInfo, "");
+nsIntRegion visibleRegion = aLayer->GetVisibleRegion();
+uint32_t maxWidth = std::min<uint32_t>(visibleRegion.GetBounds().width, 500);
+nsIntPoint topLeft = visibleRegion.GetBounds().TopLeft();
+aManager->GetTextRenderer()->RenderText(layerInfo.get(), gfx::IntPoint(topLeft.x, topLeft.y),
+aLayer->GetEffectiveTransform(), 16,
+maxWidth);
+}
+static LayerVelocityUserData* GetVelocityData(Layer* aLayer) {
+static char sLayerVelocityUserDataKey;
+void* key = reinterpret_cast<void*>(&sLayerVelocityUserDataKey);
+if (!aLayer->HasUserData(key)) {
+LayerVelocityUserData* newData = new LayerVelocityUserData();
+aLayer->SetUserData(key, newData);
+}
+return static_cast<LayerVelocityUserData*>(aLayer->GetUserData(key));
+}
+static void DrawVelGraph(const nsIntRect& aClipRect,
+LayerManagerComposite* aManager,
+Layer* aLayer) {
+Compositor* compositor = aManager->GetCompositor();
+gfx::Rect clipRect(aClipRect.x, aClipRect.y,
+aClipRect.width, aClipRect.height);
+TimeStamp now = TimeStamp::Now();
+LayerVelocityUserData* velocityData = GetVelocityData(aLayer);
+if (velocityData->mData.size() >= 1 &&
+now > velocityData->mData[velocityData->mData.size() - 1].mFrameTime +
+TimeDuration::FromMilliseconds(200)) {
+// clear stale data
+velocityData->mData.clear();
+}
+const gfx::Point layerTransform = GetScrollData(aLayer);
+velocityData->mData.push_back(
+LayerVelocityUserData::VelocityData(now,
+static_cast<int>(layerTransform.x), static_cast<int>(layerTransform.y)));
+// TODO: dump to file
+// XXX: Uncomment these lines to enable ScrollGraph logging. This is
+//      useful for HVGA phones or to output the data to accurate
+//      graphing software.
+// printf_stderr("ScrollGraph (%p): %f, %f\n",
+// aLayer, layerTransform.x, layerTransform.y);
+// Keep a circular buffer of 100.
+size_t circularBufferSize = 100;
+if (velocityData->mData.size() > circularBufferSize) {
+velocityData->mData.erase(velocityData->mData.begin());
+}
+if (velocityData->mData.size() == 1) {
+return;
+}
+// Clear and disable the graph when it's flat
+for (size_t i = 1; i < velocityData->mData.size(); i++) {
+if (velocityData->mData[i - 1].mPoint != velocityData->mData[i].mPoint) {
+break;
+}
+if (i == velocityData->mData.size() - 1) {
+velocityData->mData.clear();
+return;
+}
+}
+if (aLayer->GetEffectiveVisibleRegion().GetBounds().width < 300 ||
+aLayer->GetEffectiveVisibleRegion().GetBounds().height < 300) {
+// Don't want a graph for smaller layers
+return;
+}
+aManager->SetDebugOverlayWantsNextFrame(true);
+const gfx::Matrix4x4& transform = aLayer->GetEffectiveTransform();
+nsIntRect bounds = aLayer->GetEffectiveVisibleRegion().GetBounds();
+gfx::Rect graphBounds = gfx::Rect(bounds.x, bounds.y,
+bounds.width, bounds.height);
+gfx::Rect graphRect = gfx::Rect(bounds.x, bounds.y, 200, 100);
+float opacity = 1.0;
+EffectChain effects;
+effects.mPrimaryEffect = new EffectSolidColor(gfx::Color(0.2f,0,0,1));
+compositor->DrawQuad(graphRect,
+clipRect,
+effects,
+opacity,
+transform);
+std::vector<gfx::Point> graph;
+int yScaleFactor = 3;
+for (int32_t i = (int32_t)velocityData->mData.size() - 2; i >= 0; i--) {
+const gfx::Point& p1 = velocityData->mData[i+1].mPoint;
+const gfx::Point& p2 = velocityData->mData[i].mPoint;
+int vel = sqrt((p1.x - p2.x) * (p1.x - p2.x) +
+(p1.y - p2.y) * (p1.y - p2.y));
+graph.push_back(
+gfx::Point(bounds.x + graphRect.width / circularBufferSize * i,
+graphBounds.y + graphRect.height - vel/yScaleFactor));
+}
+compositor->DrawLines(graph, clipRect, gfx::Color(0,1,0,1),
+opacity, transform);
+}
+// ContainerRender is shared between RefLayer and ContainerLayer
+template<class ContainerT> void
+ContainerRender(ContainerT* aContainer,
+LayerManagerComposite* aManager,
+const nsIntRect& aClipRect)
+{
+/**
+* Setup our temporary surface for rendering the contents of this container.
+*/
+RefPtr<CompositingRenderTarget> surface;
+Compositor* compositor = aManager->GetCompositor();
+RefPtr<CompositingRenderTarget> previousTarget = compositor->GetCurrentRenderTarget();
+nsIntRect visibleRect = aContainer->GetEffectiveVisibleRegion().GetBounds();
+aContainer->mSupportsComponentAlphaChildren = false;
+float opacity = aContainer->GetEffectiveOpacity();
+bool needsSurface = aContainer->UseIntermediateSurface();
+if (needsSurface) {
+SurfaceInitMode mode = INIT_MODE_CLEAR;
+bool surfaceCopyNeeded = false;
+gfx::IntRect surfaceRect = gfx::IntRect(visibleRect.x, visibleRect.y,
+visibleRect.width, visibleRect.height);
+gfx::IntPoint sourcePoint = gfx::IntPoint(visibleRect.x, visibleRect.y);
+// we're about to create a framebuffer backed by textures to use as an intermediate
+// surface. What to do if its size (as given by framebufferRect) would exceed the
+// maximum texture size supported by the GL? The present code chooses the compromise
+// of just clamping the framebuffer's size to the max supported size.
+// This gives us a lower resolution rendering of the intermediate surface (children layers).
+// See bug 827170 for a discussion.
+int32_t maxTextureSize = compositor->GetMaxTextureSize();
+surfaceRect.width = std::min(maxTextureSize, surfaceRect.width);
+surfaceRect.height = std::min(maxTextureSize, surfaceRect.height);
+if (aContainer->GetEffectiveVisibleRegion().GetNumRects() == 1 &&
+(aContainer->GetContentFlags() & Layer::CONTENT_OPAQUE))
+{
+// don't need a background, we're going to paint all opaque stuff
+aContainer->mSupportsComponentAlphaChildren = true;
+mode = INIT_MODE_NONE;
+} else {
+const gfx::Matrix4x4& transform3D = aContainer->GetEffectiveTransform();
+gfx::Matrix transform;
+// If we have an opaque ancestor layer, then we can be sure that
+// all the pixels we draw into are either opaque already or will be
+// covered by something opaque. Otherwise copying up the background is
+// not safe.
+if (ContainerLayer::HasOpaqueAncestorLayer(aContainer) &&
+transform3D.Is2D(&transform) && !ThebesMatrix(transform).HasNonIntegerTranslation()) {
+surfaceCopyNeeded = gfxPrefs::ComponentAlphaEnabled();
+sourcePoint.x += transform._31;
+sourcePoint.y += transform._32;
+aContainer->mSupportsComponentAlphaChildren
+= gfxPrefs::ComponentAlphaEnabled();
+}
+}
+sourcePoint -= compositor->GetCurrentRenderTarget()->GetOrigin();
+if (surfaceCopyNeeded) {
+surface = compositor->CreateRenderTargetFromSource(surfaceRect, previousTarget, sourcePoint);
+} else {
+surface = compositor->CreateRenderTarget(surfaceRect, mode);
+}
+if (!surface) {
+return;
+}
+compositor->SetRenderTarget(surface);
+} else {
+surface = previousTarget;
+aContainer->mSupportsComponentAlphaChildren = (aContainer->GetContentFlags() & Layer::CONTENT_OPAQUE) ||
+(aContainer->GetParent() && aContainer->GetParent()->SupportsComponentAlphaChildren());
+}
+nsAutoTArray<Layer*, 12> children;
+aContainer->SortChildrenBy3DZOrder(children);
+/**
+* Render this container's contents.
+*/
+for (uint32_t i = 0; i < children.Length(); i++) {
+LayerComposite* layerToRender = static_cast<LayerComposite*>(children.ElementAt(i)->ImplData());
+if (layerToRender->GetLayer()->GetEffectiveVisibleRegion().IsEmpty() &&
+!layerToRender->GetLayer()->AsContainerLayer()) {
+continue;
+}
+nsIntRect clipRect = layerToRender->GetLayer()->
+CalculateScissorRect(aClipRect, &aManager->GetWorldTransform());
+if (clipRect.IsEmpty()) {
+continue;
+}
+nsIntRegion savedVisibleRegion;
+bool restoreVisibleRegion = false;
+if (i + 1 < children.Length() &&
+layerToRender->GetLayer()->GetEffectiveTransform().IsIdentity()) {
+LayerComposite* nextLayer = static_cast<LayerComposite*>(children.ElementAt(i + 1)->ImplData());
+nsIntRect nextLayerOpaqueRect;
+if (nextLayer && nextLayer->GetLayer()) {
+nextLayerOpaqueRect = GetOpaqueRect(nextLayer->GetLayer());
+}
+if (!nextLayerOpaqueRect.IsEmpty()) {
+savedVisibleRegion = layerToRender->GetShadowVisibleRegion();
+nsIntRegion visibleRegion;
+visibleRegion.Sub(savedVisibleRegion, nextLayerOpaqueRect);
+if (visibleRegion.IsEmpty()) {
+continue;
+}
+layerToRender->SetShadowVisibleRegion(visibleRegion);
+restoreVisibleRegion = true;
+}
+}
+if (layerToRender->HasLayerBeenComposited()) {
+// Composer2D will compose this layer so skip GPU composition
+// this time & reset composition flag for next composition phase
+layerToRender->SetLayerComposited(false);
+nsIntRect 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(nsIntRect(0, 0, 0, 0));
+}
+} else {
+layerToRender->RenderLayer(clipRect);
+}
+if (restoreVisibleRegion) {
+// Restore the region in case it's not covered by opaque content next time
+layerToRender->SetShadowVisibleRegion(savedVisibleRegion);
+}
+if (gfxPrefs::LayersScrollGraph()) {
+DrawVelGraph(clipRect, aManager, layerToRender->GetLayer());
+}
+if (gfxPrefs::DrawLayerInfo()) {
+DrawLayerInfo(clipRect, aManager, layerToRender->GetLayer());
+}
+// invariant: our GL context should be current here, I don't think we can
+// assert it though
+}
+if (needsSurface) {
+// Unbind the current surface and rebind the previous one.
+#ifdef MOZ_DUMP_PAINTING
+if (gfxUtils::sDumpPainting) {
+RefPtr<gfx::DataSourceSurface> surf = surface->Dump(aManager->GetCompositor());
+WriteSnapshotToDumpFile(aContainer, surf);
+}
+#endif
+compositor->SetRenderTarget(previousTarget);
+EffectChain effectChain(aContainer);
+LayerManagerComposite::AutoAddMaskEffect autoMaskEffect(aContainer->GetMaskLayer(),
+effectChain,
+!aContainer->GetTransform().CanDraw2D());
+effectChain.mPrimaryEffect = new EffectRenderTarget(surface);
+gfx::Rect rect(visibleRect.x, visibleRect.y, visibleRect.width, visibleRect.height);
+gfx::Rect clipRect(aClipRect.x, aClipRect.y, aClipRect.width, aClipRect.height);
+aManager->GetCompositor()->DrawQuad(rect, clipRect, effectChain, opacity,
+aContainer->GetEffectiveTransform());
+}
+if (aContainer->GetFrameMetrics().IsScrollable()) {
+const FrameMetrics& frame = aContainer->GetFrameMetrics();
+LayerRect layerBounds = ParentLayerRect(frame.mCompositionBounds) * ParentLayerToLayerScale(1.0);
+gfx::Rect rect(layerBounds.x, layerBounds.y, layerBounds.width, layerBounds.height);
+gfx::Rect clipRect(aClipRect.x, aClipRect.y, aClipRect.width, aClipRect.height);
+aManager->GetCompositor()->DrawDiagnostics(DIAGNOSTIC_CONTAINER,
+rect, clipRect,
+aContainer->GetEffectiveTransform());
+}
+}
+ContainerLayerComposite::ContainerLayerComposite(LayerManagerComposite *aManager)
+: ContainerLayer(aManager, nullptr)
+, LayerComposite(aManager)
+{
+MOZ_COUNT_CTOR(ContainerLayerComposite);
+mImplData = static_cast<LayerComposite*>(this);
+}
+ContainerLayerComposite::~ContainerLayerComposite()
+{
+MOZ_COUNT_DTOR(ContainerLayerComposite);
+// We don't Destroy() on destruction here because this destructor
+// can be called after remote content has crashed, and it may not be
+// safe to free the IPC resources of our children.  Those resources
+// are automatically cleaned up by IPDL-generated code.
+//
+// In the common case of normal shutdown, either
+// LayerManagerComposite::Destroy(), a parent
+// *ContainerLayerComposite::Destroy(), or Disconnect() will trigger
+// cleanup of our resources.
+while (mFirstChild) {
+RemoveChild(mFirstChild);
+}
+}
+void
+ContainerLayerComposite::Destroy()
+{
+if (!mDestroyed) {
+while (mFirstChild) {
+static_cast<LayerComposite*>(GetFirstChild()->ImplData())->Destroy();
+RemoveChild(mFirstChild);
+}
+mDestroyed = true;
+}
+}
+LayerComposite*
+ContainerLayerComposite::GetFirstChildComposite()
+{
+if (!mFirstChild) {
+return nullptr;
+}
+return static_cast<LayerComposite*>(mFirstChild->ImplData());
+}
+void
+ContainerLayerComposite::RenderLayer(const nsIntRect& aClipRect)
+{
+ContainerRender(this, mCompositeManager, aClipRect);
+}
+void
+ContainerLayerComposite::CleanupResources()
+{
+for (Layer* l = GetFirstChild(); l; l = l->GetNextSibling()) {
+LayerComposite* layerToCleanup = static_cast<LayerComposite*>(l->ImplData());
+layerToCleanup->CleanupResources();
+}
+}
+RefLayerComposite::RefLayerComposite(LayerManagerComposite* aManager)
+: RefLayer(aManager, nullptr)
+, LayerComposite(aManager)
+{
+mImplData = static_cast<LayerComposite*>(this);
+}
+RefLayerComposite::~RefLayerComposite()
+{
+Destroy();
+}
+void
+RefLayerComposite::Destroy()
+{
+MOZ_ASSERT(!mFirstChild);
+mDestroyed = true;
+}
+LayerComposite*
+RefLayerComposite::GetFirstChildComposite()
+{
+if (!mFirstChild) {
+return nullptr;
+}
+return static_cast<LayerComposite*>(mFirstChild->ImplData());
+}
+void
+RefLayerComposite::RenderLayer(const nsIntRect& aClipRect)
+{
+ContainerRender(this, mCompositeManager, aClipRect);
+}
+void
+RefLayerComposite::CleanupResources()
+{
+}
+} /* layers */
+} /* mozilla */

The Tor Browser / file comparison

comparison: gfx/layers/composite/ContainerLayerComposite.cpp

gfx/layers/composite/ContainerLayerComposite.cpp