Reducing code duplication between WGC3D(InProcess)CommandBufferImpl

webkit/common/gpu/webgraphicscontext3d_impl.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef WEBKIT_COMMON_GPU_WEBGRAPHICSCONTEXT3D_IN_PROCESS_COMMAND_BUFFER_IMPL_H_
-#define WEBKIT_COMMON_GPU_WEBGRAPHICSCONTEXT3D_IN_PROCESS_COMMAND_BUFFER_IMPL_H_
+#ifndef WEBKIT_COMMON_GPU_WEBGRAPHICSCONTEXT3D_IMPL_H_
+#define WEBKIT_COMMON_GPU_WEBGRAPHICSCONTEXT3D_IMPL_H_
 
+#include <string>
 #include <vector>
 
-#include "base/compiler_specific.h"
+#include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 #include "third_party/WebKit/public/platform/WebString.h"
-#include "ui/gfx/native_widget_types.h"
 #include "webkit/common/gpu/webkit_gpu_export.h"
 
 namespace gpu {
-class ContextSupport;
 
 namespace gles2 {
 class GLES2Interface;
-class GLES2Implementation;
+class GLES2ImplementationErrorMessageCallback;
 }
 }
 
 using blink::WebGLId;
 
 using blink::WGC3Dbyte;
 using blink::WGC3Dchar;
 using blink::WGC3Denum;
 using blink::WGC3Dboolean;
 using blink::WGC3Dbitfield;
 using blink::WGC3Dint;
 using blink::WGC3Dsizei;
 using blink::WGC3Duint;
 using blink::WGC3Dfloat;
 using blink::WGC3Dclampf;
 using blink::WGC3Dintptr;
 using blink::WGC3Dsizeiptr;
 
-namespace gpu {
-class GLInProcessContext;
-struct GLInProcessContextAttribs;
-}
+namespace content {

[jamesr, 2014/06/03 21:22:56]

what on earth? why are we defining symbols in namespace content:: inside
webkit/common/gpu ?

[bajones, 2014/06/03 21:25:13]

Ack! That's a mistake. (File was originally a copy of
webgraphicscontext3d_command_buffer_impl.h)

