reflow comments in modules/webgl

third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.h

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 666 matching lines @@
   // to the back-buffer of m_context.
   RefPtr<DrawingBuffer> m_drawingBuffer;
   DrawingBuffer* drawingBuffer() const;
 
   RefPtr<WebGLContextGroup> m_contextGroup;
 
   bool m_isHidden;
   LostContextMode m_contextLostMode;
   AutoRecoveryMethod m_autoRecoveryMethod;
   // Dispatches a context lost event once it is determined that one is needed.
-  // This is used for synthetic, WEBGL_lose_context and real context losses. For real ones, it's
-  // likely that there's no JavaScript on the stack, but that might be dependent
-  // on how exactly the platform discovers that the context was lost. For better
-  // portability we always defer the dispatch of the event.
+  // This is used for synthetic, WEBGL_lose_context and real context losses. For
+  // real ones, it's likely that there's no JavaScript on the stack, but that
+  // might be dependent on how exactly the platform discovers that the context
+  // was lost. For better portability we always defer the dispatch of the event.
   Timer<WebGLRenderingContextBase> m_dispatchContextLostEventTimer;
   bool m_restoreAllowed;
   Timer<WebGLRenderingContextBase> m_restoreTimer;
 
   bool m_markedCanvasDirty;
   HeapHashSet<WeakMember<WebGLContextObject>> m_contextObjects;
 
-  // List of bound VBO's. Used to maintain info about sizes for ARRAY_BUFFER and stored values for ELEMENT_ARRAY_BUFFER
+  // List of bound VBO's. Used to maintain info about sizes for ARRAY_BUFFER and
+  // stored values for ELEMENT_ARRAY_BUFFER
   Member<WebGLBuffer> m_boundArrayBuffer;
 
   Member<WebGLVertexArrayObjectBase> m_defaultVertexArrayObject;
   Member<WebGLVertexArrayObjectBase> m_boundVertexArrayObject;
   void setBoundVertexArrayObject(WebGLVertexArrayObjectBase*);
 
   enum VertexAttribValueType {
     Float32ArrayType,
     Int32ArrayType,
     Uint32ArrayType,
@@ skipping 53 matching lines @@
   GLfloat m_clearColor[4];
   bool m_scissorEnabled;
   GLfloat m_clearDepth;
   GLint m_clearStencil;
   GLboolean m_colorMask[4];
   GLboolean m_depthMask;
 
   bool m_stencilEnabled;
   GLuint m_stencilMask, m_stencilMaskBack;
   GLint m_stencilFuncRef,
-      m_stencilFuncRefBack;  // Note that these are the user specified values, not the internal clamped value.
+      m_stencilFuncRefBack;  // Note that these are the user specified values,
+                             // not the internal clamped value.
   GLuint m_stencilFuncMask, m_stencilFuncMaskBack;
 
   bool m_isDepthStencilSupported;
 
   bool m_synthesizedErrorsToConsole;
   int m_numGLErrorsToConsoleAllowed;
 
   unsigned long m_onePlusMaxNonDefaultTextureUnit;
 
   std::unique_ptr<Extensions3DUtil> m_extensionsUtil;
@@ skipping 93 matching lines @@
     m_extensions.append(
         TypedExtensionTracker<T>::create(extensionPtr, flags, prefixes));
   }
 
   bool extensionSupportedAndAllowed(const ExtensionTracker*);
 
   inline bool extensionEnabled(WebGLExtensionName name) {
     return m_extensionEnabled[name];
   }
 
