reflow comments in modules/webgl

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

 /*
  * 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 631 matching lines @@
   Document& document = canvas->document();
   LocalFrame* frame = document.frame();
   if (!frame) {
     canvas->dispatchEvent(WebGLContextEvent::create(
         EventTypeNames::webglcontextcreationerror, false, true,
         "Web page was not allowed to create a WebGL context."));
     return nullptr;
   }
   Settings* settings = frame->settings();
 
-  // The FrameLoaderClient might block creation of a new WebGL context despite the page settings; in
-  // particular, if WebGL contexts were lost one or more times via the GL_ARB_robustness extension.
+  // The FrameLoaderClient might block creation of a new WebGL context despite
+  // the page settings; in particular, if WebGL contexts were lost one or more
+  // times via the GL_ARB_robustness extension.
   if (!frame->loader().client()->allowWebGL(settings &&
                                             settings->webGLEnabled())) {
     canvas->dispatchEvent(WebGLContextEvent::create(
         EventTypeNames::webglcontextcreationerror, false, true,
         "Web page was not allowed to create a WebGL context."));
     return nullptr;
   }
 
   return createContextProviderInternal(canvas, nullptr, attributes,
                                        webGLVersion);
@@ skipping 29 matching lines @@
   // no HTMLCanvas associated, thrown InvalidStateError
   if (getOffscreenCanvas()->getAssociatedCanvasId() == -1) {
     exceptionState.throwDOMException(InvalidStateError,
                                      "Commit() was called on a context whose "
                                      "OffscreenCanvas is not associated with a "
                                      "canvas element.");
     return;
   }
   if (!drawingBuffer())
     return;
-  // TODO(crbug.com/646864): Make commit() work correctly with { preserveDrawingBuffer : true }.
+  // TODO(crbug.com/646864): Make commit() work correctly with
+  // { preserveDrawingBuffer : true }.
   getOffscreenCanvas()->getOrCreateFrameDispatcher()->dispatchFrame(
       std::move(drawingBuffer()->transferToStaticBitmapImage()));
 }
 
 PassRefPtr<Image> WebGLRenderingContextBase::getImage(
     AccelerationHint hint,
     SnapshotReason reason) const {
   if (!drawingBuffer())
     return nullptr;
 
   drawingBuffer()->commit();
   IntSize size = clampedCanvasSize();
   OpacityMode opacityMode =
       creationAttributes().hasAlpha() ? NonOpaque : Opaque;
   std::unique_ptr<AcceleratedImageBufferSurface> surface =
       wrapUnique(new AcceleratedImageBufferSurface(size, opacityMode));
   if (!surface->isValid())
     return nullptr;
   std::unique_ptr<ImageBuffer> buffer = ImageBuffer::create(std::move(surface));
   if (!buffer->copyRenderingResultsFromDrawingBuffer(drawingBuffer(),
                                                      BackBuffer)) {
-    // copyRenderingResultsFromDrawingBuffer is expected to always succeed because we've
-    // explicitly created an Accelerated surface and have already validated it.
+    // copyRenderingResultsFromDrawingBuffer is expected to always succeed
+    // because we've explicitly created an Accelerated surface and have already
+    // validated it.
     NOTREACHED();
     return nullptr;
   }
   return buffer->newImageSnapshot(hint, reason);
 }
 
 namespace {
 
 // Exposed by GL_ANGLE_depth_texture
 static const GLenum kSupportedInternalFormatsOESDepthTex[] = {
@@ skipping 410 matching lines @@
       convertToBaseCallback(
           WTF::bind(&WebGLRenderingContextBase::onErrorMessage,
                     wrapWeakPersistent(this))));
 
   // If WebGL 2, the PRIMITIVE_RESTART_FIXED_INDEX should be always enabled.
   // See the section <Primitive Restart is Always Enabled> in WebGL 2 spec:
   // https://www.khronos.org/registry/webgl/specs/latest/2.0/#4.1.4
   if (isWebGL2OrHigher())
     contextGL()->Enable(GL_PRIMITIVE_RESTART_FIXED_INDEX);
 
-  // This ensures that the context has a valid "lastFlushID" and won't be mistakenly identified as the "least recently used" context.
+  // This ensures that the context has a valid "lastFlushID" and won't be
+  // mistakenly identified as the "least recently used" context.
   contextGL()->Flush();
 
   for (int i = 0; i < WebGLExtensionNameCount; ++i)
     m_extensionEnabled[i] = false;
 
   m_isWebGL2FormatsTypesAdded = false;
   m_isWebGL2TexImageSourceFormatsTypesAdded = false;
   m_isWebGL2InternalFormatsCopyTexImageAdded = false;
   m_isOESTextureFloatFormatsTypesAdded = false;
   m_isOESTextureHalfFloatFormatsTypesAdded = false;
@@ skipping 35 matching lines @@
 
 void WebGLRenderingContextBase::addCompressedTextureFormat(GLenum format) {
   if (!m_compressedTextureFormats.contains(format))
     m_compressedTextureFormats.append(format);
 }
 
 void WebGLRenderingContextBase::removeAllCompressedTextureFormats() {
   m_compressedTextureFormats.clear();
 }
 
-// Helper function for V8 bindings to identify what version of WebGL a CanvasRenderingContext supports.
+// Helper function for V8 bindings to identify what version of WebGL a
+// CanvasRenderingContext supports.
 unsigned WebGLRenderingContextBase::getWebGLVersion(
     const CanvasRenderingContext* context) {
   if (!context->is3d())
     return 0;
   return static_cast<const WebGLRenderingContextBase*>(context)->version();
 }
 
 WebGLRenderingContextBase::~WebGLRenderingContextBase() {
   // Remove all references to WebGLObjects so if they are the last reference
-  // they will be freed before the last context is removed from the context group.
+  // they will be freed before the last context is removed from the context
+  // group.
   m_boundArrayBuffer = nullptr;
   m_defaultVertexArrayObject = nullptr;
   m_boundVertexArrayObject = nullptr;
   m_currentProgram = nullptr;
   m_framebufferBinding = nullptr;
   m_renderbufferBinding = nullptr;
 
   // WebGLTexture shared objects will be detached and deleted
-  // m_contextGroup->removeContext(this), which will bring about deleteTexture() calls.
-  // We null these out to avoid accessing those members in deleteTexture().
+  // m_contextGroup->removeContext(this), which will bring about deleteTexture()
+  // calls.  We null these out to avoid accessing those members in
+  // deleteTexture().
   for (size_t i = 0; i < m_textureUnits.size(); ++i) {
     m_textureUnits[i].m_texture2DBinding = nullptr;
     m_textureUnits[i].m_textureCubeMapBinding = nullptr;
     m_textureUnits[i].m_texture3DBinding = nullptr;
     m_textureUnits[i].m_texture2DArrayBinding = nullptr;
   }
 
   detachAndRemoveAllObjects();
 
   // Release all extensions now.
@@ skipping 76 matching lines @@
   if (!drawingBuffer()->bufferClearNeeded() || (mask && m_framebufferBinding))
     return Skipped;
 
   Nullable<WebGLContextAttributes> contextAttributes;
   getContextAttributes(contextAttributes);
   if (contextAttributes.isNull()) {
     // Unlikely, but context was lost.
     return Skipped;
   }
 
-  // Determine if it's possible to combine the clear the user asked for and this clear.
+  // Determine if it's possible to combine the clear the user asked for and this
+  // clear.
   bool combinedClear = mask && !m_scissorEnabled;
 
   contextGL()->Disable(GL_SCISSOR_TEST);
   if (combinedClear && (mask & GL_COLOR_BUFFER_BIT)) {
     contextGL()->ClearColor(m_colorMask[0] ? m_clearColor[0] : 0,
                             m_colorMask[1] ? m_clearColor[1] : 0,
                             m_colorMask[2] ? m_clearColor[2] : 0,
                             m_colorMask[3] ? m_clearColor[3] : 0);
   } else {
     contextGL()->ClearColor(0, 0, 0, 0);
@@ skipping 77 matching lines @@
 
   if (!canvas()->buffer())
     return false;
 
   ScopedTexture2DRestorer restorer(this);
   ScopedFramebufferRestorer fboRestorer(this);
 
   drawingBuffer()->commit();
   if (!canvas()->buffer()->copyRenderingResultsFromDrawingBuffer(
           drawingBuffer(), sourceBuffer)) {
-    // Currently, copyRenderingResultsFromDrawingBuffer is expected to always succeed because cases
-    // where canvas()-buffer() is not accelerated are handle before reaching this point.
-    // If that assumption ever stops holding true, we may need to implement a fallback right here.
+    // Currently, copyRenderingResultsFromDrawingBuffer is expected to always
+    // succeed because cases where canvas()-buffer() is not accelerated are
+    // handle before reaching this point.  If that assumption ever stops holding
+    // true, we may need to implement a fallback right here.
     ASSERT_NOT_REACHED();
     return false;
   }
 
   return true;
 }
 
 ImageData* WebGLRenderingContextBase::paintRenderingResultsToImageData(
     SourceDrawingBuffer sourceBuffer) {
   if (isContextLost())
@@ skipping 18 matching lines @@
 }
 
 void WebGLRenderingContextBase::reshape(int width, int height) {
   if (isContextLost())
     return;
 
   if (isWebGL2OrHigher()) {
     contextGL()->BindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
   }
 
-  // This is an approximation because at WebGLRenderingContextBase level we don't
-  // know if the underlying FBO uses textures or renderbuffers.
+  // This is an approximation because at WebGLRenderingContextBase level we
+  // don't know if the underlying FBO uses textures or renderbuffers.
   GLint maxSize = std::min(m_maxTextureSize, m_maxRenderbufferSize);
   GLint maxWidth = std::min(maxSize, m_maxViewportDims[0]);
   GLint maxHeight = std::min(maxSize, m_maxViewportDims[1]);
   width = clamp(width, 1, maxWidth);
   height = clamp(height, 1, maxHeight);
 
-  // Limit drawing buffer area to 4k*4k to avoid memory exhaustion. Width or height may be larger than
-  // 4k as long as it's within the max viewport dimensions and total area remains within the limit.
+  // Limit drawing buffer area to 4k*4k to avoid memory exhaustion. Width or
+  // height may be larger than 4k as long as it's within the max viewport
+  // dimensions and total area remains within the limit.
   // For example: 5120x2880 should be fine.
   const int maxArea = 4096 * 4096;
   int currentArea = width * height;
   if (currentArea > maxArea) {
-    // If we've exceeded the area limit scale the buffer down, preserving ascpect ratio, until it fits.
+    // If we've exceeded the area limit scale the buffer down, preserving
+    // ascpect ratio, until it fits.
     float scaleFactor =
         sqrtf(static_cast<float>(maxArea) / static_cast<float>(currentArea));
     width = std::max(1, static_cast<int>(width * scaleFactor));
     height = std::max(1, static_cast<int>(height * scaleFactor));
   }
 
-  // We don't have to mark the canvas as dirty, since the newly created image buffer will also start off
-  // clear (and this matches what reshape will do).
+  // We don't have to mark the canvas as dirty, since the newly created image
+  // buffer will also start off clear (and this matches what reshape will do).
   drawingBuffer()->reset(IntSize(width, height));
   restoreStateAfterClear();
 
   contextGL()->BindTexture(
       GL_TEXTURE_2D,
       objectOrZero(
           m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get()));
   contextGL()->BindRenderbuffer(GL_RENDERBUFFER,
                                 objectOrZero(m_renderbufferBinding.get()));
   drawingBuffer()->restoreFramebufferBindings();
@@ skipping 192 matching lines @@
     synthesizeGLError(GL_INVALID_ENUM, "bindTexture", "invalid target");
     return;
   }
 
   contextGL()->BindTexture(target, objectOrZero(texture));
   if (texture) {
     texture->setTarget(target);
     m_onePlusMaxNonDefaultTextureUnit =
         max(m_activeTextureUnit + 1, m_onePlusMaxNonDefaultTextureUnit);
   } else {
-    // If the disabled index is the current maximum, trace backwards to find the new max enabled texture index
+    // If the disabled index is the current maximum, trace backwards to find the
+    // new max enabled texture index
     if (m_onePlusMaxNonDefaultTextureUnit == m_activeTextureUnit + 1) {
       findNewMaxNonDefaultTextureUnit();
     }
   }
 
   // Note: previously we used to automatically set the TEXTURE_WRAP_R
   // repeat mode to CLAMP_TO_EDGE for cube map textures, because OpenGL
   // ES 2.0 doesn't expose this flag (a bug in the specification) and
   // otherwise the application has no control over the seams in this
   // dimension. However, it appears that supporting this properly on all
@@ skipping 190 matching lines @@
       m_framebufferBinding->checkDepthStencilStatus(&reason) !=
           GL_FRAMEBUFFER_COMPLETE) {
     synthesizeGLError(GL_INVALID_FRAMEBUFFER_OPERATION, "clear", reason);
     return;
   }
 
   ScopedRGBEmulationColorMask emulationColorMask(contextGL(), m_colorMask,
                                                  m_drawingBuffer.get());
 
   if (clearIfComposited(mask) != CombinedClear) {
-    // If clearing the default back buffer's depth buffer, also clear the stencil buffer, if one
-    // was allocated implicitly. This avoids performance problems on some GPUs.
+    // If clearing the default back buffer's depth buffer, also clear the
+    // stencil buffer, if one was allocated implicitly. This avoids performance
+    // problems on some GPUs.
     if (!m_framebufferBinding && drawingBuffer()->hasImplicitStencilBuffer() &&
         (mask & GL_DEPTH_BUFFER_BIT)) {
-      // It shouldn't matter what value it's cleared to, since in other queries in the API, we
-      // claim that the stencil buffer doesn't exist.
+      // It shouldn't matter what value it's cleared to, since in other queries
+      // in the API, we claim that the stencil buffer doesn't exist.
       mask |= GL_STENCIL_BUFFER_BIT;
     }
     contextGL()->Clear(mask);
   }
   markContextChanged(CanvasChanged);
 }
 
 void WebGLRenderingContextBase::clearColor(GLfloat r,
                                            GLfloat g,
                                            GLfloat b,
@@ skipping 324 matching lines @@
       }
     }
   }
   if (m_framebufferBinding)
     m_framebufferBinding->removeAttachmentFromBoundFramebuffer(GL_FRAMEBUFFER,
                                                                texture);
   if (getFramebufferBinding(GL_READ_FRAMEBUFFER))
     getFramebufferBinding(GL_READ_FRAMEBUFFER)
         ->removeAttachmentFromBoundFramebuffer(GL_READ_FRAMEBUFFER, texture);
 
-  // If the deleted was bound to the the current maximum index, trace backwards to find the new max texture index
+  // If the deleted was bound to the the current maximum index, trace backwards
+  // to find the new max texture index.
   if (m_onePlusMaxNonDefaultTextureUnit ==
       static_cast<unsigned long>(maxBoundTextureIndex + 1)) {
     findNewMaxNonDefaultTextureUnit();
   }
 }
 
 void WebGLRenderingContextBase::depthFunc(GLenum func) {
   if (isContextLost())
     return;
   contextGL()->DepthFunc(func);
@@ skipping 233 matching lines @@
   // implementations use an FBO internally in place of the default
   // FBO.
   WebGLFramebuffer* framebufferBinding = getFramebufferBinding(target);
   if (!framebufferBinding || !framebufferBinding->object()) {
     synthesizeGLError(GL_INVALID_OPERATION, "framebufferRenderbuffer",
                       "no framebuffer bound");
     return;
   }
   GLuint bufferObject = objectOrZero(buffer);
   if (isWebGL2OrHigher() && attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
-    // On ES3, DEPTH_STENCIL_ATTACHMENT is like an alias for DEPTH_ATTACHMENT + STENCIL_ATTACHMENT.
-    // We divide it here so in WebGLFramebuffer, we don't have to handle DEPTH_STENCIL_ATTACHMENT in WebGL 2.
+    // On ES3, DEPTH_STENCIL_ATTACHMENT is like an alias for DEPTH_ATTACHMENT +
+    // STENCIL_ATTACHMENT.  We divide it here so in WebGLFramebuffer, we don't
+    // have to handle DEPTH_STENCIL_ATTACHMENT in WebGL 2.
     contextGL()->FramebufferRenderbuffer(target, GL_DEPTH_ATTACHMENT,
                                          renderbuffertarget, bufferObject);
     contextGL()->FramebufferRenderbuffer(target, GL_STENCIL_ATTACHMENT,
                                          renderbuffertarget, bufferObject);
     framebufferBinding->setAttachmentForBoundFramebuffer(
         target, GL_DEPTH_ATTACHMENT, buffer);
     framebufferBinding->setAttachmentForBoundFramebuffer(
         target, GL_STENCIL_ATTACHMENT, buffer);
   } else {
     contextGL()->FramebufferRenderbuffer(target, attachment, renderbuffertarget,
@@ skipping 22 matching lines @@
   // implementations use an FBO internally in place of the default
   // FBO.
   WebGLFramebuffer* framebufferBinding = getFramebufferBinding(target);
   if (!framebufferBinding || !framebufferBinding->object()) {
     synthesizeGLError(GL_INVALID_OPERATION, "framebufferTexture2D",
                       "no framebuffer bound");
     return;
   }
   GLuint textureObject = objectOrZero(texture);
   if (isWebGL2OrHigher() && attachment == GL_DEPTH_STENCIL_ATTACHMENT) {
-    // On ES3, DEPTH_STENCIL_ATTACHMENT is like an alias for DEPTH_ATTACHMENT + STENCIL_ATTACHMENT.
-    // We divide it here so in WebGLFramebuffer, we don't have to handle DEPTH_STENCIL_ATTACHMENT in WebGL 2.
+    // On ES3, DEPTH_STENCIL_ATTACHMENT is like an alias for DEPTH_ATTACHMENT +
+    // STENCIL_ATTACHMENT.  We divide it here so in WebGLFramebuffer, we don't
+    // have to handle DEPTH_STENCIL_ATTACHMENT in WebGL 2.
     contextGL()->FramebufferTexture2D(target, GL_DEPTH_ATTACHMENT, textarget,
                                       textureObject, level);
     contextGL()->FramebufferTexture2D(target, GL_STENCIL_ATTACHMENT, textarget,
                                       textureObject, level);
     framebufferBinding->setAttachmentForBoundFramebuffer(
         target, GL_DEPTH_ATTACHMENT, textarget, texture, level, 0);
     framebufferBinding->setAttachmentForBoundFramebuffer(
         target, GL_STENCIL_ATTACHMENT, textarget, texture, level, 0);
   } else {
     contextGL()->FramebufferTexture2D(target, attachment, textarget,
@@ skipping 147 matching lines @@
                         "invalid parameter name");
       return ScriptValue::createNull(scriptState);
   }
 }
 
 void WebGLRenderingContextBase::getContextAttributes(
     Nullable<WebGLContextAttributes>& result) {
   if (isContextLost())
     return;
   result.set(toWebGLContextAttributes(creationAttributes()));
-  // Some requested attributes may not be honored, so we need to query the underlying
-  // context/drawing buffer and adjust accordingly.
+  // Some requested attributes may not be honored, so we need to query the
+  // underlying context/drawing buffer and adjust accordingly.
   if (creationAttributes().depth() && !drawingBuffer()->hasDepthBuffer())
     result.get().setDepth(false);
   if (creationAttributes().stencil() && !drawingBuffer()->hasStencilBuffer())
     result.get().setStencil(false);
   result.get().setAntialias(drawingBuffer()->multisample());
 }
 
 GLenum WebGLRenderingContextBase::getError() {
   if (!m_lostContextErrors.isEmpty()) {
     GLenum error = m_lostContextErrors.first();
@@ skipping 675 matching lines @@
   contextGL()->GetProgramiv(programId, GL_ACTIVE_UNIFORM_MAX_LENGTH,
                             &maxNameLength);
   if (maxNameLength < 0)
     return ScriptValue::createNull(scriptState);
   if (maxNameLength == 0) {
     synthesizeGLError(GL_INVALID_VALUE, "getUniform",
                       "no active uniforms exist");
     return ScriptValue::createNull(scriptState);
   }
 
-  // FIXME: make this more efficient using WebGLUniformLocation and caching types in it
+  // FIXME: make this more efficient using WebGLUniformLocation and caching
+  // types in it.
   GLint activeUniforms = 0;
   contextGL()->GetProgramiv(programId, GL_ACTIVE_UNIFORMS, &activeUniforms);
   for (GLint i = 0; i < activeUniforms; i++) {
     LChar* namePtr;
     RefPtr<StringImpl> nameImpl =
         StringImpl::createUninitialized(maxNameLength, namePtr);
     GLsizei length = 0;
     GLint size = -1;
     GLenum type = 0;
     contextGL()->GetActiveUniform(programId, i, maxNameLength, &length, &size,
                                   &type, reinterpret_cast<GLchar*>(namePtr));
     if (size < 0)
       return ScriptValue::createNull(scriptState);
     String name(nameImpl->substring(0, length));
     StringBuilder nameBuilder;
     // Strip "[0]" from the name if it's an array.
     if (size > 1 && name.endsWith("[0]"))
       name = name.left(name.length() - 3);
-    // If it's an array, we need to iterate through each element, appending "[index]" to the name.
+    // If it's an array, we need to iterate through each element, appending
+    // "[index]" to the name.
     for (GLint index = 0; index < size; ++index) {
       nameBuilder.clear();
       nameBuilder.append(name);
       if (size > 1 && index >= 1) {
         nameBuilder.append('[');
         nameBuilder.appendNumber(index);
         nameBuilder.append(']');
       }
       // Now need to look this up by name again to find its location
       GLint loc = contextGL()->GetUniformLocation(
           objectOrZero(program), nameBuilder.toString().utf8().data());
       if (loc == location) {
-        // Found it. Use the type in the ActiveInfo to determine the return type.
+        // Found it. Use the type in the ActiveInfo to determine the return
+        // type.
         GLenum baseType;
         unsigned length;
         switch (type) {
           case GL_BOOL:
             baseType = GL_BOOL;
             length = 1;
             break;
           case GL_BOOL_VEC2:
             baseType = GL_BOOL;
             length = 2;
@@ skipping 149 matching lines @@
               return WebGLAny(scriptState, boolValue, length);
             }
             return WebGLAny(scriptState, static_cast<bool>(value[0]));
           }
           default:
             NOTIMPLEMENTED();
         }
       }
     }
   }
-  // If we get here, something went wrong in our unfortunately complex logic above
+  // If we get here, something went wrong in our unfortunately complex logic
+  // above
   synthesizeGLError(GL_INVALID_VALUE, "getUniform", "unknown error");
   return ScriptValue::createNull(scriptState);
 }
 
 WebGLUniformLocation* WebGLRenderingContextBase::getUniformLocation(
     WebGLProgram* program,
     const String& name) {
   if (isContextLost() || !validateWebGLObject("getUniformLocation", program))
     return nullptr;
   if (!validateLocationLength("getUniformLocation", name))
@@ skipping 435 matching lines @@
   }
 }
 
 void WebGLRenderingContextBase::renderbufferStorageImpl(
     GLenum target,
     GLsizei samples,
     GLenum internalformat,
     GLsizei width,
     GLsizei height,
     const char* functionName) {
-  ASSERT(
-      !samples);  // |samples| > 0 is only valid in WebGL2's renderbufferStorageMultisample().
+  ASSERT(!samples);             // |samples| > 0 is only valid in WebGL2's
+                                // renderbufferStorageMultisample().
   ASSERT(!isWebGL2OrHigher());  // Make sure this is overridden in WebGL 2.
   switch (internalformat) {
     case GL_DEPTH_COMPONENT16:
     case GL_RGBA4:
     case GL_RGB5_A1:
     case GL_RGB565:
     case GL_STENCIL_INDEX8:
       contextGL()->RenderbufferStorage(target, internalformat, width, height);
       m_renderbufferBinding->setInternalFormat(internalformat);
       m_renderbufferBinding->setSize(width, height);
@@ skipping 58 matching lines @@
   if (isContextLost())
     return;
   contextGL()->Scissor(x, y, width, height);
 }
 
 void WebGLRenderingContextBase::shaderSource(WebGLShader* shader,
                                              const String& string) {
   if (isContextLost() || !validateWebGLObject("shaderSource", shader))
     return;
   String stringWithoutComments = StripComments(string).result();
-  // TODO(danakj): Make validateShaderSource reject characters > 255 (or utf16 Strings)
-  // so we don't need to use StringUTF8Adaptor.
+  // TODO(danakj): Make validateShaderSource reject characters > 255 (or utf16
+  // Strings) so we don't need to use StringUTF8Adaptor.
   if (!validateShaderSource(stringWithoutComments))
     return;
   shader->setSource(string);
   WTF::StringUTF8Adaptor adaptor(stringWithoutComments);
   const GLchar* shaderData = adaptor.data();
   // TODO(danakj): Use base::saturated_cast<GLint>.
   const GLint shaderLength = adaptor.length();
   contextGL()->ShaderSource(objectOrZero(shader), 1, &shaderData,
                             &shaderLength);
 }
@@ skipping 84 matching lines @@
                                                   GLenum zfail,
                                                   GLenum zpass) {
   if (isContextLost())
     return;
   contextGL()->StencilOpSeparate(face, fail, zfail, zpass);
 }
 
 GLenum WebGLRenderingContextBase::convertTexInternalFormat(
     GLenum internalformat,
     GLenum type) {
-  // Convert to sized internal formats that are renderable with GL_CHROMIUM_color_buffer_float_rgb(a).
+  // Convert to sized internal formats that are renderable with
+  // GL_CHROMIUM_color_buffer_float_rgb(a).
   if (type == GL_FLOAT && internalformat == GL_RGBA &&
       extensionsUtil()->isExtensionEnabled(
           "GL_CHROMIUM_color_buffer_float_rgba"))
     return GL_RGBA32F_EXT;
   if (type == GL_FLOAT && internalformat == GL_RGB &&
       extensionsUtil()->isExtensionEnabled(
           "GL_CHROMIUM_color_buffer_float_rgb"))
     return GL_RGB32F_EXT;
   return internalformat;
 }
 
 void WebGLRenderingContextBase::texImage2DBase(GLenum target,
                                                GLint level,
                                                GLint internalformat,
                                                GLsizei width,
                                                GLsizei height,
                                                GLint border,
                                                GLenum format,
                                                GLenum type,
                                                const void* pixels) {
-  // All calling functions check isContextLost, so a duplicate check is not needed here.
+  // All calling functions check isContextLost, so a duplicate check is not
+  // needed here.
   contextGL()->TexImage2D(target, level,
                           convertTexInternalFormat(internalformat, type), width,
                           height, border, format, type, pixels);
 }
 
 void WebGLRenderingContextBase::texImageImpl(
     TexImageFunctionID functionID,
     GLenum target,
     GLint level,
     GLint internalformat,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     GLenum format,
     GLenum type,
     Image* image,
     WebGLImageConversion::ImageHtmlDomSource domSource,
     bool flipY,
     bool premultiplyAlpha) {
   const char* funcName = getTexImageFunctionName(functionID);
-  // All calling functions check isContextLost, so a duplicate check is not needed here.
+  // All calling functions check isContextLost, so a duplicate check is not
+  // needed here.
   if (type == GL_UNSIGNED_INT_10F_11F_11F_REV) {
     // The UNSIGNED_INT_10F_11F_11F_REV type pack/unpack isn't implemented.
     type = GL_FLOAT;
   }
   Vector<uint8_t> data;
   WebGLImageConversion::ImageExtractor imageExtractor(
       image, domSource, premultiplyAlpha,
       m_unpackColorspaceConversion == GL_NONE);
   if (!imageExtractor.imagePixelData()) {
     synthesizeGLError(GL_INVALID_VALUE, funcName, "bad image data");
@@ skipping 64 matching lines @@
                                  level, internalformat, width, height, depth,
                                  border, format, type))
     return false;
 
   if (functionType == TexSubImage) {
     if (!validateSettableTexFormat(functionName, format))
       return false;
     if (!validateSize(functionName, xoffset, yoffset, zoffset))
       return false;
   } else {
-    // For SourceArrayBufferView, function validateTexFuncData() would handle whether to validate the SettableTexFormat
+    // For SourceArrayBufferView, function validateTexFuncData() would handle
+    // whether to validate the SettableTexFormat
     // by checking if the ArrayBufferView is null or not.
     if (sourceType != SourceArrayBufferView) {
       if (!validateSettableTexFormat(functionName, format))
         return false;
     }
   }
 
   return true;
 }
 
 bool WebGLRenderingContextBase::validateValueFitNonNegInt32(
     const char* functionName,
     const char* paramName,
     long long value) {
   if (value < 0) {
     String errorMsg = String(paramName) + " < 0";
     synthesizeGLError(GL_INVALID_VALUE, functionName, errorMsg.ascii().data());
     return false;
   }
   if (value > static_cast<long long>(std::numeric_limits<int>::max())) {
     String errorMsg = String(paramName) + " more than 32-bit";
     synthesizeGLError(GL_INVALID_OPERATION, functionName,
                       errorMsg.ascii().data());
     return false;
   }
   return true;
 }
 
-// TODO(fmalita): figure why WebGLImageConversion::ImageExtractor can't handle SVG-backed images,
-// and get rid of this intermediate step.
+// TODO(fmalita): figure why WebGLImageConversion::ImageExtractor can't handle
+// SVG-backed images, and get rid of this intermediate step.
 PassRefPtr<Image> WebGLRenderingContextBase::drawImageIntoBuffer(
     PassRefPtr<Image> passImage,
     int width,
     int height,
     const char* functionName) {
   RefPtr<Image> image(passImage);
   ASSERT(image);
 
   IntSize size(width, height);
   ImageBuffer* buf = m_generatedImageCache.imageBuffer(size);
@@ skipping 166 matching lines @@
     functionType = TexImage;
   else
     functionType = TexSubImage;
   if (!validateTexFunc(funcName, functionType, SourceImageData, target, level,
                        internalformat, pixels->width(), pixels->height(), depth,
                        border, format, type, xoffset, yoffset, zoffset))
     return;
   Vector<uint8_t> data;
   bool needConversion = true;
   // The data from ImageData is always of format RGBA8.
-  // No conversion is needed if destination format is RGBA and type is USIGNED_BYTE and no Flip or Premultiply operation is required.
+  // No conversion is needed if destination format is RGBA and type is
+  // USIGNED_BYTE and no Flip or Premultiply operation is required.
   if (!m_unpackFlipY && !m_unpackPremultiplyAlpha && format == GL_RGBA &&
       type == GL_UNSIGNED_BYTE) {
     needConversion = false;
   } else {
     if (type == GL_UNSIGNED_INT_10F_11F_11F_REV) {
       // The UNSIGNED_INT_10F_11F_11F_REV type pack/unpack isn't implemented.
       type = GL_FLOAT;
     }
     if (!WebGLImageConversion::extractImageData(
             pixels->data()->data(),
@@ skipping 87 matching lines @@
 }
 
 bool WebGLRenderingContextBase::canUseTexImageByGPU(
     TexImageFunctionID functionID,
     GLint internalformat,
     GLenum type) {
   if (functionID == TexImage2D &&
       (isFloatType(type) || isIntegerFormat(internalformat) ||
        isSRGBFormat(internalformat)))
     return false;
-  // TODO(crbug.com/622958): Implement GPU-to-GPU path for WebGL 2 and more internal formats.
+  // TODO(crbug.com/622958): Implement GPU-to-GPU path for WebGL 2 and more
+  // internal formats.
   if (functionID == TexSubImage2D &&
       (isWebGL2OrHigher() || extensionEnabled(OESTextureFloatName) ||
        extensionEnabled(OESTextureHalfFloatName) ||
        extensionEnabled(EXTsRGBName)))
     return false;
   return true;
 }
 
 void WebGLRenderingContextBase::texImageCanvasByGPU(HTMLCanvasElement* canvas,
                                                     GLuint targetTexture,
@@ skipping 40 matching lines @@
   GLuint targetTexture = texture->object();
   GLenum targetType = type;
   GLenum targetInternalformat = internalformat;
   GLint targetLevel = level;
   bool possibleDirectCopy = false;
   if (functionType == TexImage2DByGPU) {
     possibleDirectCopy = Extensions3DUtil::canUseCopyTextureCHROMIUM(
         target, internalformat, type, level);
   }
 
-  // if direct copy is not possible, create a temporary texture and then copy from canvas to temporary texture to target texture.
+  // if direct copy is not possible, create a temporary texture and then copy
+  // from canvas to temporary texture to target texture.
   if (!possibleDirectCopy) {
     targetLevel = 0;
     targetInternalformat = GL_RGBA;
     targetType = GL_UNSIGNED_BYTE;
     contextGL()->GenTextures(1, &targetTexture);
     contextGL()->BindTexture(GL_TEXTURE_2D, targetTexture);
     contextGL()->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
                                GL_NEAREST);
     contextGL()->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                                GL_NEAREST);
@@ skipping 60 matching lines @@
   TexImageFunctionType functionType;
   if (functionID == TexImage2D)
     functionType = TexImage;
   else
     functionType = TexSubImage;
   if (!validateTexFunc(funcName, functionType, SourceHTMLCanvasElement, target,
                        level, internalformat, canvas->width(), canvas->height(),
                        1, 0, format, type, xoffset, yoffset, zoffset))
     return;
   if (functionID == TexImage2D || functionID == TexSubImage2D) {
-    // texImageByGPU relies on copyTextureCHROMIUM which doesn't support float/integer/sRGB internal format.
-    // TODO(crbug.com/622958): relax the constrains if copyTextureCHROMIUM is upgraded to handle more formats.
+    // texImageByGPU relies on copyTextureCHROMIUM which doesn't support
+    // float/integer/sRGB internal format.
+    // TODO(crbug.com/622958): relax the constrains if copyTextureCHROMIUM is
+    // upgraded to handle more formats.
     if (!canvas->renderingContext() ||
         !canvas->renderingContext()->isAccelerated() ||
         !canUseTexImageByGPU(functionID, internalformat, type)) {
       // 2D canvas has only FrontBuffer.
       texImageImpl(functionID, target, level, internalformat, xoffset, yoffset,
                    zoffset, format, type,
                    canvas->copiedImage(FrontBuffer, PreferAcceleration).get(),
                    WebGLImageConversion::HtmlDomCanvas, m_unpackFlipY,
                    m_unpackPremultiplyAlpha);
       return;
@@ skipping 69 matching lines @@
     functionType = TexImage;
   else
     functionType = TexSubImage;
   if (!validateTexFunc(funcName, functionType, SourceHTMLVideoElement, target,
                        level, internalformat, video->videoWidth(),
                        video->videoHeight(), 1, 0, format, type, xoffset,
                        yoffset, zoffset))
     return;
 
   if (functionID == TexImage2D) {
-    // Go through the fast path doing a GPU-GPU textures copy without a readback to system memory if possible.
-    // Otherwise, it will fall back to the normal SW path.
+    // Go through the fast path doing a GPU-GPU textures copy without a readback
+    // to system memory if possible.  Otherwise, it will fall back to the normal
+    // SW path.
     if (GL_TEXTURE_2D == target) {
       if (Extensions3DUtil::canUseCopyTextureCHROMIUM(target, internalformat,
                                                       type, level) &&
           video->copyVideoTextureToPlatformTexture(
               contextGL(), texture->object(), internalformat, type,
               m_unpackPremultiplyAlpha, m_unpackFlipY)) {
         return;
       }
 
-      // Try using an accelerated image buffer, this allows YUV conversion to be done on the GPU.
+      // Try using an accelerated image buffer, this allows YUV conversion to be
+      // done on the GPU.
       std::unique_ptr<ImageBufferSurface> surface =
           wrapUnique(new AcceleratedImageBufferSurface(
               IntSize(video->videoWidth(), video->videoHeight())));
       if (surface->isValid()) {
         std::unique_ptr<ImageBuffer> imageBuffer(
             ImageBuffer::create(std::move(surface)));
         if (imageBuffer) {
-          // The video element paints an RGBA frame into our surface here. By using an AcceleratedImageBufferSurface,
-          // we enable the WebMediaPlayer implementation to do any necessary color space conversion on the GPU (though it
+          // The video element paints an RGBA frame into our surface here. By
+          // using an AcceleratedImageBufferSurface, we enable the
+          // WebMediaPlayer implementation to do any necessary color space
+          // conversion on the GPU (though it
           // may still do a CPU conversion and upload the results).
           video->paintCurrentFrame(
               imageBuffer->canvas(),
               IntRect(0, 0, video->videoWidth(), video->videoHeight()),
               nullptr);
 
-          // This is a straight GPU-GPU copy, any necessary color space conversion was handled in the paintCurrentFrameInContext() call.
+          // This is a straight GPU-GPU copy, any necessary color space
+          // conversion was handled in the paintCurrentFrameInContext() call.
           if (imageBuffer->copyToPlatformTexture(
                   contextGL(), texture->object(), internalformat, type, level,
                   m_unpackPremultiplyAlpha, m_unpackFlipY)) {
             return;
           }
         }
       }
     }
   }
 
@@ skipping 69 matching lines @@
     } else if (functionID == TexSubImage2D) {
       texImageByGPU(TexSubImage2DByGPU, texture, target, level, GL_RGBA, type,
                     xoffset, yoffset, 0, bitmap);
     }
     return;
   }
   sk_sp<SkImage> skImage = bitmap->bitmapImage()->imageForCurrentFrame();
   SkPixmap pixmap;
   uint8_t* pixelDataPtr = nullptr;
   RefPtr<Uint8Array> pixelData;
-  // In the case where an ImageBitmap is not texture backed, peekPixels() always succeed.
-  // However, when it is texture backed and !canUseTexImageByGPU, we do a GPU read back.
+  // In the case where an ImageBitmap is not texture backed, peekPixels() always
+  // succeed.  However, when it is texture backed and !canUseTexImageByGPU, we
+  // do a GPU read back.
   bool peekSucceed = skImage->peekPixels(&pixmap);
   if (peekSucceed) {
     pixelDataPtr = static_cast<uint8_t*>(pixmap.writable_addr());
   } else {
     pixelData = bitmap->copyBitmapData(
         bitmap->isPremultiplied() ? PremultiplyAlpha : DontPremultiplyAlpha);
     pixelDataPtr = pixelData->data();
   }
   Vector<uint8_t> data;
   bool needConversion = true;
   bool havePeekableRGBA =
       (peekSucceed &&
        pixmap.colorType() == SkColorType::kRGBA_8888_SkColorType);
   bool isPixelDataRGBA = (havePeekableRGBA || !peekSucceed);
   if (isPixelDataRGBA && format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
     needConversion = false;
   } else {
     if (type == GL_UNSIGNED_INT_10F_11F_11F_REV) {
       // The UNSIGNED_INT_10F_11F_11F_REV type pack/unpack isn't implemented.
       type = GL_FLOAT;
     }
-    // In the case of ImageBitmap, we do not need to apply flipY or premultiplyAlpha.
+    // In the case of ImageBitmap, we do not need to apply flipY or
+    // premultiplyAlpha.
     bool isPixelDataBGRA =
         pixmap.colorType() == SkColorType::kBGRA_8888_SkColorType;
     if ((isPixelDataBGRA &&
          !WebGLImageConversion::extractImageData(
              pixelDataPtr, WebGLImageConversion::DataFormat::DataFormatBGRA8,
              bitmap->size(), format, type, false, false, data)) ||
         (isPixelDataRGBA &&
          !WebGLImageConversion::extractImageData(
              pixelDataPtr, WebGLImageConversion::DataFormat::DataFormatRGBA8,
              bitmap->size(), format, type, false, false, data))) {
@@ skipping 741 matching lines @@
 
 void WebGLRenderingContextBase::viewport(GLint x,
                                          GLint y,
                                          GLsizei width,
                                          GLsizei height) {
   if (isContextLost())
     return;
   contextGL()->Viewport(x, y, width, height);
 }
 
-// Added to provide a unified interface with CanvasRenderingContext2D. Prefer calling forceLostContext instead.
+// Added to provide a unified interface with CanvasRenderingContext2D. Prefer
+// calling forceLostContext instead.
 void WebGLRenderingContextBase::loseContext(LostContextMode mode) {
   forceLostContext(mode, Manual);
 }
 
 void WebGLRenderingContextBase::forceLostContext(
     LostContextMode mode,
     AutoRecoveryMethod autoRecoveryMethod) {
   if (isContextLost()) {
     synthesizeGLError(GL_INVALID_OPERATION, "loseContext",
                       "context already lost");
     return;
   }
 
   m_contextGroup->loseContextGroup(mode, autoRecoveryMethod);
 }
 
 void WebGLRenderingContextBase::loseContextImpl(
     WebGLRenderingContextBase::LostContextMode mode,
     AutoRecoveryMethod autoRecoveryMethod) {
   if (isContextLost())
     return;
 
   m_contextLostMode = mode;
   ASSERT(m_contextLostMode != NotLostContext);
   m_autoRecoveryMethod = autoRecoveryMethod;
 
-  // Make absolutely sure we do not refer to an already-deleted texture or framebuffer.
+  // Make absolutely sure we do not refer to an already-deleted texture or
+  // framebuffer.
   drawingBuffer()->setTexture2DBinding(0);
   drawingBuffer()->setFramebufferBinding(GL_FRAMEBUFFER, 0);
   drawingBuffer()->setRenderbufferBinding(0);
 
   detachAndRemoveAllObjects();
 
   // Lose all the extensions.
   for (size_t i = 0; i < m_extensions.size(); ++i) {
     ExtensionTracker* tracker = m_extensions[i];
     tracker->loseExtension(false);
@@ skipping 50 matching lines @@
     SkFilterQuality filterQuality) {
   if (!isContextLost() && drawingBuffer()) {
     drawingBuffer()->setFilterQuality(filterQuality);
   }
 }
 
 Extensions3DUtil* WebGLRenderingContextBase::extensionsUtil() {
   if (!m_extensionsUtil) {
     gpu::gles2::GLES2Interface* gl = contextGL();
     m_extensionsUtil = Extensions3DUtil::create(gl);
-    // The only reason the ExtensionsUtil should be invalid is if the gl context is lost.
+    // The only reason the ExtensionsUtil should be invalid is if the gl context
+    // is lost.
     ASSERT(m_extensionsUtil->isValid() ||
            gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR);
   }
   return m_extensionsUtil.get();
 }
 
 void WebGLRenderingContextBase::removeSharedObject(WebGLSharedObject* object) {
   m_contextGroup->removeObject(object);
 }
 
@@ skipping 509 matching lines @@
     case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
     case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
     case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
     case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
       if (functionType != TexSubImage && width != height) {
         synthesizeGLError(GL_INVALID_VALUE, functionName,
                           "width != height for cube map");
         return false;
       }
       // No need to check height here. For texImage width == height.
-      // For texSubImage that will be checked when checking yoffset + height is in range.
+      // For texSubImage that will be checked when checking yoffset + height is
+      // in range.
       if (width > (m_maxCubeMapTextureSize >> level)) {
         synthesizeGLError(GL_INVALID_VALUE, functionName,
                           "width or height out of range for cube map");
         return false;
       }
       break;
     case GL_TEXTURE_3D:
       if (isWebGL2OrHigher()) {
         if (width > (m_max3DTextureSize >> level) ||
             height > (m_max3DTextureSize >> level) ||
@@ skipping 70 matching lines @@
     TexImageDimension texDimension,
     GLint level,
     GLsizei width,
     GLsizei height,
     GLsizei depth,
     GLenum format,
     GLenum type,
     DOMArrayBufferView* pixels,
     NullDisposition disposition,
     GLuint srcOffset) {
-  // All calling functions check isContextLost, so a duplicate check is not needed here.
+  // All calling functions check isContextLost, so a duplicate check is not
+  // needed here.
   if (!pixels) {
     DCHECK_NE(disposition, NullNotReachable);
     if (disposition == NullAllowed)
       return true;
     synthesizeGLError(GL_INVALID_VALUE, functionName, "no pixels");
     return false;
   }
 
   if (!validateSettableTexFormat(functionName, format))
     return false;
@@ skipping 53 matching lines @@
       break;
     case GL_FLOAT:  // OES_texture_float
       if (pixels->type() != DOMArrayBufferView::TypeFloat32) {
         synthesizeGLError(GL_INVALID_OPERATION, functionName,
                           "type FLOAT but ArrayBufferView not Float32Array");
         return false;
       }
       break;
     case GL_HALF_FLOAT:
     case GL_HALF_FLOAT_OES:  // OES_texture_half_float
-      // As per the specification, ArrayBufferView should be null or a Uint16Array when
-      // OES_texture_half_float is enabled.
+      // As per the specification, ArrayBufferView should be null or a
+      // Uint16Array when OES_texture_half_float is enabled.
       if (pixels->type() != DOMArrayBufferView::TypeUint16) {
         synthesizeGLError(GL_INVALID_OPERATION, functionName,
                           "type HALF_FLOAT_OES but ArrayBufferView is not NULL "
                           "and not Uint16Array");
         return false;
       }
       break;
     case GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
       synthesizeGLError(GL_INVALID_OPERATION, functionName,
                         "type FLOAT_32_UNSIGNED_INT_24_8_REV but "
@@ skipping 442 matching lines @@
   LocalFrame* frame = canvas()->document().frame();
   if (!frame)
     return;
 
   Settings* settings = frame->settings();
 
   if (!frame->loader().client()->allowWebGL(settings &&
                                             settings->webGLEnabled()))
     return;
 
-  // If the context was lost due to RealLostContext, we need to destroy the old DrawingBuffer before creating new DrawingBuffer to ensure resource budget enough.
+  // If the context was lost due to RealLostContext, we need to destroy the old
+  // DrawingBuffer before creating new DrawingBuffer to ensure resource budget
+  // enough.
   if (drawingBuffer()) {
     m_drawingBuffer->beginDestruction();
     m_drawingBuffer.clear();
   }
 
   Platform::ContextAttributes attributes =
       toPlatformContextAttributes(creationAttributes(), version());
   Platform::GraphicsInfo glInfo;
   std::unique_ptr<WebGraphicsContext3DProvider> contextProvider =
       wrapUnique(Platform::current()->createOffscreenGraphicsContext3DProvider(
           attributes, canvas()->document().topDocument().url(), 0, &glInfo));
   RefPtr<DrawingBuffer> buffer;
   if (contextProvider && contextProvider->bindToCurrentThread()) {
     // Construct a new drawing buffer with the new GL context.
-    // TODO(xidachen): make sure that the second parameter is correct for OffscreenCanvas.
+    // TODO(xidachen): make sure that the second parameter is correct for
+    // OffscreenCanvas.
     buffer = createDrawingBuffer(std::move(contextProvider),
                                  DrawingBuffer::AllowChromiumImage);
-    // If DrawingBuffer::create() fails to allocate a fbo, |drawingBuffer| is set to null.
+    // If DrawingBuffer::create() fails to allocate a fbo, |drawingBuffer| is
+    // set to null.
   }
   if (!buffer) {
     if (m_contextLostMode == RealLostContext) {
       m_restoreTimer.startOneShot(secondsBetweenRestoreAttempts,
                                   BLINK_FROM_HERE);
     } else {
-      // This likely shouldn't happen but is the best way to report it to the WebGL app.
+      // This likely shouldn't happen but is the best way to report it to the
+      // WebGL app.
       synthesizeGLError(GL_INVALID_OPERATION, "", "error restoring context");
     }
     return;
   }
 
   m_drawingBuffer = buffer.release();
   m_drawingBuffer->addNewMailboxCallback(
       WTF::bind(&WebGLRenderingContextBase::notifyCanvasContextChanged,
                 wrapWeakPersistent(this)));
 
@@ skipping 191 matching lines @@
 void WebGLRenderingContextBase::restoreCurrentFramebuffer() {
   bindFramebuffer(GL_FRAMEBUFFER, m_framebufferBinding.get());
 }
 
 void WebGLRenderingContextBase::restoreCurrentTexture2D() {
   bindTexture(GL_TEXTURE_2D,
               m_textureUnits[m_activeTextureUnit].m_texture2DBinding.get());
 }
 
 void WebGLRenderingContextBase::findNewMaxNonDefaultTextureUnit() {
-  // Trace backwards from the current max to find the new max non-default texture unit
+  // Trace backwards from the current max to find the new max non-default
+  // texture unit
   int startIndex = m_onePlusMaxNonDefaultTextureUnit - 1;
   for (int i = startIndex; i >= 0; --i) {
     if (m_textureUnits[i].m_texture2DBinding ||
         m_textureUnits[i].m_textureCubeMapBinding) {
       m_onePlusMaxNonDefaultTextureUnit = i + 1;
       return;
     }
   }
   m_onePlusMaxNonDefaultTextureUnit = 0;
 }
@@ skipping 63 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 }  // namespace blink