Fixed docs for webGL method variants (overloaded methods were getting the same comments).

sdk/lib/web_gl/dart2js/web_gl_dart2js.dart

 /**
  * 3D programming in the browser.
  */
 library dart.dom.web_gl;
 
 import 'dart:collection';
 import 'dart:_internal' hide deprecated;
 import 'dart:html';
 import 'dart:html_common';
 import 'dart:_native_typed_data';
@@ skipping 2216 matching lines @@
   void blendFunc(int sfactor, int dfactor) native;
 
   @DomName('WebGLRenderingContext.blendFuncSeparate')
   @DocsEditable()
   void blendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) native;
 
   @JSName('bufferData')
   /**
    * Buffers the specified data.
    *
-   * This specific method is provided for WebGL API compatibility reasons, but
+   * The [bufferData] method is provided for WebGL API compatibility reasons, but
    * it is highly recommended that you use [bufferDataTyped] or [bufferByteData]
    * depending on your purposes.
    */
   @DomName('WebGLRenderingContext.bufferData')
   @DocsEditable()
   void bufferByteData(int target, ByteBuffer data, int usage) native;
 
   /**
    * Buffers the specified data.
    *
-   * This specific method is provided for WebGL API compatibility reasons, but
+   * The [bufferData] method is provided for WebGL API compatibility reasons, but
    * it is highly recommended that you use [bufferDataTyped] or [bufferByteData]
    * depending on your purposes.
    */
   @DomName('WebGLRenderingContext.bufferData')
   @DocsEditable()
   void bufferData(int target, data_OR_size, int usage) native;
 
   @JSName('bufferData')
   /**
    * Buffers the specified data.
    *
-   * This specific method is provided for WebGL API compatibility reasons, but
+   * The [bufferData] method is provided for WebGL API compatibility reasons, but
    * it is highly recommended that you use [bufferDataTyped] or [bufferByteData]
    * depending on your purposes.
    */
   @DomName('WebGLRenderingContext.bufferData')
   @DocsEditable()
   void bufferDataTyped(int target, TypedData data, int usage) native;
 
   @JSName('bufferSubData')
   /**
    * Buffers the specified subset of data.
    *
-   * This specific method is provided for WebGL API compatibility reasons, but
+   * The [bufferSubData] method is provided for WebGL API compatibility reasons, but
    * it is highly recommended that you use [bufferSubDataTyped] or [bufferSubByteData]
    * depending on your purposes.
    */
   @DomName('WebGLRenderingContext.bufferSubData')
   @DocsEditable()
   void bufferSubByteData(int target, int offset, ByteBuffer data) native;
 
   /**
    * Buffers the specified subset of data.
    *
-   * This specific method is provided for WebGL API compatibility reasons, but
+   * The [bufferSubData] method is provided for WebGL API compatibility reasons, but
    * it is highly recommended that you use [bufferSubDataTyped] or [bufferSubByteData]
    * depending on your purposes.
    */
   @DomName('WebGLRenderingContext.bufferSubData')
   @DocsEditable()
   void bufferSubData(int target, int offset, data) native;
 
   @JSName('bufferSubData')
   /**
    * Buffers the specified subset of data.
    *
-   * This specific method is provided for WebGL API compatibility reasons, but
+   * The [bufferSubData] method is provided for WebGL API compatibility reasons, but
    * it is highly recommended that you use [bufferSubDataTyped] or [bufferSubByteData]
    * depending on your purposes.
    */
   @DomName('WebGLRenderingContext.bufferSubData')
   @DocsEditable()
   void bufferSubDataTyped(int target, int offset, TypedData data) native;
 
   @DomName('WebGLRenderingContext.checkFramebufferStatus')
   @DocsEditable()
   int checkFramebufferStatus(int target) native;
