Add m-esr52 at 52.6.0

1 files changed, 195 insertions, 0 deletions

diff --git a/gfx/layers/opengl/CompositingRenderTargetOGL.h b/gfx/layers/opengl/CompositingRenderTargetOGL.h
new file mode 100644
index 000000000..501701d6f
--- /dev/null
+++ b/gfx/layers/opengl/CompositingRenderTargetOGL.h
@@ -0,0 +1,195 @@
+/* -*- 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/. */
+
+#ifndef MOZILLA_GFX_COMPOSITINGRENDERTARGETOGL_H
+#define MOZILLA_GFX_COMPOSITINGRENDERTARGETOGL_H
+
+#include "GLContextTypes.h"             // for GLContext
+#include "GLDefs.h"                     // for GLenum, LOCAL_GL_FRAMEBUFFER, etc
+#include "mozilla/Assertions.h"         // for MOZ_ASSERT, etc
+#include "mozilla/Attributes.h"         // for override
+#include "mozilla/RefPtr.h"             // for RefPtr, already_AddRefed
+#include "mozilla/gfx/Point.h"          // for IntSize, IntSizeTyped
+#include "mozilla/gfx/Types.h"          // for SurfaceFormat, etc
+#include "mozilla/layers/Compositor.h"  // for SurfaceInitMode, etc
+#include "mozilla/layers/TextureHost.h" // for CompositingRenderTarget
+#include "mozilla/layers/CompositorOGL.h"  // for CompositorOGL
+#include "mozilla/mozalloc.h"           // for operator new
+#include "nsAString.h"
+#include "nsCOMPtr.h"                   // for already_AddRefed
+#include "nsDebug.h"                    // for NS_ERROR, NS_WARNING
+#include "nsString.h"                   // for nsAutoCString
+
+
+namespace mozilla {
+namespace gl {
+  class BindableTexture;
+} // namespace gl
+namespace gfx {
+  class DataSourceSurface;
+} // namespace gfx
+
+namespace layers {
+
+class TextureSource;
+
+class CompositingRenderTargetOGL : public CompositingRenderTarget
+{
+  typedef mozilla::gl::GLContext GLContext;
+
+  friend class CompositorOGL;
+
+  // For lazy initialisation of the GL stuff
+  struct InitParams
+  {
+    InitParams() : mStatus(NO_PARAMS) {}
+    InitParams(const gfx::IntSize& aSize,
+               const gfx::IntSize& aPhySize,
+               GLenum aFBOTextureTarget,
+               SurfaceInitMode aInit)
+      : mStatus(READY)
+      , mSize(aSize)
+      , mPhySize(aPhySize)
+      , mFBOTextureTarget(aFBOTextureTarget)
+      , mInit(aInit)
+    {}
+
+    enum {
+      NO_PARAMS,
+      READY,
+      INITIALIZED
+    } mStatus;
+    /*
+     * Users of render target would draw in logical size, but it is
+     * actually drawn to a surface in physical size.  GL surfaces have
+     * a limitation on their size, a smaller surface would be
+     * allocated for the render target if the caller requests in a
+     * size too big.
+     */
+    gfx::IntSize mSize; // Logical size, the expected by callers.
+    gfx::IntSize mPhySize; // Physical size, the real size of the surface.
+    GLenum mFBOTextureTarget;
+    SurfaceInitMode mInit;
+  };
+
+public:
+  CompositingRenderTargetOGL(CompositorOGL* aCompositor, const gfx::IntPoint& aOrigin,
+                             GLuint aTexure, GLuint aFBO)
+    : CompositingRenderTarget(aOrigin)
+    , mInitParams()
+    , mCompositor(aCompositor)
+    , mGL(aCompositor->gl())
+    , mTextureHandle(aTexure)
+    , mFBO(aFBO)
+  {
+    MOZ_ASSERT(mGL);
+  }
+
+  ~CompositingRenderTargetOGL();
+
+  virtual const char* Name() const override { return "CompositingRenderTargetOGL"; }
+
+  /**
+   * Create a render target around the default FBO, for rendering straight to
+   * the window.
+   */
+  static already_AddRefed<CompositingRenderTargetOGL>
+  RenderTargetForWindow(CompositorOGL* aCompositor,
+                        const gfx::IntSize& aSize)
+  {
+    RefPtr<CompositingRenderTargetOGL> result
+      = new CompositingRenderTargetOGL(aCompositor, gfx::IntPoint(), 0, 0);
+    result->mInitParams = InitParams(aSize, aSize, 0, INIT_MODE_NONE);
+    result->mInitParams.mStatus = InitParams::INITIALIZED;
+    return result.forget();
+  }
+
+  /**
+   * Some initialisation work on the backing FBO and texture.
+   * We do this lazily so that when we first set this render target on the
+   * compositor we do not have to re-bind the FBO after unbinding it, or
+   * alternatively leave the FBO bound after creation.
+   */
+  void Initialize(const gfx::IntSize& aSize,
+                  const gfx::IntSize& aPhySize,
+                  GLenum aFBOTextureTarget,
+                  SurfaceInitMode aInit)
+  {
+    MOZ_ASSERT(mInitParams.mStatus == InitParams::NO_PARAMS, "Initialized twice?");
+    // postpone initialization until we actually want to use this render target
+    mInitParams = InitParams(aSize, aPhySize, aFBOTextureTarget, aInit);
+  }
+
+  void BindTexture(GLenum aTextureUnit, GLenum aTextureTarget);
+
+  /**
+   * Call when we want to draw into our FBO
+   */
+  void BindRenderTarget();
+
+  bool IsWindow() { return GetFBO() == 0; }
+
+  GLuint GetFBO() const
+  {
+    MOZ_ASSERT(mInitParams.mStatus == InitParams::INITIALIZED);
+    return mFBO;
+  }
+
+  GLuint GetTextureHandle() const
+  {
+    MOZ_ASSERT(mInitParams.mStatus == InitParams::INITIALIZED);
+    return mTextureHandle;
+  }
+
+  // TextureSourceOGL
+  TextureSourceOGL* AsSourceOGL() override
+  {
+    // XXX - Bug 900770
+    MOZ_ASSERT(false, "CompositingRenderTargetOGL should not be used as a TextureSource");
+    return nullptr;
+  }
+  gfx::IntSize GetSize() const override
+  {
+    return mInitParams.mSize;
+  }
+
+  gfx::SurfaceFormat GetFormat() const override
+  {
+    // XXX - Should it be implemented ? is the above assert true ?
+    MOZ_ASSERT(false, "Not implemented");
+    return gfx::SurfaceFormat::UNKNOWN;
+  }
+
+#ifdef MOZ_DUMP_PAINTING
+  virtual already_AddRefed<gfx::DataSourceSurface> Dump(Compositor* aCompositor) override;
+#endif
+
+  const gfx::IntSize& GetInitSize() const {
+    return mInitParams.mSize;
+  }
+
+private:
+  /**
+   * Actually do the initialisation. Note that we leave our FBO bound, and so
+   * calling this method is only suitable when about to use this render target.
+   */
+  void InitializeImpl();
+
+  InitParams mInitParams;
+  /**
+   * There is temporary a cycle between the compositor and the render target,
+   * each having a strong ref to the other. The compositor's reference to
+   * the target is always cleared at the end of a frame.
+   */
+  RefPtr<CompositorOGL> mCompositor;
+  GLContext* mGL;
+  GLuint mTextureHandle;
+  GLuint mFBO;
+};
+
+} // namespace layers
+} // namespace mozilla
+
+#endif /* MOZILLA_GFX_SURFACEOGL_H */