I'll upload fix ASAP. Thanks for spotting it! 

 
-namespace webkit {
-namespace gpu {
+class WebGraphicsContext3DErrorMessageCallback;
 
-class WEBKIT_GPU_EXPORT WebGraphicsContext3DInProcessCommandBufferImpl
+class WEBKIT_GPU_EXPORT WebGraphicsContext3DImpl
     : public NON_EXPORTED_BASE(blink::WebGraphicsContext3D) {
  public:
-  static scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>
-      CreateViewContext(
-          const blink::WebGraphicsContext3D::Attributes& attributes,
-          bool lose_context_when_out_of_memory,
-          gfx::AcceleratedWidget window);
-
-  static scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>
-      CreateOffscreenContext(
-          const blink::WebGraphicsContext3D::Attributes& attributes,
-          bool lose_context_when_out_of_memory);
-
-  static scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>
-      WrapContext(
-          scoped_ptr< ::gpu::GLInProcessContext> context,
-          const blink::WebGraphicsContext3D::Attributes& attributes);
-
-  virtual ~WebGraphicsContext3DInProcessCommandBufferImpl();
-
-  // Convert WebGL context creation attributes into GLInProcessContext / EGL
-  // size requests.
-  static void ConvertAttributes(
-      const blink::WebGraphicsContext3D::Attributes& attributes,
-      ::gpu::GLInProcessContextAttribs* output_attribs);
-
   //----------------------------------------------------------------------
   // WebGraphicsContext3D methods
-  virtual bool makeContextCurrent();
 
   virtual uint32_t lastFlushID();
 
-  virtual void reshapeWithScaleFactor(int width, int height, float scaleFactor);
+  virtual unsigned int insertSyncPoint();
+  virtual void waitSyncPoint(unsigned int sync_point);
+
+  virtual void loseContextCHROMIUM(WGC3Denum current, WGC3Denum other);
+
+  virtual void reshapeWithScaleFactor(
+      int width, int height, float scale_factor);
 
   virtual void prepareTexture();
   virtual void postSubBufferCHROMIUM(int x, int y, int width, int height);
 
   virtual void activeTexture(WGC3Denum texture);
   virtual void attachShader(WebGLId program, WebGLId shader);
   virtual void bindAttribLocation(WebGLId program, WGC3Duint index,
                                   const WGC3Dchar* name);
   virtual void bindBuffer(WGC3Denum target, WebGLId buffer);
   virtual void bindFramebuffer(WGC3Denum target, WebGLId framebuffer);
@@ skipping 104 matching lines @@
   virtual void getBooleanv(WGC3Denum pname, WGC3Dboolean* value);
 
   virtual void getBufferParameteriv(WGC3Denum target,
                                     WGC3Denum pname,
                                     WGC3Dint* value);
 
   virtual Attributes getContextAttributes();
 
   virtual WGC3Denum getError();
 
-  virtual bool isContextLost();
-
   virtual void getFloatv(WGC3Denum pname, WGC3Dfloat* value);
 
   virtual void getFramebufferAttachmentParameteriv(WGC3Denum target,
                                                    WGC3Denum attachment,
                                                    WGC3Denum pname,
                                                    WGC3Dint* value);
 
   virtual void getIntegerv(WGC3Denum pname, WGC3Dint* value);
 
   virtual void getProgramiv(WebGLId program, WGC3Denum pname, WGC3Dint* value);
@@ skipping 220 matching lines @@
       WGC3Denum format,
       WGC3Denum type,
       WGC3Denum access);
   virtual void unmapTexSubImage2DCHROMIUM(const void*);
 
   virtual void setVisibilityCHROMIUM(bool visible);
 
   virtual void discardFramebufferEXT(WGC3Denum target,
                                      WGC3Dsizei numAttachments,
                                      const WGC3Denum* attachments);
-
   virtual void copyTextureToParentTextureCHROMIUM(
       WebGLId texture, WebGLId parentTexture);
 
   virtual blink::WebString getRequestableExtensionsCHROMIUM();
   virtual void requestExtensionCHROMIUM(const char*);
 
   virtual void blitFramebufferCHROMIUM(
       WGC3Dint srcX0, WGC3Dint srcY0, WGC3Dint srcX1, WGC3Dint srcY1,
       WGC3Dint dstX0, WGC3Dint dstY0, WGC3Dint dstX1, WGC3Dint dstY1,
       WGC3Dbitfield mask, WGC3Denum filter);
   virtual void renderbufferStorageMultisampleCHROMIUM(
       WGC3Denum target, WGC3Dsizei samples, WGC3Denum internalformat,
       WGC3Dsizei width, WGC3Dsizei height);
 
   virtual blink::WebString getTranslatedShaderSourceANGLE(WebGLId shader);
 
   virtual void setContextLostCallback(
       WebGraphicsContext3D::WebGraphicsContextLostCallback* callback);
-  virtual WGC3Denum getGraphicsResetStatusARB();
+
+  virtual void setErrorMessageCallback(
+      WebGraphicsContext3D::WebGraphicsErrorMessageCallback* callback);
 
   virtual void texImageIOSurface2DCHROMIUM(
       WGC3Denum target, WGC3Dint width, WGC3Dint height,
       WGC3Duint ioSurfaceId, WGC3Duint plane);
 
-  virtual void bindTexImage2DCHROMIUM(WGC3Denum target, WGC3Dint imageId);
-  virtual void releaseTexImage2DCHROMIUM(WGC3Denum target, WGC3Dint imageId);
-
   virtual void texStorage2DEXT(
       WGC3Denum target, WGC3Dint levels, WGC3Duint internalformat,
       WGC3Dint width, WGC3Dint height);
-  virtual WGC3Duint createImageCHROMIUM(WGC3Dsizei width,
-                                        WGC3Dsizei height,
-                                        WGC3Denum internalformat,
-                                        WGC3Denum usage);
-  virtual void destroyImageCHROMIUM(WGC3Duint image_id);
-  virtual void getImageParameterivCHROMIUM(
-      WGC3Duint image_id, WGC3Denum pname, WGC3Dint* params);
-  virtual void* mapImageCHROMIUM(WGC3Duint image_id);
-  virtual void unmapImageCHROMIUM(WGC3Duint image_id);
+
   virtual WebGLId createQueryEXT();
   virtual void deleteQueryEXT(WebGLId query);
-  virtual WGC3Dboolean isQueryEXT(WebGLId query);
+  virtual WGC3Dboolean isQueryEXT(WGC3Duint query);
   virtual void beginQueryEXT(WGC3Denum target, WebGLId query);
   virtual void endQueryEXT(WGC3Denum target);
   virtual void getQueryivEXT(
       WGC3Denum target, WGC3Denum pname, WGC3Dint* params);
   virtual void getQueryObjectuivEXT(
       WebGLId query, WGC3Denum pname, WGC3Duint* params);
 
-  virtual void copyTextureCHROMIUM(WGC3Denum target, WGC3Duint source_id,
-                                   WGC3Duint dest_id, WGC3Dint level,
+  virtual void copyTextureCHROMIUM(WGC3Denum target, WebGLId source_id,
+                                   WebGLId dest_id, WGC3Dint level,
                                    WGC3Denum internal_format,
                                    WGC3Denum dest_type);
 
   virtual void bindUniformLocationCHROMIUM(WebGLId program, WGC3Dint location,
                                            const WGC3Dchar* uniform);
 
   virtual void shallowFlushCHROMIUM();
   virtual void shallowFinishCHROMIUM();
 
   virtual void genMailboxCHROMIUM(WGC3Dbyte* mailbox);
   virtual void produceTextureCHROMIUM(WGC3Denum target,
                                       const WGC3Dbyte* mailbox);
   virtual void consumeTextureCHROMIUM(WGC3Denum target,
                                       const WGC3Dbyte* mailbox);
 
   virtual void insertEventMarkerEXT(const WGC3Dchar* marker);
   virtual void pushGroupMarkerEXT(const WGC3Dchar* marker);
   virtual void popGroupMarkerEXT();
 
+  // GL_OES_vertex_array_object
+  virtual WebGLId createVertexArrayOES();
+  virtual void deleteVertexArrayOES(WebGLId array);
+  virtual WGC3Dboolean isVertexArrayOES(WebGLId array);
+  virtual void bindVertexArrayOES(WebGLId array);
+
+  virtual void bindTexImage2DCHROMIUM(WGC3Denum target, WGC3Dint image_id);
+  virtual void releaseTexImage2DCHROMIUM(WGC3Denum target, WGC3Dint image_id);
+
   virtual void* mapBufferCHROMIUM(WGC3Denum target, WGC3Denum access);
   virtual WGC3Dboolean unmapBufferCHROMIUM(WGC3Denum target);
 
-  virtual void framebufferTexture2DMultisampleEXT(WGC3Denum target,
-                                                  WGC3Denum attachment,
-                                                  WGC3Denum textarget,
-                                                  WebGLId texture,
-                                                  WGC3Dint level,
-                                                  WGC3Dsizei samples);
-  virtual void renderbufferStorageMultisampleEXT(WGC3Denum target,
-                                                 WGC3Dsizei samples,
-                                                 WGC3Denum internalformat,
-                                                 WGC3Dsizei width,
-                                                 WGC3Dsizei height);
-
-
   // Async pixel transfer functions.
   virtual void asyncTexImage2DCHROMIUM(
       WGC3Denum target,
       WGC3Dint level,
       WGC3Denum internalformat,
       WGC3Dsizei width,
       WGC3Dsizei height,
       WGC3Dint border,
       WGC3Denum format,
       WGC3Denum type,
       const void* pixels);
   virtual void asyncTexSubImage2DCHROMIUM(
       WGC3Denum target,
       WGC3Dint level,
       WGC3Dint xoffset,
       WGC3Dint yoffset,
       WGC3Dsizei width,
       WGC3Dsizei height,
       WGC3Denum format,
       WGC3Denum type,
       const void* pixels);
   virtual void waitAsyncTexImage2DCHROMIUM(WGC3Denum target);
 
-  virtual void drawBuffersEXT(WGC3Dsizei n, const WGC3Denum* bufs);
+  // GL_EXT_draw_buffers
+  virtual void drawBuffersEXT(
+      WGC3Dsizei n,
+      const WGC3Denum* bufs);
 
-  virtual unsigned insertSyncPoint();
+  // GL_ANGLE_instanced_arrays
+  virtual void drawArraysInstancedANGLE(WGC3Denum mode, WGC3Dint first,
+      WGC3Dsizei count, WGC3Dsizei primcount);
+  virtual void drawElementsInstancedANGLE(WGC3Denum mode, WGC3Dsizei count,
+      WGC3Denum type, WGC3Dintptr offset, WGC3Dsizei primcount);
+  virtual void vertexAttribDivisorANGLE(WGC3Duint index, WGC3Duint divisor);
 
-  virtual void loseContextCHROMIUM(WGC3Denum current, WGC3Denum other);
+  // GL_CHROMIUM_map_image
+  virtual WGC3Duint createImageCHROMIUM(WGC3Dsizei width,
+                                        WGC3Dsizei height,
+                                        WGC3Denum internalformat,
+                                        WGC3Denum usage);
+  virtual void destroyImageCHROMIUM(WGC3Duint image_id);
+  virtual void getImageParameterivCHROMIUM(
+      WGC3Duint image_id, WGC3Denum pname, WGC3Dint* params);
+  virtual void* mapImageCHROMIUM(WGC3Duint image_id);
+  virtual void unmapImageCHROMIUM(WGC3Duint image_id);
+
+  // GL_EXT_multisampled_render_to_texture
+  virtual void framebufferTexture2DMultisampleEXT(WGC3Denum target,
+                                    WGC3Denum attachment,
+                                    WGC3Denum textarget,
+                                    WebGLId texture,
+                                    WGC3Dint level,
+                                    WGC3Dsizei samples);
+  virtual void renderbufferStorageMultisampleEXT(
+      WGC3Denum target, WGC3Dsizei samples, WGC3Denum internalformat,
+      WGC3Dsizei width, WGC3Dsizei height);
 
   virtual GrGLInterface* createGrGLInterface();
 
-  ::gpu::gles2::GLES2Interface* GetGLInterface();
-  ::gpu::ContextSupport* GetContextSupport();
-
-  ::gpu::gles2::GLES2Implementation* GetImplementation() {
+  gpu::gles2::GLES2Interface* GetGLInterface() {
     return gl_;
   }
 
- private:
-  WebGraphicsContext3DInProcessCommandBufferImpl(
-      scoped_ptr< ::gpu::GLInProcessContext> context,
-      const blink::WebGraphicsContext3D::Attributes& attributes,
-      bool lose_context_when_out_of_memory,
-      bool is_offscreen,
-      gfx::AcceleratedWidget window);
+ protected:
+  friend class WebGraphicsContext3DErrorMessageCallback;
 
-  void OnContextLost();
+  WebGraphicsContext3DImpl(
+      const Attributes& attributes,
+      bool lose_context_when_out_of_memory);
+  virtual ~WebGraphicsContext3DImpl();
 
-  bool MaybeInitializeGL();
+  gpu::gles2::GLES2ImplementationErrorMessageCallback*
+      getErrorMessageCallback();
+  virtual void OnErrorMessage(const std::string& message, int id);
 
-  // Used to try to find bugs in code that calls gl directly through the gl api
-  // instead of going through WebGraphicsContext3D.
-  void ClearContext();
-
-  bool is_offscreen_;
-  // Only used when not offscreen.
-  gfx::AcceleratedWidget window_;
+  void setGLInterface(gpu::gles2::GLES2Interface* gl) {
+    gl_ = gl;
+  }
 
   bool initialized_;
   bool initialize_failed_;
 
-  // The context we use for OpenGL rendering.
-  scoped_ptr< ::gpu::GLInProcessContext> context_;
-  // The GLES2Implementation we use for OpenGL rendering.
-  ::gpu::gles2::GLES2Implementation* gl_;
-
   WebGraphicsContext3D::WebGraphicsContextLostCallback* context_lost_callback_;
   WGC3Denum context_lost_reason_;
 
+  WebGraphicsContext3D::WebGraphicsErrorMessageCallback*
+      error_message_callback_;
+  scoped_ptr<WebGraphicsContext3DErrorMessageCallback>
+      client_error_message_callback_;
+
   blink::WebGraphicsContext3D::Attributes attributes_;
-  bool lose_context_when_out_of_memory_;
 
   // Errors raised by synthesizeGLError().
   std::vector<WGC3Denum> synthetic_errors_;
 
+  gpu::gles2::GLES2Interface* gl_;
+  bool lose_context_when_out_of_memory_;
   uint32_t flush_id_;
 };
 
-}  // namespace gpu
-}  // namespace webkit
+}  // namespace content
 
-#endif  // WEBKIT_COMMON_GPU_WEBGRAPHICSCONTEXT3D_IN_PROCESS_COMMAND_BUFFER_IMPL_H_
+#endif  // WEBKIT_COMMON_GPU_WEBGRAPHICSCONTEXT3D_IMPL_H_