@@ skipping 364 matching lines @@
   @DocsEditable()
   void stencilOp(int fail, int zfail, int zpass) native;
 
   @DomName('WebGLRenderingContext.stencilOpSeparate')
   @DocsEditable()
   void stencilOpSeparate(int face, int fail, int zfail, int zpass) native;
 
   /**
    * Updates the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texImage2DUntyped] or [texImage2DTyped]
    * (or for more specificity, the more specialized [texImage2DImageData],
    * [texImage2DCanvas], [texImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texImage2D')
   @DocsEditable()
   void texImage2D(int target, int level, int internalformat, int format_OR_width, int height_OR_type, border_OR_canvas_OR_image_OR_pixels_OR_video, [int format, int type, TypedData pixels]) {
     if (pixels != null && type != null && format != null && (border_OR_canvas_OR_image_OR_pixels_OR_video is int || border_OR_canvas_OR_image_OR_pixels_OR_video == null)) {
       _texImage2D_1(target, level, internalformat, format_OR_width, height_OR_type, border_OR_canvas_OR_image_OR_pixels_OR_video, format, type, pixels);
       return;
@@ skipping 14 matching lines @@
     if ((border_OR_canvas_OR_image_OR_pixels_OR_video is VideoElement || border_OR_canvas_OR_image_OR_pixels_OR_video == null) && format == null && type == null && pixels == null) {
       _texImage2D_5(target, level, internalformat, format_OR_width, height_OR_type, border_OR_canvas_OR_image_OR_pixels_OR_video);
       return;
     }
     throw new ArgumentError("Incorrect number or type of arguments");
   }
   @JSName('texImage2D')
   /**
    * Updates the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texImage2DUntyped] or [texImage2DTyped]
    * (or for more specificity, the more specialized [texImage2DImageData],
    * [texImage2DCanvas], [texImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texImage2D')
   @DocsEditable()
   void _texImage2D_1(target, level, internalformat, width, height, int border, format, type, TypedData pixels) native;
   @JSName('texImage2D')
   /**
    * Updates the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texImage2DUntyped] or [texImage2DTyped]
    * (or for more specificity, the more specialized [texImage2DImageData],
    * [texImage2DCanvas], [texImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texImage2D')
   @DocsEditable()
   void _texImage2D_2(target, level, internalformat, format, type, pixels) native;
   @JSName('texImage2D')
   /**
    * Updates the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texImage2DUntyped] or [texImage2DTyped]
    * (or for more specificity, the more specialized [texImage2DImageData],
    * [texImage2DCanvas], [texImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texImage2D')
   @DocsEditable()
   void _texImage2D_3(target, level, internalformat, format, type, ImageElement image) native;
   @JSName('texImage2D')
   /**
    * Updates the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texImage2DUntyped] or [texImage2DTyped]
    * (or for more specificity, the more specialized [texImage2DImageData],
    * [texImage2DCanvas], [texImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texImage2D')
   @DocsEditable()
   void _texImage2D_4(target, level, internalformat, format, type, CanvasElement canvas) native;
   @JSName('texImage2D')
   /**
    * Updates the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texImage2DUntyped] or [texImage2DTyped]
    * (or for more specificity, the more specialized [texImage2DImageData],
    * [texImage2DCanvas], [texImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texImage2D')
   @DocsEditable()
   void _texImage2D_5(target, level, internalformat, format, type, VideoElement video) native;
 
   @JSName('texImage2D')
   /**
    * Updates the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texImage2DUntyped] or [texImage2DTyped]
    * (or for more specificity, the more specialized [texImage2DImageData],
    * [texImage2DCanvas], [texImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texImage2D')
   @DocsEditable()
   void texImage2DCanvas(int target, int level, int internalformat, int format, int type, CanvasElement canvas) native;
 
   @JSName('texImage2D')
   /**
    * Updates the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texImage2DUntyped] or [texImage2DTyped]
    * (or for more specificity, the more specialized [texImage2DImageData],
    * [texImage2DCanvas], [texImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texImage2D')
   @DocsEditable()
   void texImage2DImage(int target, int level, int internalformat, int format, int type, ImageElement image) native;
 
   /**
    * Updates the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texImage2DUntyped] or [texImage2DTyped]
    * (or for more specificity, the more specialized [texImage2DImageData],
    * [texImage2DCanvas], [texImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texImage2D')
   @DocsEditable()
   void texImage2DImageData(int target, int level, int internalformat, int format, int type, ImageData pixels) {
     var pixels_1 = convertDartToNative_ImageData(pixels);
     _texImage2DImageData_1(target, level, internalformat, format, type, pixels_1);
     return;
   }
   @JSName('texImage2D')
   /**
    * Updates the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texImage2DUntyped] or [texImage2DTyped]
    * (or for more specificity, the more specialized [texImage2DImageData],
    * [texImage2DCanvas], [texImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texImage2D')
   @DocsEditable()
   void _texImage2DImageData_1(target, level, internalformat, format, type, pixels) native;
 
   @JSName('texImage2D')
   /**
    * Updates the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texImage2DUntyped] or [texImage2DTyped]
    * (or for more specificity, the more specialized [texImage2DImageData],
    * [texImage2DCanvas], [texImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texImage2D')
   @DocsEditable()
   void texImage2DVideo(int target, int level, int internalformat, int format, int type, VideoElement video) native;
 
   @DomName('WebGLRenderingContext.texParameterf')
   @DocsEditable()
   void texParameterf(int target, int pname, num param) native;
 
   @DomName('WebGLRenderingContext.texParameteri')
   @DocsEditable()
   void texParameteri(int target, int pname, int param) native;
 
   /**
    * Updates a sub-rectangle of the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texSubImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texSubImage2DUntyped] or [texSubImage2DTyped]
    * (or for more specificity, the more specialized [texSubImage2DImageData],
    * [texSubImage2DCanvas], [texSubImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texSubImage2D')
   @DocsEditable()
   void texSubImage2D(int target, int level, int xoffset, int yoffset, int format_OR_width, int height_OR_type, canvas_OR_format_OR_image_OR_pixels_OR_video, [int type, TypedData pixels]) {
     if (pixels != null && type != null && (canvas_OR_format_OR_image_OR_pixels_OR_video is int || canvas_OR_format_OR_image_OR_pixels_OR_video == null)) {
       _texSubImage2D_1(target, level, xoffset, yoffset, format_OR_width, height_OR_type, canvas_OR_format_OR_image_OR_pixels_OR_video, type, pixels);
       return;
@@ skipping 14 matching lines @@
     if ((canvas_OR_format_OR_image_OR_pixels_OR_video is VideoElement || canvas_OR_format_OR_image_OR_pixels_OR_video == null) && type == null && pixels == null) {
       _texSubImage2D_5(target, level, xoffset, yoffset, format_OR_width, height_OR_type, canvas_OR_format_OR_image_OR_pixels_OR_video);
       return;
     }
     throw new ArgumentError("Incorrect number or type of arguments");
   }
   @JSName('texSubImage2D')
   /**
    * Updates a sub-rectangle of the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texSubImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texSubImage2DUntyped] or [texSubImage2DTyped]
    * (or for more specificity, the more specialized [texSubImage2DImageData],
    * [texSubImage2DCanvas], [texSubImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texSubImage2D')
   @DocsEditable()
   void _texSubImage2D_1(target, level, xoffset, yoffset, width, height, int format, type, TypedData pixels) native;
   @JSName('texSubImage2D')
   /**
    * Updates a sub-rectangle of the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texSubImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texSubImage2DUntyped] or [texSubImage2DTyped]
    * (or for more specificity, the more specialized [texSubImage2DImageData],
    * [texSubImage2DCanvas], [texSubImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texSubImage2D')
   @DocsEditable()
   void _texSubImage2D_2(target, level, xoffset, yoffset, format, type, pixels) native;
   @JSName('texSubImage2D')
   /**
    * Updates a sub-rectangle of the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texSubImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texSubImage2DUntyped] or [texSubImage2DTyped]
    * (or for more specificity, the more specialized [texSubImage2DImageData],
    * [texSubImage2DCanvas], [texSubImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texSubImage2D')
   @DocsEditable()
   void _texSubImage2D_3(target, level, xoffset, yoffset, format, type, ImageElement image) native;
   @JSName('texSubImage2D')
   /**
    * Updates a sub-rectangle of the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texSubImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texSubImage2DUntyped] or [texSubImage2DTyped]
    * (or for more specificity, the more specialized [texSubImage2DImageData],
    * [texSubImage2DCanvas], [texSubImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texSubImage2D')
   @DocsEditable()
   void _texSubImage2D_4(target, level, xoffset, yoffset, format, type, CanvasElement canvas) native;
   @JSName('texSubImage2D')
   /**
    * Updates a sub-rectangle of the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texSubImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texSubImage2DUntyped] or [texSubImage2DTyped]
    * (or for more specificity, the more specialized [texSubImage2DImageData],
    * [texSubImage2DCanvas], [texSubImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texSubImage2D')
   @DocsEditable()
   void _texSubImage2D_5(target, level, xoffset, yoffset, format, type, VideoElement video) native;
 
   @JSName('texSubImage2D')
   /**
    * Updates a sub-rectangle of the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texSubImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texSubImage2DUntyped] or [texSubImage2DTyped]
    * (or for more specificity, the more specialized [texSubImage2DImageData],
    * [texSubImage2DCanvas], [texSubImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texSubImage2D')
   @DocsEditable()
   void texSubImage2DCanvas(int target, int level, int xoffset, int yoffset, int format, int type, CanvasElement canvas) native;
 
   @JSName('texSubImage2D')
   /**
    * Updates a sub-rectangle of the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texSubImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texSubImage2DUntyped] or [texSubImage2DTyped]
    * (or for more specificity, the more specialized [texSubImage2DImageData],
    * [texSubImage2DCanvas], [texSubImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texSubImage2D')
   @DocsEditable()
   void texSubImage2DImage(int target, int level, int xoffset, int yoffset, int format, int type, ImageElement image) native;
 
   /**
    * Updates a sub-rectangle of the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texSubImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texSubImage2DUntyped] or [texSubImage2DTyped]
    * (or for more specificity, the more specialized [texSubImage2DImageData],
    * [texSubImage2DCanvas], [texSubImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texSubImage2D')
   @DocsEditable()
   void texSubImage2DImageData(int target, int level, int xoffset, int yoffset, int format, int type, ImageData pixels) {
     var pixels_1 = convertDartToNative_ImageData(pixels);
     _texSubImage2DImageData_1(target, level, xoffset, yoffset, format, type, pixels_1);
     return;
   }
   @JSName('texSubImage2D')
   /**
    * Updates a sub-rectangle of the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texSubImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texSubImage2DUntyped] or [texSubImage2DTyped]
    * (or for more specificity, the more specialized [texSubImage2DImageData],
    * [texSubImage2DCanvas], [texSubImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texSubImage2D')
   @DocsEditable()
   void _texSubImage2DImageData_1(target, level, xoffset, yoffset, format, type, pixels) native;
 
   @JSName('texSubImage2D')
   /**
    * Updates a sub-rectangle of the currently bound texture to [data].
    *
-   * This specific method is provided for WebGL API compatibility reasons, but it
+   * The [texSubImage2D] method is provided for WebGL API compatibility reasons, but it
    * is highly recommended that you use [texSubImage2DUntyped] or [texSubImage2DTyped]
    * (or for more specificity, the more specialized [texSubImage2DImageData],
    * [texSubImage2DCanvas], [texSubImage2DVideo]).
    */
   @DomName('WebGLRenderingContext.texSubImage2D')
   @DocsEditable()
   void texSubImage2DVideo(int target, int level, int xoffset, int yoffset, int format, int type, VideoElement video) native;
 
   @DomName('WebGLRenderingContext.uniform1f')
   @DocsEditable()
@@ skipping 224 matching lines @@
 
 
 @DocsEditable()
 @DomName('WebGLVertexArrayObjectOES')
 // http://www.khronos.org/registry/webgl/extensions/OES_vertex_array_object/
 @Experimental() // experimental
 class VertexArrayObject extends Interceptor native "WebGLVertexArrayObjectOES" {
   // To suppress missing implicit constructor warnings.
   factory VertexArrayObject._() { throw new UnsupportedError("Not supported"); }
 }