Attachment #514156 for bug #635373

Attachment #514156: GL fix for bug #635373

View | Details | Raw Unified | Return to bug 635373
Collapse All | Expand All





    *aRotationPoint += aSize;
  } else if (*aRotationPoint >= aSize) {
    *aRotationPoint -= aSize;
  }
}

ThebesLayerBuffer::PaintState
ThebesLayerBuffer::BeginPaint(ThebesLayer* aLayer, ContentType aContentType,
                              const nsIntRegion& aNeededRegion,
                              float aXResolution, float aYResolution)
{
  PaintState result;

  result.mRegionToDraw.Sub(aNeededRegion, aLayer->GetValidRegion());

  float curXRes = aLayer->GetXResolution();
  float curYRes = aLayer->GetYResolution();
  if (mBuffer &&
      (aContentType != mBuffer->GetContentType() ||
       aXResolution != curXRes || aYResolution != curYRes)) {
    // We're effectively clearing the valid region, so we need to draw
    // the entire needed region now.
    //
    // XXX/cjones: a possibly worthwhile optimization to keep in mind
    // is to re-use buffers when the resolution and visible region
    // have changed in such a way that the buffer size stays the same.
    // It might make even more sense to allocate buffers from a
    // recyclable pool, so that we could keep this logic simple and
    // still get back the same buffer.
    result.mRegionToDraw = aNeededRegion;
    result.mRegionToInvalidate = aLayer->GetValidRegion();
    Clear();
  }

  if (result.mRegionToDraw.IsEmpty())
    return result;
  nsIntRect drawBounds = result.mRegionToDraw.GetBounds();

  nsIntRect neededBounds = aNeededRegion.GetBounds();
  nsIntSize destBufferDims = ScaledSize(neededBounds.Size(),
                                        aXResolution, aYResolution);
  nsRefPtr<gfxASurface> destBuffer;
  nsIntRect destBufferRect;
  PRBool bufferDimsChanged = PR_FALSE;

  if (BufferSizeOkFor(destBufferDims)) {
    NS_ASSERTION(curXRes == aXResolution && curYRes == aYResolution,
                 "resolution changes must Clear()!");

    // The current buffer is big enough to hold the needed area.
    if (mBufferRect.Contains(neededBounds)) {
      // We don't need to adjust mBufferRect.
      destBufferRect = mBufferRect;
    } else {
      // The buffer's big enough but doesn't contain everything that's
      // going to be visible. We'll move it.
      destBufferRect = nsIntRect(neededBounds.TopLeft(), mBufferRect.Size());
    }
    nsIntRect keepArea;
    if (keepArea.IntersectRect(destBufferRect, mBufferRect)) {
      // Set mBufferRotation so that the pixels currently in mBuffer
      // will still be rendered in the right place when mBufferRect
      // changes to destBufferRect.
      nsIntPoint newRotation = mBufferRotation +
        (destBufferRect.TopLeft() - mBufferRect.TopLeft());
      WrapRotationAxis(&newRotation.x, mBufferRect.width);
      WrapRotationAxis(&newRotation.y, mBufferRect.height);
      NS_ASSERTION(nsIntRect(nsIntPoint(0,0), mBufferRect.Size()).Contains(newRotation),
                   "newRotation out of bounds");
      PRInt32 xBoundary = destBufferRect.XMost() - newRotation.x;
      PRInt32 yBoundary = destBufferRect.YMost() - newRotation.y;
      if ((drawBounds.x < xBoundary && xBoundary < drawBounds.XMost()) ||
          (drawBounds.y < yBoundary && yBoundary < drawBounds.YMost()) ||
          (!mEnableRotationOptimization && newRotation != nsIntPoint(0,0))) {
        // The stuff we need to redraw will wrap around an edge of the
        // buffer, so we will need to do a self-copy
        if (mBuffer->SupportsSelfCopy() && mBufferRotation == nsIntPoint(0,0)) {
          destBuffer = mBuffer;
        } else {
          // We can't do a real self-copy because the buffer is rotated.
          // So allocate a new buffer for the destination.
          destBufferRect = neededBounds;
          destBufferDims = ScaledSize(destBufferRect.Size(),
                                      aXResolution, aYResolution);
          bufferDimsChanged = PR_TRUE;
          destBuffer = CreateBuffer(aContentType, destBufferDims);
          if (!destBuffer)
            return result;
        }
      } else {

      // No pixels are going to be kept. The whole visible region
      // will be redrawn, so we don't need to copy anything, so we don't
      // set destBuffer.
      mBufferRect = destBufferRect;
      mBufferRotation = nsIntPoint(0,0);
    }
  } else {
    // The buffer's not big enough, so allocate a new one
    destBufferRect = neededBounds;
    destBufferDims = ScaledSize(destBufferRect.Size(),
                                aXResolution, aYResolution);
    bufferDimsChanged = PR_TRUE;
    destBuffer = CreateBuffer(aContentType, destBufferDims);
    if (!destBuffer)
      return result;
  }



    mBuffer = destBuffer.forget();
    mBufferRect = destBufferRect;
    mBufferRotation = nsIntPoint(0,0);
  }
  if (bufferDimsChanged) {
    mBufferDims = destBufferDims;
  }
  NS_ASSERTION(mEnableRotationOptimization || mBufferRotation == nsIntPoint(0,0),
               "Rotation disabled, but we have nonzero rotation?");

  nsIntRegion invalidate;
  invalidate.Sub(aLayer->GetValidRegion(), destBufferRect);
  result.mRegionToInvalidate.Or(result.mRegionToInvalidate, invalidate);

  result.mContext = GetContextForQuadrantUpdate(drawBounds,
                                                aXResolution, aYResolution);






    SizedToVisibleBounds,
    ContainsVisibleBounds
  };

  ThebesLayerBuffer(BufferSizePolicy aBufferSizePolicy)
    : mBufferDims(0,0)
    , mBufferRotation(0,0)
    , mBufferSizePolicy(aBufferSizePolicy)
    , mEnableRotationOptimization(PR_FALSE)
  {
    MOZ_COUNT_CTOR(ThebesLayerBuffer);
  }
  virtual ~ThebesLayerBuffer()
  {
    MOZ_COUNT_DTOR(ThebesLayerBuffer);
  }

  void SetEnableRotationOptimization(PRBool aEnable)
  {
    if (mEnableRotationOptimization != aEnable) {
      // Force a new buffer to be created, since subclasses may decide
      // to create different buffer types depending on whether rotation is allowed
      Clear();
      mEnableRotationOptimization = aEnable;
    }
  }

  /**
   * Wipe out all retained contents. Call this when the entire
   * buffer becomes invalid.
   */
  void Clear()
  {
    mBuffer = nsnull;
    mBufferDims.SizeTo(0, 0);

   * Start a drawing operation. This returns a PaintState describing what
   * needs to be drawn to bring the buffer up to date in the visible region.
   * This queries aLayer to get the currently valid and visible regions.
   * The returned mContext may be null if mRegionToDraw is empty.
   * Otherwise it must not be null.
   * mRegionToInvalidate will contain mRegionToDraw.
   */
  PaintState BeginPaint(ThebesLayer* aLayer, ContentType aContentType,
                        const nsIntRegion& aNeededRegion,
                        float aXResolution, float aYResolution);

  /**
   * Return a new surface of |aSize| and |aType|.
   */
  virtual already_AddRefed<gfxASurface>
  CreateBuffer(ContentType aType, const nsIntSize& aSize) = 0;


   * So the pixel at mBufferRotation within the buffer is what gets painted at
   * mBufferRect.TopLeft().
   * This is "rotation" in the sense of rotating items in a linear buffer,
   * where items falling off the end of the buffer are returned to the
   * buffer at the other end, not 2D rotation!
   */
  nsIntPoint            mBufferRotation;
  BufferSizePolicy      mBufferSizePolicy;

protected:
  PRPackedBool          mEnableRotationOptimization;
};

}
}

