The Tor Browser: gfx/gl/GLScreenBuffer.h@97036ab72558 (annotated)

gfx/gl/GLScreenBuffer.h@97036ab72558 (annotated)

gfx/gl/GLScreenBuffer.h

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40; -*- */
 /* 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/. */
 /* GLScreenBuffer is the abstraction for the "default framebuffer" used
  * by an offscreen GLContext. Since it's only for offscreen GLContext's,
  * it's only useful for things like WebGL, and is NOT used by the
  * compositor's GLContext. Remember that GLContext provides an abstraction
  * so that even if you want to draw to the 'screen', even if that's not
  * actually the screen, just draw to 0. This GLScreenBuffer class takes the
  * logic handling out of GLContext.
 */
 #ifndef SCREEN_BUFFER_H_
 #define SCREEN_BUFFER_H_
 #include "SurfaceTypes.h"
 #include "SurfaceStream.h"
 #include "GLContextTypes.h"
 #include "GLDefs.h"
 #include "mozilla/gfx/2D.h"
 #include "mozilla/gfx/Point.h"
 // Forwards:
 class gfxImageSurface;
 namespace mozilla {
     namespace gfx {
         class SurfaceStream;
         class SharedSurface;
     }
     namespace gl {
         class GLContext;
         class SharedSurface_GL;
         class SurfaceFactory_GL;
     }
 }
 namespace mozilla {
 namespace gl {
 class DrawBuffer
 {
 protected:
     typedef struct gfx::SurfaceCaps SurfaceCaps;
 public:
     // Infallible, may return null if unneeded.
     static DrawBuffer* Create(GLContext* const gl,
                               const SurfaceCaps& caps,
                               const GLFormats& formats,
                               const gfx::IntSize& size);
 protected:
     GLContext* const mGL;
     const gfx::IntSize mSize;
     const GLuint mFB;
     const GLuint mColorMSRB;
     const GLuint mDepthRB;
     const GLuint mStencilRB;
     DrawBuffer(GLContext* gl,
                const gfx::IntSize& size,
                GLuint fb,
                GLuint colorMSRB,
                GLuint depthRB,
                GLuint stencilRB)
         : mGL(gl)
         , mSize(size)
         , mFB(fb)
         , mColorMSRB(colorMSRB)
         , mDepthRB(depthRB)
         , mStencilRB(stencilRB)
     {}
 public:
     virtual ~DrawBuffer();
     const gfx::IntSize& Size() const {
         return mSize;
     }
     GLuint FB() const {
         return mFB;
     }
 };
 class ReadBuffer
 {
 protected:
     typedef struct gfx::SurfaceCaps SurfaceCaps;
 public:
     // Infallible, always non-null.
     static ReadBuffer* Create(GLContext* gl,
                               const SurfaceCaps& caps,
                               const GLFormats& formats,
                               SharedSurface_GL* surf);
 protected:
     GLContext* const mGL;
     const GLuint mFB;
     // mFB has the following attachments:
     const GLuint mDepthRB;
     const GLuint mStencilRB;
     // note no mColorRB here: this is provided by mSurf.
     SharedSurface_GL* mSurf; // Owned by GLScreenBuffer's SurfaceStream.
     ReadBuffer(GLContext* gl,
                GLuint fb,
                GLuint depthRB,
                GLuint stencilRB,
                SharedSurface_GL* surf)
         : mGL(gl)
         , mFB(fb)
         , mDepthRB(depthRB)
         , mStencilRB(stencilRB)
         , mSurf(surf)
     {}
 public:
     virtual ~ReadBuffer();
     // Cannot attach a surf of a different AttachType or Size than before.
     void Attach(SharedSurface_GL* surf);
     const gfx::IntSize& Size() const;
     GLuint FB() const {
         return mFB;
     }
     SharedSurface_GL* SharedSurf() const {
         return mSurf;
     }
 };
 class GLScreenBuffer
 {
 protected:
     typedef class gfx::SurfaceStream SurfaceStream;
     typedef class gfx::SharedSurface SharedSurface;
     typedef gfx::SurfaceStreamType SurfaceStreamType;
     typedef gfx::SharedSurfaceType SharedSurfaceType;
     typedef struct gfx::SurfaceCaps SurfaceCaps;
 public:
     // Infallible.
     static GLScreenBuffer* Create(GLContext* gl,
                                   const gfx::IntSize& size,
                                   const SurfaceCaps& caps);
 protected:
     GLContext* const mGL;         // Owns us.
     SurfaceCaps mCaps;
     SurfaceFactory_GL* mFactory;  // Owned by us.
     RefPtr<SurfaceStream> mStream;
     DrawBuffer* mDraw;            // Owned by us.
     ReadBuffer* mRead;            // Owned by us.
     bool mNeedsBlit;
     // Below are the parts that help us pretend to be framebuffer 0:
     GLuint mUserDrawFB;
     GLuint mUserReadFB;
     GLuint mInternalDrawFB;
     GLuint mInternalReadFB;
 #ifdef DEBUG
     bool mInInternalMode_DrawFB;
     bool mInInternalMode_ReadFB;
 #endif
     GLScreenBuffer(GLContext* gl,
                    const SurfaceCaps& caps,
                    SurfaceFactory_GL* factory,
                    SurfaceStream* stream)
         : mGL(gl)
         , mCaps(caps)
         , mFactory(factory)
         , mStream(stream)
         , mDraw(nullptr)
         , mRead(nullptr)
         , mNeedsBlit(true)
         , mUserDrawFB(0)
         , mUserReadFB(0)
         , mInternalDrawFB(0)
         , mInternalReadFB(0)
 #ifdef DEBUG
         , mInInternalMode_DrawFB(true)
         , mInInternalMode_ReadFB(true)
 #endif
     {}
 public:
     virtual ~GLScreenBuffer();
     SurfaceStream* Stream() const {
         return mStream;
     }
     SurfaceFactory_GL* Factory() const {
         return mFactory;
     }
     SharedSurface_GL* SharedSurf() const {
         MOZ_ASSERT(mRead);
         return mRead->SharedSurf();
     }
     bool PreserveBuffer() const {
         return mCaps.preserve;
     }
     const SurfaceCaps& Caps() const {
         return mCaps;
     }
     GLuint DrawFB() const {
         if (!mDraw)
             return ReadFB();
         return mDraw->FB();
     }
     GLuint ReadFB() const {
         return mRead->FB();
     }
     void DeletingFB(GLuint fb);
     const gfx::IntSize& Size() const {
         MOZ_ASSERT(mRead);
         MOZ_ASSERT(!mDraw || mDraw->Size() == mRead->Size());
         return mRead->Size();
     }
     void BindAsFramebuffer(GLContext* const gl, GLenum target) const;
     void RequireBlit();
     void AssureBlitted();
     void AfterDrawCall();
     void BeforeReadCall();
     /**
      * Attempts to read pixels from the current bound framebuffer, if
      * it is backed by a SharedSurface_GL.
      *
      * Returns true if the pixel data has been read back, false
      * otherwise.
      */
     bool ReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
                     GLenum format, GLenum type, GLvoid *pixels);
     /* Morph swaps out our SurfaceStream mechanism and replaces it with
      * one best suited to our platform and compositor configuration.
      *
      * Must be called on the producing thread.
      * We haven't made any guarantee that rendering is actually
      * done when Morph is run, just that it can't run concurrently
      * with rendering. This means that we can't just drop the contents
      * of the buffer, since we may only be partially done rendering.
      *
      * Once you pass newFactory into Morph, newFactory will be owned by
      * GLScreenBuffer, so `forget` any references to it that still exist.
      */
     void Morph(SurfaceFactory_GL* newFactory, SurfaceStreamType streamType);
 protected:
     // Returns false on error or inability to resize.
     bool Swap(const gfx::IntSize& size);
 public:
     bool PublishFrame(const gfx::IntSize& size);
     bool Resize(const gfx::IntSize& size);
     void Readback(SharedSurface_GL* src, gfx::DataSourceSurface* dest);
     void DeprecatedReadback(SharedSurface_GL* src, gfxImageSurface* dest);
 protected:
     void Attach(SharedSurface* surface, const gfx::IntSize& size);
     DrawBuffer* CreateDraw(const gfx::IntSize& size);
     ReadBuffer* CreateRead(SharedSurface_GL* surf);
 public:
     /* `fb` in these functions is the framebuffer the GLContext is hoping to
      * bind. When this is 0, we intercept the call and bind our own
      * framebuffers. As a client of these functions, just bind 0 when you want
      * to draw to the default framebuffer/'screen'.
      */
     void BindFB(GLuint fb);
     void BindDrawFB(GLuint fb);
     void BindReadFB(GLuint fb);
     GLuint GetFB() const;
     GLuint GetDrawFB() const;
     GLuint GetReadFB() const;
     // Here `fb` is the actual framebuffer you want bound. Binding 0 will
     // bind the (generally useless) default framebuffer.
     void BindDrawFB_Internal(GLuint fb);
     void BindReadFB_Internal(GLuint fb);
 };
 }   // namespace gl
 }   // namespace mozilla
 #endif  // SCREEN_BUFFER_H_

The Tor Browser / annotate

gfx/gl/GLScreenBuffer.h@97036ab72558 (annotated)

gfx/gl/GLScreenBuffer.h