Rewrap comments to 80 columns in platform/graphics/{compositing,cpu,gpu,skia}/.

third_party/WebKit/Source/platform/graphics/gpu/DrawingBuffer.cpp

 /*
  * Copyright (c) 2010, Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 339 matching lines @@
 
   // No buffer available to recycle, create a new one.
   if (!mailboxInfo)
     mailboxInfo = createNewMailbox(createTextureAndAllocateMemory(m_size));
 
   if (m_preserveDrawingBuffer == Discard) {
     std::swap(mailboxInfo->textureInfo, m_colorBuffer);
     attachColorBufferToReadFramebuffer();
 
     if (m_discardFramebufferSupported) {
-      // Explicitly discard framebuffer to save GPU memory bandwidth for tile-based GPU arch.
+      // Explicitly discard the framebuffer to save GPU memory bandwidth for
+      // tile-based GPU arch.
       const GLenum attachments[3] = {GL_COLOR_ATTACHMENT0, GL_DEPTH_ATTACHMENT,
                                      GL_STENCIL_ATTACHMENT};
       m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
       m_gl->DiscardFramebufferEXT(GL_FRAMEBUFFER, 3, attachments);
     }
   } else {
     m_gl->CopySubTextureCHROMIUM(
         m_colorBuffer.textureId, mailboxInfo->textureInfo.textureId, 0, 0, 0, 0,
         m_size.width(), m_size.height(), GL_FALSE, GL_FALSE, GL_FALSE);
   }
@@ skipping 61 matching lines @@
     bool lostResource) {
   DCHECK(!syncToken.HasData());  // No sync tokens for software resources.
   if (m_destructionInProgress || lostResource || m_isHidden || size != m_size)
     return;  // Just delete the bitmap.
 
   RecycledBitmap recycled = {std::move(bitmap), m_size};
   m_recycledBitmaps.append(std::move(recycled));
 }
 
 PassRefPtr<StaticBitmapImage> DrawingBuffer::transferToStaticBitmapImage() {
-  // This can be null if the context is lost before the first call to grContext().
+  // This can be null if the context is lost before the first call to
+  // grContext().
   GrContext* grContext = m_contextProvider->grContext();
 
   cc::TextureMailbox textureMailbox;
   std::unique_ptr<cc::SingleReleaseCallback> releaseCallback;
   bool success = false;
   if (grContext) {
     bool forceGpuResult = true;
     success = prepareTextureMailboxInternal(&textureMailbox, &releaseCallback,
                                             forceGpuResult);
   }
   if (!success) {
     // If we can't get a mailbox, return an transparent black ImageBitmap.
-    // The only situation this could happen is when two or more calls to transferToImageBitmap are made back-to-back, or when the context gets lost.
+    // The only situation in which this could happen is when two or more calls
+    // to transferToImageBitmap are made back-to-back, or when the context gets
+    // lost.
     sk_sp<SkSurface> surface =
         SkSurface::MakeRasterN32Premul(m_size.width(), m_size.height());
     return StaticBitmapImage::create(surface->makeImageSnapshot());
   }
 
   DCHECK_EQ(m_size.width(), textureMailbox.size_in_pixels().width());
   DCHECK_EQ(m_size.height(), textureMailbox.size_in_pixels().height());
 
-  // Make our own textureId that is a reference on the same texture backing being used as the front
-  // buffer (which was returned from PrepareTextureMailbox()).
-  // We do not need to wait on the sync token in |textureMailbox| since the mailbox was produced on
-  // the same |m_gl| context that we are using here. Similarly, the |releaseCallback| will run on
-  // the same context so we don't need to send a sync token for this consume action back to it.
-  // TODO(danakj): Instead of using PrepareTextureMailbox(), we could just use the actual texture id and
-  // avoid needing to produce/consume a mailbox.
+  // Make our own textureId that is a reference on the same texture backing
+  // being used as the front buffer (which was returned from
+  // PrepareTextureMailbox()). We do not need to wait on the sync token in
+  // |textureMailbox| since the mailbox was produced on the same |m_gl| context
+  // that we are using here. Similarly, the |releaseCallback| will run on the
+  // same context so we don't need to send a sync token for this consume action
+  // back to it.
+  // TODO(danakj): Instead of using PrepareTextureMailbox(), we could just use
+  // the actual texture id and avoid needing to produce/consume a mailbox.
   GLuint textureId = m_gl->CreateAndConsumeTextureCHROMIUM(
       GL_TEXTURE_2D, textureMailbox.name());
-  // Return the mailbox but report that the resource is lost to prevent trying to use
-  // the backing for future frames. We keep it alive with our own reference to the
-  // backing via our |textureId|.
+  // Return the mailbox but report that the resource is lost to prevent trying
+  // to use the backing for future frames. We keep it alive with our own
+  // reference to the backing via our |textureId|.
   releaseCallback->Run(gpu::SyncToken(), true /* lostResource */);
 
   // Store that texture id as the backing for an SkImage.
   GrGLTextureInfo textureInfo;
   textureInfo.fTarget = GL_TEXTURE_2D;
   textureInfo.fID = textureId;
   GrBackendTextureDesc backendTexture;
   backendTexture.fOrigin = kBottomLeft_GrSurfaceOrigin;
   backendTexture.fWidth = m_size.width();
   backendTexture.fHeight = m_size.height();
   backendTexture.fConfig = kSkia8888_GrPixelConfig;
   backendTexture.fTextureHandle =
       skia::GrGLTextureInfoToGrBackendObject(textureInfo);
   sk_sp<SkImage> skImage =
       SkImage::MakeFromAdoptedTexture(grContext, backendTexture);
 