-  // ScopedDrawingBufferBinder is used for ReadPixels/CopyTexImage2D/CopySubImage2D to read from
-  // a multisampled DrawingBuffer. In this situation, we need to blit to a single sampled buffer
-  // for reading, during which the bindings could be changed and need to be recovered.
+  // ScopedDrawingBufferBinder is used for
+  // ReadPixels/CopyTexImage2D/CopySubImage2D to read from a multisampled
+  // DrawingBuffer. In this situation, we need to blit to a single sampled
+  // buffer for reading, during which the bindings could be changed and need to
+  // be recovered.
   class ScopedDrawingBufferBinder {
     STACK_ALLOCATED();
 
    public:
     ScopedDrawingBufferBinder(DrawingBuffer* drawingBuffer,
                               WebGLFramebuffer* framebufferBinding)
         : m_drawingBuffer(drawingBuffer),
           m_readFramebufferBinding(framebufferBinding) {
       // Commit DrawingBuffer if needed (e.g., for multisampling)
       if (!m_readFramebufferBinding && m_drawingBuffer)
@@ skipping 36 matching lines @@
   ScriptValue getBooleanParameter(ScriptState*, GLenum);
   ScriptValue getBooleanArrayParameter(ScriptState*, GLenum);
   ScriptValue getFloatParameter(ScriptState*, GLenum);
   ScriptValue getIntParameter(ScriptState*, GLenum);
   ScriptValue getInt64Parameter(ScriptState*, GLenum);
   ScriptValue getUnsignedIntParameter(ScriptState*, GLenum);
   ScriptValue getWebGLFloatArrayParameter(ScriptState*, GLenum);
   ScriptValue getWebGLIntArrayParameter(ScriptState*, GLenum);
 
   // Clear the backbuffer if it was composited since the last operation.
-  // clearMask is set to the bitfield of any clear that would happen anyway at this time
-  // and the function returns |CombinedClear| if that clear is now unnecessary.
+  // clearMask is set to the bitfield of any clear that would happen anyway at
+  // this time and the function returns |CombinedClear| if that clear is now
+  // unnecessary.
   enum HowToClear {
     // Skip clearing the backbuffer.
     Skipped,
     // Clear the backbuffer.
     JustClear,
     // Combine webgl.clear() API with the backbuffer clear, so webgl.clear()
     // doesn't have to call glClear() again.
     CombinedClear
   };
   HowToClear clearIfComposited(GLbitfield clearMask = 0);
@@ skipping 38 matching lines @@
                     GLint xoffset,
                     GLint yoffset,
                     GLint zoffset,
                     GLenum format,
                     GLenum type,
                     Image*,
                     WebGLImageConversion::ImageHtmlDomSource,
                     bool flipY,
                     bool premultiplyAlpha);
 
-  // Copy from the source directly to the texture via the gpu, without a read-back to system memory.
-  // Souce could be canvas or imageBitmap.
+  // Copy from the source directly to the texture via the gpu, without a
+  // read-back to system memory.  Souce could be canvas or imageBitmap.
   void texImageByGPU(TexImageByGPUType,
                      WebGLTexture*,
                      GLenum target,
                      GLint level,
                      GLint internalformat,
                      GLenum type,
                      GLint xoffset,
                      GLint yoffset,
                      GLint zoffset,
                      CanvasImageSource*);
   virtual bool canUseTexImageByGPU(TexImageFunctionID,
                                    GLint internalformat,
                                    GLenum type);
 
   virtual WebGLImageConversion::PixelStoreParams getPackPixelStoreParams();
   virtual WebGLImageConversion::PixelStoreParams getUnpackPixelStoreParams(
       TexImageDimension);
 
   // Helper function for copyTex{Sub}Image, check whether the internalformat
   // and the color buffer format of the current bound framebuffer combination
   // is valid.
   bool isTexInternalFormatColorBufferCombinationValid(GLenum texInternalFormat,
                                                       GLenum colorBufferFormat);
 
-  // Helper function to verify limits on the length of uniform and attribute locations.
+  // Helper function to verify limits on the length of uniform and attribute
+  // locations.
   virtual unsigned getMaxWebGLLocationLength() const { return 256; }
   bool validateLocationLength(const char* functionName, const String&);
 
   // Helper function to check if size is non-negative.
-  // Generate GL error and return false for negative inputs; otherwise, return true.
+  // Generate GL error and return false for negative inputs; otherwise, return
+  // true.
   bool validateSize(const char* functionName, GLint x, GLint y, GLint z = 0);
 
   // Helper function to check if all characters in the string belong to the
   // ASCII subset as defined in GLSL ES 1.0 spec section 3.1.
   bool validateString(const char* functionName, const String&);
 
-  // Helper function to check if all characters in the shader source belong to the ASCII
-  // subset as defined in GLSL ES 1.0 spec section 3.1 Character Set for WebGL 1.0 and
-  // in GLSL ES 3.00 spec section 3.1 Character Set for WebGL 2.0.
+  // Helper function to check if all characters in the shader source belong to
+  // the ASCII subset as defined in GLSL ES 1.0 spec section 3.1 Character Set
+  // for WebGL 1.0 and in GLSL ES 3.00 spec section 3.1 Character Set for WebGL
+  // 2.0.
   bool validateShaderSource(const String&);
 
-  // Helper function to check texture binding target and texture bound to the target.
-  // Generate GL errors and return 0 if target is invalid or texture bound is
-  // null.  Otherwise, return the texture bound to the target.
+  // Helper function to check texture binding target and texture bound to the
+  // target.  Generate GL errors and return 0 if target is invalid or texture
+  // bound is null.  Otherwise, return the texture bound to the target.
   WebGLTexture* validateTextureBinding(const char* functionName, GLenum target);
 
-  // Wrapper function for validateTexture2D(3D)Binding, used in texImageHelper functions.
+  // Wrapper function for validateTexture2D(3D)Binding, used in texImageHelper
+  // functions.
   virtual WebGLTexture* validateTexImageBinding(const char*,
                                                 TexImageFunctionID,
                                                 GLenum);
 
   // Helper function to check texture 2D target and texture bound to the target.
   // Generate GL errors and return 0 if target is invalid or texture bound is
   // null.  Otherwise, return the texture bound to the target.
   WebGLTexture* validateTexture2DBinding(const char* functionName,
                                          GLenum target);
 
   void addExtensionSupportedFormatsTypes();
 
-  // Helper function to check input internalformat/format/type for functions Tex{Sub}Image taking TexImageSource source data.
-  // Generates GL error and returns false if parameters are invalid.
+  // Helper function to check input internalformat/format/type for functions
+  // Tex{Sub}Image taking TexImageSource source data.  Generates GL error and
+  // returns false if parameters are invalid.
   bool validateTexImageSourceFormatAndType(const char* functionName,
                                            TexImageFunctionType,
                                            GLenum internalformat,
                                            GLenum format,
                                            GLenum type);
 
-  // Helper function to check input internalformat/format/type for functions Tex{Sub}Image.
-  // Generates GL error and returns false if parameters are invalid.
+  // Helper function to check input internalformat/format/type for functions
+  // Tex{Sub}Image.  Generates GL error and returns false if parameters are
+  // invalid.
   bool validateTexFuncFormatAndType(const char* functionName,
                                     TexImageFunctionType,
                                     GLenum internalformat,
                                     GLenum format,
                                     GLenum type,
                                     GLint level);
 
   // Helper function to check readbuffer validity for copyTex{Sub}Image.
   // If yes, obtains the bound read framebuffer, returns true.
   // If not, generates a GL error, returns false.
   bool validateReadBufferAndGetInfo(const char* functionName,
                                     WebGLFramebuffer*& readFramebufferBinding);
 
-  // Helper function to check format/type and ArrayBuffer view type for readPixels.
+  // Helper function to check format/type and ArrayBuffer view type for
+  // readPixels.
   // Generates INVALID_ENUM and returns false if parameters are invalid.
-  // Generates INVALID_OPERATION if ArrayBuffer view type is incompatible with type.
+  // Generates INVALID_OPERATION if ArrayBuffer view type is incompatible with
+  // type.
   virtual bool validateReadPixelsFormatAndType(GLenum format,
                                                GLenum type,
                                                DOMArrayBufferView*);
 
-  // Helper function to check parameters of readPixels. Returns true if all parameters
-  // are valid. Otherwise, generates appropriate error and returns false.
+  // Helper function to check parameters of readPixels. Returns true if all
+  // parameters are valid. Otherwise, generates appropriate error and returns
+  // false.
   bool validateReadPixelsFuncParameters(GLsizei width,
                                         GLsizei height,
                                         GLenum format,
                                         GLenum type,
                                         DOMArrayBufferView*,
                                         long long bufferSize);
 
   virtual GLint getMaxTextureLevelForTarget(GLenum target);
 
   // Helper function to check input level for functions {copy}Tex{Sub}Image.
   // Generates GL error and returns false if level is invalid.
   bool validateTexFuncLevel(const char* functionName,
                             GLenum target,
                             GLint level);
 
-  // Helper function to check if a 64-bit value is non-negative and can fit into a 32-bit integer.
-  // Generates GL error and returns false if not.
+  // Helper function to check if a 64-bit value is non-negative and can fit into
+  // a 32-bit integer.  Generates GL error and returns false if not.
   bool validateValueFitNonNegInt32(const char* functionName,
                                    const char* paramName,
                                    long long value);
 
   enum TexFuncValidationSourceType {
     SourceArrayBufferView,
     SourceImageData,
     SourceHTMLImageElement,
     SourceHTMLCanvasElement,
     SourceHTMLVideoElement,
     SourceImageBitmap,
     SourceUnpackBuffer,
   };
 
-  // Helper function for tex{Sub}Image{2|3}D to check if the input format/type/level/target/width/height/depth/border/xoffset/yoffset/zoffset are valid.
-  // Otherwise, it would return quickly without doing other work.
+  // Helper function for tex{Sub}Image{2|3}D to check if the input
+  // format/type/level/target/width/height/depth/border/xoffset/yoffset/zoffset
+  // are valid.  Otherwise, it would return quickly without doing other work.
   bool validateTexFunc(const char* functionName,
                        TexImageFunctionType,
                        TexFuncValidationSourceType,
                        GLenum target,
                        GLint level,
                        GLenum internalformat,
                        GLsizei width,
                        GLsizei height,
                        GLsizei depth,
                        GLint border,
                        GLenum format,
                        GLenum type,
                        GLint xoffset,
                        GLint yoffset,
                        GLint zoffset);
 
-  // Helper function to check input width and height for functions {copy, compressed}Tex{Sub}Image.
-  // Generates GL error and returns false if width or height is invalid.
+  // Helper function to check input width and height for functions {copy,
+  // compressed}Tex{Sub}Image.  Generates GL error and returns false if width or
+  // height is invalid.
   bool validateTexFuncDimensions(const char* functionName,
                                  TexImageFunctionType,
                                  GLenum target,
                                  GLint level,
                                  GLsizei width,
                                  GLsizei height,
                                  GLsizei depth);
 
-  // Helper function to check input parameters for functions {copy}Tex{Sub}Image.
-  // Generates GL error and returns false if parameters are invalid.
+  // Helper function to check input parameters for functions
+  // {copy}Tex{Sub}Image.  Generates GL error and returns false if parameters
+  // are invalid.
   bool validateTexFuncParameters(const char* functionName,
                                  TexImageFunctionType,
                                  TexFuncValidationSourceType,
                                  GLenum target,
                                  GLint level,
                                  GLenum internalformat,
                                  GLsizei width,
                                  GLsizei height,
                                  GLsizei depth,
                                  GLint border,
@@ skipping 22 matching lines @@
   // copyTexSubImage2D.
   // Generates GL error and returns false if the format is not settable.
   bool validateSettableTexFormat(const char* functionName, GLenum format);
 
   // Helper function to validate format for CopyTexImage.
   bool validateCopyTexFormat(const char* functionName, GLenum format);
 
   // Helper function for validating compressed texture formats.
   bool validateCompressedTexFormat(const char* functionName, GLenum format);
 
-  // Helper function to validate if front/back stencilMask and stencilFunc settings are the same.
+  // Helper function to validate if front/back stencilMask and stencilFunc
+  // settings are the same.
   bool validateStencilSettings(const char* functionName);
 
   // Helper function to validate stencil or depth func.
   bool validateStencilOrDepthFunc(const char* functionName, GLenum);
 
   // Helper function for texParameterf and texParameteri.
   void texParameter(GLenum target,
                     GLenum pname,
                     GLfloat paramf,
                     GLint parami,
                     bool isFloat);
 
   // Helper function to print GL errors to console.
   void printGLErrorToConsole(const String&);
 
   // Helper function to print warnings to console. Currently
   // used only to warn about use of obsolete functions.
   void printWarningToConsole(const String&);
 
-  // Helper function to validate the target for checkFramebufferStatus and validateFramebufferFuncParameters.
+  // Helper function to validate the target for checkFramebufferStatus and
+  // validateFramebufferFuncParameters.
   virtual bool validateFramebufferTarget(GLenum target);
 
   // Get the framebuffer bound to given target
   virtual WebGLFramebuffer* getFramebufferBinding(GLenum target);
 
   virtual WebGLFramebuffer* getReadFramebufferBinding();
 
   // Helper function to validate input parameters for framebuffer functions.
   // Generate GL error if parameters are illegal.
   bool validateFramebufferFuncParameters(const char* functionName,
@@ skipping 45 matching lines @@
       GLsizei requiredMinSize) {
     if (!v.dataMaybeOnStack()) {
       synthesizeGLError(GL_INVALID_VALUE, functionName, "no array");
       return false;
     }
     return validateUniformMatrixParameters(functionName, location, false,
                                            v.dataMaybeOnStack(), v.length(),
                                            requiredMinSize);
   }
 
-  // Helper function to validate the target for bufferData and getBufferParameter.
+  // Helper function to validate the target for bufferData and
+  // getBufferParameter.
   virtual bool validateBufferTarget(const char* functionName, GLenum target);
 
   // Helper function to validate the target for bufferData.
   // Return the current bound buffer to target, or 0 if the target is invalid.
   virtual WebGLBuffer* validateBufferDataTarget(const char* functionName,
                                                 GLenum target);
   // Helper function to validate the usage for bufferData.
   virtual bool validateBufferDataUsage(const char* functionName, GLenum usage);
 
   virtual bool validateAndUpdateBufferBindTarget(const char* functionName,
                                                  GLenum target,
                                                  WebGLBuffer*);
 
   virtual void removeBoundBuffer(WebGLBuffer*);
 
-  // Helper function for tex{Sub}Image2D to make sure image is ready and wouldn't taint Origin.
+  // Helper function for tex{Sub}Image2D to make sure image is ready and
+  // wouldn't taint Origin.
   bool validateHTMLImageElement(const char* functionName,
                                 HTMLImageElement*,
                                 ExceptionState&);
 
-  // Helper function for tex{Sub}Image2D to make sure canvas is ready and wouldn't taint Origin.
+  // Helper function for tex{Sub}Image2D to make sure canvas is ready and
+  // wouldn't taint Origin.
   bool validateHTMLCanvasElement(const char* functionName,
                                  HTMLCanvasElement*,
                                  ExceptionState&);
 
-  // Helper function for tex{Sub}Image2D to make sure video is ready wouldn't taint Origin.
+  // Helper function for tex{Sub}Image2D to make sure video is ready wouldn't
+  // taint Origin.
   bool validateHTMLVideoElement(const char* functionName,
                                 HTMLVideoElement*,
                                 ExceptionState&);
 
-  // Helper function for tex{Sub}Image2D to make sure imagebitmap is ready and wouldn't taint Origin.
+  // Helper function for tex{Sub}Image2D to make sure imagebitmap is ready and
+  // wouldn't taint Origin.
   bool validateImageBitmap(const char* functionName,
                            ImageBitmap*,
                            ExceptionState&);
 
   // Helper function to validate drawArrays(Instanced) calls
   bool validateDrawArrays(const char* functionName);
 
   // Helper function to validate drawElements(Instanced) calls
   bool validateDrawElements(const char* functionName,
                             GLenum type,
@@ skipping 39 matching lines @@
   // Enable or disable stencil test based on user setting and
   // whether the current FBO has a stencil buffer.
   void applyStencilTest();
 
   // Helper for enabling or disabling a capability.
   void enableOrDisable(GLenum capability, bool enable);
 
   // Clamp the width and height to GL_MAX_VIEWPORT_DIMS.
   IntSize clampedCanvasSize() const;
 
-  // First time called, if EXT_draw_buffers is supported, query the value; otherwise return 0.
-  // Later, return the cached value.
+  // First time called, if EXT_draw_buffers is supported, query the value;
+  // otherwise return 0.  Later, return the cached value.
   GLint maxDrawBuffers();
   GLint maxColorAttachments();
 
   void setBackDrawBuffer(GLenum);
   void setFramebuffer(GLenum, WebGLFramebuffer*);
 
   virtual void restoreCurrentFramebuffer();
   void restoreCurrentTexture2D();
 
   void findNewMaxNonDefaultTextureUnit();
 
   virtual void renderbufferStorageImpl(GLenum target,
                                        GLsizei samples,
                                        GLenum internalformat,
                                        GLsizei width,
                                        GLsizei height,
                                        const char* functionName);
 
   friend class WebGLStateRestorer;
   friend class WebGLRenderingContextEvictionManager;
 
   static void activateContext(WebGLRenderingContextBase*);
   static void deactivateContext(WebGLRenderingContextBase*);
   static void addToEvictedList(WebGLRenderingContextBase*);
   static void removeFromEvictedList(WebGLRenderingContextBase*);
   static void willDestroyContext(WebGLRenderingContextBase*);
   static void forciblyLoseOldestContext(const String& reason);
-  // Return the least recently used context's position in the active context vector.
-  // If the vector is empty, return the maximum allowed active context number.
+  // Return the least recently used context's position in the active context
+  // vector.  If the vector is empty, return the maximum allowed active context
+  // number.
   static WebGLRenderingContextBase* oldestContext();
   static WebGLRenderingContextBase* oldestEvictedContext();
 
   ImageBitmap* transferToImageBitmapBase();
 
   // Helper functions for tex(Sub)Image2D && texSubImage3D
   void texImageHelperDOMArrayBufferView(TexImageFunctionID,
                                         GLenum,
                                         GLint,
                                         GLint,
@@ skipping 91 matching lines @@
                   context,
                   context->is3d(),
                   context.is3d());
 
 }  // namespace blink
 
 WTF_ALLOW_MOVE_INIT_AND_COMPARE_WITH_MEM_FUNCTIONS(
     blink::WebGLRenderingContextBase::TextureUnitState);
 
 #endif  // WebGLRenderingContextBase_h