#endif /* THEBESLAYERBUFFER_H_ */





class BasicThebesLayer;
class BasicThebesLayerBuffer : public ThebesLayerBuffer {
  typedef ThebesLayerBuffer Base;

public:
  BasicThebesLayerBuffer(BasicThebesLayer* aLayer)
    : Base(ContainsVisibleBounds)
    , mLayer(aLayer)
  {
    mEnableRotationOptimization = PR_TRUE;
  }

  virtual ~BasicThebesLayerBuffer()
  {}

  using Base::BufferRect;
  using Base::BufferRotation;

  /**


private:
  BasicThebesLayerBuffer(gfxASurface* aBuffer,
                         const nsIntRect& aRect, const nsIntPoint& aRotation)
    // The size policy doesn't really matter here; this constructor is
    // intended to be used for creating temporaries
    : ThebesLayerBuffer(ContainsVisibleBounds)
  {
    mEnableRotationOptimization = PR_TRUE;
    gfxIntSize sz = aBuffer->GetSize();
    SetBuffer(aBuffer, nsIntSize(sz.width, sz.height), aRect, aRotation);
  }

  BasicThebesLayer* mLayer;
};

class BasicThebesLayer : public ThebesLayer, BasicImplData {

    return;
  }

  {
    gfxSize scale = aContext->CurrentMatrix().ScaleFactors(PR_TRUE);
    float paintXRes = BasicManager()->XResolution() * gfxUtils::ClampToScaleFactor(scale.width);
    float paintYRes = BasicManager()->YResolution() * gfxUtils::ClampToScaleFactor(scale.height);
    Buffer::PaintState state =
      mBuffer.BeginPaint(this, contentType, mVisibleRegion, paintXRes, paintYRes);
    mValidRegion.Sub(mValidRegion, state.mRegionToInvalidate);

    if (state.mContext) {
      // The area that became invalid and is visible needs to be repainted
      // (this could be the whole visible area if our buffer switched
      // from RGB to RGBA, because we might need to repaint with
      // subpixel AA)
      state.mRegionToInvalidate.And(state.mRegionToInvalidate, mVisibleRegion);





#include "gfxTeeSurface.h"

namespace mozilla {
namespace layers {

using gl::GLContext;
using gl::TextureImage;

static const int ALLOW_REPEAT = 0x01;

// BindAndDrawQuadWithTextureRect can work with either GL_REPEAT (preferred)
// or GL_CLAMP_TO_EDGE textures.  We select based on whether REPEAT is
// valid for non-power-of-two textures -- if we have NPOT support we use it,
// otherwise we stick with CLAMP_TO_EDGE and decompose.
static already_AddRefed<TextureImage>
CreateClampOrRepeatTextureImage(GLContext *aGl,
                                const nsIntSize& aSize,
                                TextureImage::ContentType aContentType,
                                PRUint32 aFlags)
{
  GLenum wrapMode = LOCAL_GL_CLAMP_TO_EDGE;
  if ((aFlags & ALLOW_REPEAT) &&
      (aGl->IsExtensionSupported(GLContext::ARB_texture_non_power_of_two) ||
       aGl->IsExtensionSupported(GLContext::OES_texture_npot)))
  {
    wrapMode = LOCAL_GL_REPEAT;
  }

  return aGl->CreateTextureImage(aSize, aContentType, wrapMode);
}

// |aTexCoordRect| is the rectangle from the texture that we want to

  typedef ThebesLayerBuffer::PaintState PaintState;

  ThebesLayerBufferOGL(ThebesLayer* aLayer, LayerOGL* aOGLLayer)
    : mLayer(aLayer)
    , mOGLLayer(aOGLLayer)
  {}
  virtual ~ThebesLayerBufferOGL() {}

  virtual void SetEnableRotationOptimization(PRBool aEnable) = 0;

  virtual PaintState BeginPaint(ContentType aContentType,
                                const nsIntRegion& aNeededRegion,
                                float aXResolution,
                                float aYResolution) = 0;

  void RenderTo(const nsIntPoint& aOffset, LayerManagerOGL* aManager);

  nsIntSize GetSize() {
    if (mTexImage)
      return mTexImage->GetSize();

      DEBUG_GL_ERROR_CHECK(gl());
      alphaProgram->SetBlackTextureUnit(0);
      alphaProgram->SetWhiteTextureUnit(1);
      program = alphaProgram;
    } else {
      // Note BGR: Cairo's image surfaces are always in what
      // OpenGL and our shaders consider BGR format.
      ColorTextureLayerProgram *basicProgram =
        aManager->GetBasicLayerProgram(mTexImage->GetContentType() == gfxASurface::CONTENT_COLOR,
                                       mTexImage->IsRGB());

      basicProgram->Activate();
      DEBUG_GL_ERROR_CHECK(gl());
      basicProgram->SetTextureUnit(0);
      program = basicProgram;
    }



  SurfaceBufferOGL(ThebesLayerOGL* aLayer)
    : ThebesLayerBufferOGL(aLayer, aLayer)
    , ThebesLayerBuffer(SizedToVisibleBounds)
  {
  }
  virtual ~SurfaceBufferOGL() {}

  virtual void SetEnableRotationOptimization(PRBool aEnable)
  {
    ThebesLayerBuffer::SetEnableRotationOptimization(aEnable);
  }

  // ThebesLayerBufferOGL interface
  virtual PaintState BeginPaint(ContentType aContentType, 
                                const nsIntRegion& aNeededRegion,
                                float aXResolution,
                                float aYResolution)
  {
    // Let ThebesLayerBuffer do all the hard work for us! :D
    return ThebesLayerBuffer::BeginPaint(mLayer, 
                                         aContentType, 
                                         aNeededRegion,
                                         aXResolution, 
                                         aYResolution);
  }

  // ThebesLayerBuffer interface
  virtual already_AddRefed<gfxASurface>
  CreateBuffer(ContentType aType, const nsIntSize& aSize)
  {
    NS_ASSERTION(gfxASurface::CONTENT_ALPHA != aType,"ThebesBuffer has color");

    mTexImage = CreateClampOrRepeatTextureImage(gl(), aSize, aType,
            mEnableRotationOptimization ? ALLOW_REPEAT : 0);
    return mTexImage ? mTexImage->GetBackingSurface() : nsnull;
  }

protected:
  virtual nsIntPoint GetOriginOffset() {
    return BufferRect().TopLeft() - BufferRotation();
  }
};

// and implementing them here using GL hacketry.
class BasicBufferOGL : public ThebesLayerBufferOGL
{
public:
  BasicBufferOGL(ThebesLayerOGL* aLayer)
    : ThebesLayerBufferOGL(aLayer, aLayer)
    , mBufferRect(0,0,0,0)
    , mBufferRotation(0,0)
    , mEnableRotationOptimization(PR_FALSE)
  {}
  virtual ~BasicBufferOGL() {}

  virtual void SetEnableRotationOptimization(PRBool aEnable)
  {
    mEnableRotationOptimization = aEnable;
  }
  virtual PaintState BeginPaint(ContentType aContentType,
                                const nsIntRegion& aNeededRegion,
                                float aXResolution,
                                float aYResolution);

protected:
  enum XSide {
    LEFT, RIGHT
  };
  enum YSide {


  virtual nsIntPoint GetOriginOffset() {
    return mBufferRect.TopLeft() - mBufferRotation;
  }

private:
  nsIntRect mBufferRect;
  nsIntPoint mBufferRotation;
  PRPackedBool mEnableRotationOptimization;
};

static void
WrapRotationAxis(PRInt32* aRotationPoint, PRInt32 aSize)
{
  if (*aRotationPoint < 0) {
    *aRotationPoint += aSize;
  } else if (*aRotationPoint >= aSize) {


  nsIntRect rect(0, 0, aSize.width, aSize.height);
  rect.ScaleRoundOut(aXScale, aYScale);
  return rect.Size();
}

BasicBufferOGL::PaintState
BasicBufferOGL::BeginPaint(ContentType aContentType,
                           const nsIntRegion& aNeededRegion,
                           float aXResolution,
                           float aYResolution)
{
  PaintState result;

  result.mRegionToDraw.Sub(aNeededRegion, mLayer->GetValidRegion());
  
  float curXRes = mLayer->GetXResolution();
  float curYRes = mLayer->GetYResolution();
  Layer::SurfaceMode mode = mLayer->GetSurfaceMode();

  if (mode == Layer::SURFACE_COMPONENT_ALPHA) {
#ifdef MOZ_GFX_OPTIMIZE_MOBILE
    mode = Layer::SURFACE_SINGLE_CHANNEL_ALPHA;
#else
    if (!mLayer->GetParent() || !mLayer->GetParent()->SupportsComponentAlphaChildren()) {
      mode = Layer::SURFACE_SINGLE_CHANNEL_ALPHA;
    } else {
      aContentType = gfxASurface::CONTENT_COLOR;
    }
#endif
  }
  if (mode == Layer::SURFACE_OPAQUE && aContentType == gfxASurface::CONTENT_COLOR_ALPHA) {
    // The caller may be forcing us to use an RGBA texture
    mode = Layer::SURFACE_SINGLE_CHANNEL_ALPHA;
  }

  if (!mTexImage || mTexImage->GetContentType() != aContentType ||
      aXResolution != curXRes || aYResolution != curYRes ||
      (mode == Layer::SURFACE_COMPONENT_ALPHA) != (mTexImageOnWhite != nsnull)) {
    // We're effectively clearing the valid region, so we need to draw
    // the entire needed region now.
    //
    // XXX/cjones: a possibly worthwhile optimization to keep in mind
    // is to re-use buffers when the resolution and visible region
    // have changed in such a way that the buffer size stays the same.
    // It might make even more sense to allocate buffers from a
    // recyclable pool, so that we could keep this logic simple and
    // still get back the same buffer.
    result.mRegionToDraw = aNeededRegion;
    result.mRegionToInvalidate = mLayer->GetValidRegion();
    mTexImage = nsnull;
    mTexImageOnWhite = nsnull;
    mBufferRect.SetRect(0, 0, 0, 0);
    mBufferRotation.MoveTo(0, 0);
  }

  if (result.mRegionToDraw.IsEmpty())
    return result;

  nsIntRect neededBounds = aNeededRegion.GetBounds();
  nsIntRect drawBounds = result.mRegionToDraw.GetBounds();
  nsIntSize destBufferDims = ScaledSize(neededBounds.Size(),
                                        aXResolution, aYResolution);
  
  if (destBufferDims.width > gl()->GetMaxTextureSize() ||
      destBufferDims.height > gl()->GetMaxTextureSize()) {
    return result;
  }

  nsRefPtr<TextureImage> destBuffer;
  nsRefPtr<TextureImage> destBufferOnWhite;
  nsIntRect destBufferRect;
  PRUint32 textureFlags = mEnableRotationOptimization ? ALLOW_REPEAT : 0;

  if (neededBounds.Size() <= mBufferRect.Size() &&
      mTexImage &&
      (mTexImage->GetWrapMode() == LOCAL_GL_CLAMP_TO_EDGE || mEnableRotationOptimization)) {
    NS_ASSERTION(curXRes == aXResolution && curYRes == aYResolution,
                 "resolution changes must clear the buffer!");
    // The current buffer is big enough to hold the visible area.
    if (mBufferRect.Contains(neededBounds)) {
      // We don't need to adjust mBufferRect.
      destBufferRect = mBufferRect;
    } else {
      // The buffer's big enough but doesn't contain everything that's
      // going to be visible. We'll move it.
      destBufferRect = nsIntRect(neededBounds.TopLeft(), mBufferRect.Size());
    }
    nsIntRect keepArea;
    if (keepArea.IntersectRect(destBufferRect, mBufferRect)) {
      // Set mBufferRotation so that the pixels currently in mBuffer
      // will still be rendered in the right place when mBufferRect
      // changes to destBufferRect.
      nsIntPoint newRotation = mBufferRotation +
        (destBufferRect.TopLeft() - mBufferRect.TopLeft());
      WrapRotationAxis(&newRotation.x, mBufferRect.width);
      WrapRotationAxis(&newRotation.y, mBufferRect.height);
      NS_ASSERTION(nsIntRect(nsIntPoint(0,0), mBufferRect.Size()).Contains(newRotation),
                   "newRotation out of bounds");
      PRInt32 xBoundary = destBufferRect.XMost() - newRotation.x;
      PRInt32 yBoundary = destBufferRect.YMost() - newRotation.y;
      if ((drawBounds.x < xBoundary && xBoundary < drawBounds.XMost()) ||
          (drawBounds.y < yBoundary && yBoundary < drawBounds.YMost()) ||
          (!mEnableRotationOptimization && newRotation != nsIntPoint(0,0))) {
        // The stuff we need to redraw will wrap around an edge of the
        // buffer, so we will need to do a self-copy
        // If mBufferRotation == nsIntPoint(0,0) we could do a real
        // self-copy but we're not going to do that in GL yet.
        // We can't do a real self-copy because the buffer is rotated.
        // So allocate a new buffer for the destination.
        destBufferRect = neededBounds;
        destBuffer = CreateClampOrRepeatTextureImage(gl(), destBufferDims, aContentType, textureFlags);
        DEBUG_GL_ERROR_CHECK(gl());
        if (!destBuffer)
          return result;
        if (mode == Layer::SURFACE_COMPONENT_ALPHA) {
          destBufferOnWhite =
            CreateClampOrRepeatTextureImage(gl(), destBufferDims, aContentType, textureFlags);
          DEBUG_GL_ERROR_CHECK(gl());
          if (!destBufferOnWhite)
            return result;
        }
      } else {
        mBufferRect = destBufferRect;
        mBufferRotation = newRotation;
      }

      // No pixels are going to be kept. The whole visible region
      // will be redrawn, so we don't need to copy anything, so we don't
      // set destBuffer.
      mBufferRect = destBufferRect;
      mBufferRotation = nsIntPoint(0,0);
    }
  } else {
    // The buffer's not big enough, so allocate a new one
    destBufferRect = neededBounds;
    destBuffer = CreateClampOrRepeatTextureImage(gl(), destBufferDims, aContentType, textureFlags);
    DEBUG_GL_ERROR_CHECK(gl());
    if (!destBuffer)
      return result;

    if (mode == Layer::SURFACE_COMPONENT_ALPHA) {
      destBufferOnWhite = 
        CreateClampOrRepeatTextureImage(gl(), destBufferDims, aContentType, textureFlags);
      DEBUG_GL_ERROR_CHECK(gl());
      if (!destBufferOnWhite)
        return result;
    }
  }

  if (!destBuffer && !mTexImage) {
    return result;

                               destBuffer, dstRect);
        if (mode == Layer::SURFACE_COMPONENT_ALPHA) {
          destBufferOnWhite->Resize(size);
          gl()->BlitTextureImage(mTexImageOnWhite, srcRect,
                                 destBufferOnWhite, dstRect);
        }
      } else {
        // can't blit, just draw everything
        destBufferRect = neededBounds;
        destBuffer = CreateClampOrRepeatTextureImage(gl(), destBufferDims, aContentType, textureFlags);
        if (mode == Layer::SURFACE_COMPONENT_ALPHA) {
          destBufferOnWhite = 
            CreateClampOrRepeatTextureImage(gl(), destBufferDims, aContentType, textureFlags);
        }
      }
    }

    mTexImage = destBuffer.forget();
    if (mode == Layer::SURFACE_COMPONENT_ALPHA) {
      mTexImageOnWhite = destBufferOnWhite.forget();
    }
    mBufferRect = destBufferRect;
    mBufferRotation = nsIntPoint(0,0);
  }
  NS_ASSERTION(mEnableRotationOptimization || mBufferRotation == nsIntPoint(0,0),
               "Rotation disabled, but we have nonzero rotation?");

  nsIntRegion invalidate;
  invalidate.Sub(mLayer->GetValidRegion(), destBufferRect);
  result.mRegionToInvalidate.Or(result.mRegionToInvalidate, invalidate);

  // Figure out which quadrant to draw in
  PRInt32 xBoundary = mBufferRect.XMost() - mBufferRotation.x;
  PRInt32 yBoundary = mBufferRect.YMost() - mBufferRotation.y;

    // be incorrect.
    surf->SetAllowUseAsSource(PR_FALSE);
    result.mContext = new gfxContext(surf);
  } else {
    result.mContext = new gfxContext(mTexImage->BeginUpdate(result.mRegionToDraw));
    if (mTexImage->GetContentType() == gfxASurface::CONTENT_COLOR_ALPHA) {
      gfxUtils::ClipToRegion(result.mContext, result.mRegionToDraw);
      result.mContext->SetOperator(gfxContext::OPERATOR_CLEAR);
      result.mContext->Paint();
      result.mContext->SetOperator(gfxContext::OPERATOR_OVER);
    }
  }
  if (!result.mContext) {
    NS_WARNING("unable to get context for update");
    return result;
  }
  result.mContext->Scale(aXResolution, aYResolution);

  mOGLManager->MakeCurrent();
  gl()->fActiveTexture(LOCAL_GL_TEXTURE0);

  TextureImage::ContentType contentType =
    CanUseOpaqueSurface() ? gfxASurface::CONTENT_COLOR :
                            gfxASurface::CONTENT_COLOR_ALPHA;

  const gfx3DMatrix& transform = GetEffectiveTransform();
  nsIntRegion neededRegion = mVisibleRegion;
  gfxMatrix transform2d;
  gfxSize scale(1.0, 1.0);
  float paintXRes = 1.0;
  float paintYRes = 1.0;
  bool willResample;
  if (transform.Is2D(&transform2d)) {
    scale = transform2d.ScaleFactors(PR_TRUE);
    paintXRes = gfxUtils::ClampToScaleFactor(scale.width);
    paintYRes = gfxUtils::ClampToScaleFactor(scale.height);
    transform2d.Scale(1.0/paintXRes, 1.0/paintYRes);
    willResample = transform2d.HasNonIntegerTranslation();
  } else {
    willResample = true;
  }
  if (willResample && neededRegion.GetNumRects() > 1) {
    neededRegion = mVisibleRegion.GetBounds();
    contentType = gfxASurface::CONTENT_COLOR_ALPHA;
  }

  mBuffer->SetEnableRotationOptimization(!willResample);
  Buffer::PaintState state =
    mBuffer->BeginPaint(contentType, neededRegion, paintXRes, paintYRes);
  mValidRegion.Sub(mValidRegion, state.mRegionToInvalidate);

  if (state.mContext) {
    state.mRegionToInvalidate.And(state.mRegionToInvalidate, neededRegion);
    mXResolution = paintXRes;
    mYResolution = paintYRes;

    LayerManager::DrawThebesLayerCallback callback =
      mOGLManager->GetThebesLayerCallback();
    if (!callback) {
      NS_ERROR("GL should never need to update ThebesLayers in an empty transaction");
    } else {
      void* callbackData = mOGLManager->GetThebesLayerCallbackData();
      callback(this, state.mContext, state.mRegionToDraw,
               state.mRegionToInvalidate, callbackData);
      // Everything that's visible has been validated. Do this instead of
      // OR-ing with aRegionToDraw, since that can lead to a very complex region
      // here (OR doesn't automatically simplify to the simplest possible
      // representation of a region.)
      mValidRegion.Or(mValidRegion, neededRegion);
    }
  }

  DEBUG_GL_ERROR_CHECK(gl());

  gl()->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, aPreviousFrameBuffer);
  mBuffer->RenderTo(aOffset, mOGLManager);
  DEBUG_GL_ERROR_CHECK(gl());


class ShadowBufferOGL : public ThebesLayerBufferOGL
{
public:
  ShadowBufferOGL(ShadowThebesLayerOGL* aLayer)
    : ThebesLayerBufferOGL(aLayer, aLayer)
  {}

  virtual void SetEnableRotationOptimization(PRBool aEnable) {}
  virtual PaintState BeginPaint(ContentType aContentType,
                                const nsIntRegion&, float, float) {
    NS_RUNTIMEABORT("can't BeginPaint for a shadow layer");
    return PaintState();
  }

  void
  CreateTexture(ContentType aType, const nsIntSize& aSize)
  {
    NS_ASSERTION(gfxASurface::CONTENT_ALPHA != aType,"ThebesBuffer has color");

    mTexImage = CreateClampOrRepeatTextureImage(gl(), aSize, aType);
  }

  void Upload(gfxASurface* aUpdate, const nsIntRegion& aUpdated,
              const nsIntRect& aRect, const nsIntPoint& aRotation);

protected:
  virtual nsIntPoint GetOriginOffset() {
    return mBufferRect.TopLeft() - mBufferRotation;
  }


};

void
ShadowBufferOGL::Upload(gfxASurface* aUpdate, const nsIntRegion& aUpdated,
                        const nsIntRect& aRect, const nsIntPoint& aRotation)
{
  gfxIntSize size = aUpdate->GetSize();
  if (GetSize() != nsIntSize(size.width, size.height)) {
    // XXX we should do something here to decide whether to use REPEAT or not,
    // but I'm not sure what
    mTexImage = CreateClampOrRepeatTextureImage(gl(),
      nsIntSize(size.width, size.height), aUpdate->GetContentType(), ALLOW_REPEAT);
  }

  nsIntRegion destRegion(aUpdated);
  // aUpdated is in screen coordinates.  Move it so that the layer's
  // top-left is 0,0
  nsIntPoint visTopLeft = mLayer->GetVisibleRegion().GetBounds().TopLeft();
  destRegion.MoveBy(-visTopLeft);


Return to bug 635373