-  // We reuse the same mailbox name from above since our texture id was consumed from it.
+  // We reuse the same mailbox name from above since our texture id was consumed
+  // from it.
   const auto& skImageMailbox = textureMailbox.mailbox();
-  // Use the sync token generated after producing the mailbox. Waiting for this before trying to use
-  // the mailbox with some other context will ensure it is valid. We wouldn't need to wait for the
-  // consume done in this function because the texture id it generated would only be valid for the
+  // Use the sync token generated after producing the mailbox. Waiting for this
+  // before trying to use the mailbox with some other context will ensure it is
+  // valid. We wouldn't need to wait for the consume done in this function
+  // because the texture id it generated would only be valid for the
   // DrawingBuffer's context anyways.
   const auto& skImageSyncToken = textureMailbox.sync_token();
 
-  // TODO(xidachen): Create a small pool of recycled textures from ImageBitmapRenderingContext's
-  // transferFromImageBitmap, and try to use them in DrawingBuffer.
+  // TODO(xidachen): Create a small pool of recycled textures from
+  // ImageBitmapRenderingContext's transferFromImageBitmap, and try to use them
+  // in DrawingBuffer.
   return AcceleratedStaticBitmapImage::createFromWebGLContextImage(
       std::move(skImage), skImageMailbox, skImageSyncToken);
 }
 
 DrawingBuffer::TextureParameters
 DrawingBuffer::chromiumImageTextureParameters() {
 #if OS(MACOSX)
   // A CHROMIUM_image backed texture requires a specialized set of parameters
   // on OSX.
   TextureParameters parameters;
@@ skipping 121 matching lines @@
     m_gl->GetIntegerv(GL_MAX_SAMPLES_ANGLE, &maxSampleCount);
     m_antiAliasingMode = MSAAExplicitResolve;
     if (m_extensionsUtil->supportsExtension(
             "GL_EXT_multisampled_render_to_texture")) {
       m_antiAliasingMode = MSAAImplicitResolve;
     } else if (m_extensionsUtil->supportsExtension(
                    "GL_CHROMIUM_screen_space_antialiasing")) {
       m_antiAliasingMode = ScreenSpaceAntialiasing;
     }
   }
