Rewrap comments to 80 columns in Source/platform/graphics/.

third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridge.cpp

 /*
  * Copyright (C) 2012 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:
  *
  * 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
@@ skipping 37 matching lines @@
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/gl/GrGLTypes.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace {
 enum {
   InvalidMailboxIndex = -1,
-  MaxCanvasAnimationBacklog =
-      2,  // Make sure the the GPU is never more than two animation frames behind.
+  MaxCanvasAnimationBacklog = 2,  // Make sure the the GPU is never more than
+                                  // two animation frames behind.
 };
 }  // namespace
 
 namespace blink {
 
 #if USE_IOSURFACE_FOR_2D_CANVAS
 struct Canvas2DLayerBridge::ImageInfo : public RefCounted<ImageInfo> {
   ImageInfo(std::unique_ptr<gfx::GpuMemoryBuffer>,
             GLuint imageId,
             GLuint textureId);
@@ skipping 128 matching lines @@
   return accelerate;
 }
 
 bool Canvas2DLayerBridge::isAccelerated() const {
   if (m_accelerationMode == DisableAcceleration)
     return false;
   if (isHibernating())
     return false;
   if (m_softwareRenderingWhileHidden)
     return false;
-  if (m_layer)  // We don't check m_surface, so this returns true if context was lost (m_surface is null) with restoration pending.
+  if (m_layer) {
+    // We don't check |m_surface|, so this returns true if context was lost
+    // (|m_surface| is null) with restoration pending.
     return true;
+  }
   if (m_surface)  // && !m_layer is implied
     return false;
 
-  // Whether or not to accelerate is not yet resolved, determine whether immediate presentation
-  // of the canvas would result in the canvas being accelerated. Presentation is assumed to be
-  // a 'PreferAcceleration' operation.
+  // Whether or not to accelerate is not yet resolved. Determine whether
+  // immediate presentation of the canvas would result in the canvas being
+  // accelerated. Presentation is assumed to be a 'PreferAcceleration'
+  // operation.
   return shouldAccelerate(PreferAcceleration);
 }
 
 GLenum Canvas2DLayerBridge::getGLFilter() {
   return m_filterQuality == kNone_SkFilterQuality ? GL_NEAREST : GL_LINEAR;
 }
 
 #if USE_IOSURFACE_FOR_2D_CANVAS
 bool Canvas2DLayerBridge::prepareIOSurfaceMailboxFromImage(
     SkImage* image,
     cc::TextureMailbox* outMailbox) {
-  // Need to flush skia's internal queue because texture is about to be accessed directly
+  // Need to flush skia's internal queue, because the texture is about to be
+  // accessed directly.
   GrContext* grContext = m_contextProvider->grContext();
   grContext->flush();
 
   RefPtr<ImageInfo> imageInfo = createIOSurfaceBackedTexture();
   if (!imageInfo)
     return false;
 
   gpu::gles2::GLES2Interface* gl = contextGL();
   if (!gl)
     return false;
@@ skipping 117 matching lines @@
 
 bool Canvas2DLayerBridge::prepareMailboxFromImage(
     sk_sp<SkImage> image,
     cc::TextureMailbox* outMailbox) {
   createMailboxInfo();
   MailboxInfo& mailboxInfo = m_mailboxes.first();
 
   GrContext* grContext = m_contextProvider->grContext();
   if (!grContext) {
     mailboxInfo.m_image = std::move(image);
-    return true;  // for testing: skip gl stuff when using a mock graphics context.
+    // For testing, skip GL stuff when using a mock graphics context.
+    return true;
   }
 
 #if USE_IOSURFACE_FOR_2D_CANVAS
   if (RuntimeEnabledFeatures::canvas2dImageChromiumEnabled()) {
     if (prepareIOSurfaceMailboxFromImage(image.get(), outMailbox))
       return true;
     // Note: if IOSurface backed texture creation failed we fall back to the
     // non-IOSurface path.
   }
 #endif  // USE_IOSURFACE_FOR_2D_CANVAS
 
   mailboxInfo.m_image = std::move(image);
 
   if (RuntimeEnabledFeatures::forceDisable2dCanvasCopyOnWriteEnabled())
     m_surface->notifyContentWillChange(SkSurface::kRetain_ContentChangeMode);
 
-  // Need to flush skia's internal queue because texture is about to be accessed directly
+  // Need to flush skia's internal queue, because the texture is about to be
+  // accessed directly.
   grContext->flush();
 
   // Because of texture sharing with the compositor, we must invalidate
   // the state cached in skia so that the deferred copy on write
   // in SkSurface_Gpu does not make any false assumptions.
   mailboxInfo.m_image->getTexture()->textureParamsModified();
 
   gpu::gles2::GLES2Interface* gl = contextGL();
   if (!gl)
     return false;
@@ skipping 383 matching lines @@
   gpu::gles2::GLES2Interface* gl = contextGL();
   if (isAccelerated() && gl)
     gl->Flush();
 }
 
 gpu::gles2::GLES2Interface* Canvas2DLayerBridge::contextGL() {
   // Check on m_layer is necessary because contextGL() may be called during
   // the destruction of m_layer
   if (m_layer && m_accelerationMode != DisableAcceleration &&
       !m_destructionInProgress) {
-    // Call checkSurfaceValid to ensure rate limiter is disabled if context is lost.
+    // Call checkSurfaceValid to ensure the rate limiter is disabled if the
+    // context is lost.
     if (!checkSurfaceValid())
       return nullptr;
   }
   return m_contextProvider ? m_contextProvider->contextGL() : nullptr;
 }
 
 bool Canvas2DLayerBridge::checkSurfaceValid() {
   DCHECK(!m_destructionInProgress);
   if (m_destructionInProgress)
     return false;
@@ skipping 35 matching lines @@
   if (sharedGL && sharedGL->GetGraphicsResetStatusKHR() == GL_NO_ERROR) {
     GrContext* grCtx = m_contextProvider->grContext();
     bool surfaceIsAccelerated;
     sk_sp<SkSurface> surface(createSkSurface(grCtx, m_size, m_msaaSampleCount,
                                              m_opacityMode, m_colorSpace,
                                              &surfaceIsAccelerated));
 
     if (!m_surface)
       reportSurfaceCreationFailure();
 
-    // Current paradigm does support switching from accelerated to non-accelerated, which would be tricky
-    // due to changes to the layer tree, which can only happen at specific times during the document lifecycle.
+    // The current paradigm does not support switching from accelerated to
+    // non-accelerated, which would be tricky due to changes to the layer tree,
+    // which can only happen at specific times during the document lifecycle.
     // Therefore, we can only accept the restored surface if it is accelerated.
     if (surface && surfaceIsAccelerated) {
       m_surface = std::move(surface);
       // FIXME: draw sad canvas picture into new buffer crbug.com/243842
     }
   }
   if (m_imageBuffer)
     m_imageBuffer->updateGPUMemoryUsage();
 
   return m_surface.get();
@@ skipping 92 matching lines @@
   auto firstMailbox = m_mailboxes.begin();
 
   while (true) {
     --releasedMailboxInfo;
     if (releasedMailboxInfo->m_mailbox == mailbox)
       break;
     DCHECK(releasedMailboxInfo != firstMailbox);
   }
 
   if (!contextLost) {
-    // Invalidate texture state in case the compositor altered it since the copy-on-write.
+    // Invalidate texture state in case the compositor altered it since the
+    // copy-on-write.
     if (releasedMailboxInfo->m_image) {
 #if USE_IOSURFACE_FOR_2D_CANVAS
       DCHECK(!releasedMailboxInfo->m_imageInfo);
 #endif  // USE_IOSURFACE_FOR_2D_CANVAS
       if (syncToken.HasData()) {
         contextGL()->WaitSyncTokenCHROMIUM(syncToken.GetConstData());
       }
       GrTexture* texture = releasedMailboxInfo->m_image->getTexture();
       if (texture) {
         if (lostResource) {
           texture->abandon();
         } else {
           texture->textureParamsModified();
-          // Break the mailbox association to avoid leaking mailboxes every time skia recycles a texture.
+          // Break the mailbox association to avoid leaking mailboxes every time
+          // skia recycles a texture.
           gpu::gles2::GLES2Interface* gl = contextGL();
           if (gl)
             gl->ProduceTextureDirectCHROMIUM(
                 0, GL_TEXTURE_2D, releasedMailboxInfo->m_mailbox.name);
         }
       }
     }
 
 #if USE_IOSURFACE_FOR_2D_CANVAS
     if (releasedMailboxInfo->m_imageInfo && !lostResource) {
@@ skipping 130 matching lines @@
     default;
 
 void Canvas2DLayerBridge::Logger::reportHibernationEvent(
     HibernationEvent event) {
   DEFINE_STATIC_LOCAL(EnumerationHistogram, hibernationHistogram,
                       ("Canvas.HibernationEvents", HibernationEventCount));
   hibernationHistogram.count(event);
 }
 
 }  // namespace blink