-  // TODO(dshwang): enable storage texture on all platform. crbug.com/557848
-  // Linux ATI bot fails WebglConformance.conformance_textures_misc_tex_image_webgl
-  // So use storage texture only if ScreenSpaceAntialiasing is enabled,
-  // because ScreenSpaceAntialiasing is much faster with storage texture.
+  // TODO(dshwang): Enable storage textures on all platforms. crbug.com/557848
+  // The Linux ATI bot fails
+  // WebglConformance.conformance_textures_misc_tex_image_webgl, so use storage
+  // textures only if ScreenSpaceAntialiasing is enabled, because
+  // ScreenSpaceAntialiasing is much faster with storage textures.
   m_storageTextureSupported =
       (m_webGLVersion > WebGL1 ||
        m_extensionsUtil->supportsExtension("GL_EXT_texture_storage")) &&
       m_antiAliasingMode == ScreenSpaceAntialiasing;
   m_sampleCount = std::min(4, maxSampleCount);
 
   m_gl->GenFramebuffers(1, &m_fbo);
   m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
   if (wantExplicitResolve()) {
     m_gl->GenFramebuffers(1, &m_multisampleFBO);
     m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_multisampleFBO);
     m_gl->GenRenderbuffers(1, &m_multisampleRenderbuffer);
   }
   if (!reset(size))
     return false;
 
   if (m_depthStencilBuffer) {
     DCHECK(wantDepthOrStencil());
     m_hasImplicitStencilBuffer = !m_wantStencil;
   }
 
   if (m_gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR) {
-    // It's possible that the drawing buffer allocation provokes a context loss, so check again just in case. http://crbug.com/512302
+    // It's possible that the drawing buffer allocation provokes a context loss,
+    // so check again just in case. http://crbug.com/512302
     return false;
   }
 
   return true;
 }
 
 bool DrawingBuffer::copyToPlatformTexture(gpu::gles2::GLES2Interface* gl,
                                           GLuint texture,
                                           GLenum internalFormat,
                                           GLenum destType,
                                           GLint level,
                                           bool premultiplyAlpha,
                                           bool flipY,
                                           SourceDrawingBuffer sourceBuffer) {
   if (m_contentsChanged) {
     if (m_antiAliasingMode != None) {
       commit();
       restoreFramebufferBindings();
     }
     m_gl->Flush();
   }
 
   // Assume that the destination target is GL_TEXTURE_2D.
   if (!Extensions3DUtil::canUseCopyTextureCHROMIUM(
           GL_TEXTURE_2D, internalFormat, destType, level))
     return false;
 
-  // Contexts may be in a different share group. We must transfer the texture through a mailbox first
+  // Contexts may be in a different share group. We must transfer the texture
+  // through a mailbox first.
   GLint textureId = 0;
   GLenum target = 0;
   gpu::Mailbox mailbox;
   gpu::SyncToken produceSyncToken;
   if (sourceBuffer == FrontBuffer && m_frontColorBuffer.texInfo.textureId) {
     textureId = m_frontColorBuffer.texInfo.textureId;
     target = m_frontColorBuffer.texInfo.parameters.target;
     mailbox = m_frontColorBuffer.mailbox;
     produceSyncToken = m_frontColorBuffer.produceSyncToken;
   } else {
@@ skipping 136 matching lines @@
     m_gl->RenderbufferStorageMultisampleEXT(GL_RENDERBUFFER, m_sampleCount,
                                             GL_DEPTH24_STENCIL8_OES,
                                             size.width(), size.height());
   else if (m_antiAliasingMode == MSAAExplicitResolve)
     m_gl->RenderbufferStorageMultisampleCHROMIUM(GL_RENDERBUFFER, m_sampleCount,
                                                  GL_DEPTH24_STENCIL8_OES,
                                                  size.width(), size.height());
   else
     m_gl->RenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8_OES,
                               size.width(), size.height());
-  // For ES 2.0 contexts DEPTH_STENCIL is not available natively, so we emulate it
-  // at the command buffer level for WebGL contexts.
+  // For ES 2.0 contexts DEPTH_STENCIL is not available natively, so we emulate
+  // it at the command buffer level for WebGL contexts.
   m_gl->FramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
                                 GL_RENDERBUFFER, m_depthStencilBuffer);
   m_gl->BindRenderbuffer(GL_RENDERBUFFER, 0);
 }
 
 bool DrawingBuffer::resizeDefaultFramebuffer(const IntSize& size) {
   // Resize or create m_colorBuffer.
   if (m_colorBuffer.textureId) {
     resizeTextureMemory(&m_colorBuffer, size);
   } else {
@@ skipping 15 matching lines @@
     if (m_gl->CheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
       return false;
   }
 
   m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
   return m_gl->CheckFramebufferStatus(GL_FRAMEBUFFER) ==
          GL_FRAMEBUFFER_COMPLETE;
 }
 
 void DrawingBuffer::clearFramebuffers(GLbitfield clearMask) {
-  // We will clear the multisample FBO, but we also need to clear the non-multisampled buffer.
+  // We will clear the multisample FBO, but we also need to clear the
+  // non-multisampled buffer.
   if (m_multisampleFBO) {
     m_gl->BindFramebuffer(GL_FRAMEBUFFER, m_fbo);
     m_gl->Clear(GL_COLOR_BUFFER_BIT);
   }
 
   m_gl->BindFramebuffer(GL_FRAMEBUFFER,
                         m_multisampleFBO ? m_multisampleFBO : m_fbo);
   m_gl->Clear(clearMask);
 }
 
 void DrawingBuffer::setSize(const IntSize& size) {
   if (m_size == size)
     return;
 
   m_size = size;
 }
 
 IntSize DrawingBuffer::adjustSize(const IntSize& desiredSize,
                                   const IntSize& curSize,
                                   int maxTextureSize) {
   IntSize adjustedSize = desiredSize;
 
-  // Clamp if the desired size is greater than the maximum texture size for the device.
+  // Clamp if the desired size is greater than the maximum texture size for the
+  // device.
   if (adjustedSize.height() > maxTextureSize)
     adjustedSize.setHeight(maxTextureSize);
 
   if (adjustedSize.width() > maxTextureSize)
     adjustedSize.setWidth(maxTextureSize);
 
   return adjustedSize;
 }
 
 bool DrawingBuffer::reset(const IntSize& newSize) {
@@ skipping 394 matching lines @@
   // the public interface for WebGL does not support GL_TEXTURE_RECTANGLE.
   m_gl->BindTexture(GL_TEXTURE_2D, m_texture2DBinding);
 }
 
 bool DrawingBuffer::shouldUseChromiumImage() {
   return RuntimeEnabledFeatures::webGLImageChromiumEnabled() &&
          m_chromiumImageUsage == AllowChromiumImage;
 }
 
 }  // namespace blink