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

third_party/WebKit/Source/platform/graphics/GraphicsLayer.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 329 matching lines @@
                         m_paintController->imagePainted());
 }
 
 void GraphicsLayer::updateChildList() {
   WebLayer* childHost = m_layer->layer();
   childHost->removeAllChildren();
 
   clearContentsLayerIfUnregistered();
 
   if (m_contentsLayer) {
-    // FIXME: add the contents layer in the correct order with negative z-order children.
-    // This does not cause visible rendering issues because currently contents layers are only used
-    // for replaced elements that don't have children.
+    // FIXME: Add the contents layer in the correct order with negative z-order
+    // children. This does not currently cause visible rendering issues because
+    // contents layers are only used for replaced elements that don't have
+    // children.
     childHost->addChild(m_contentsLayer);
   }
 
   for (size_t i = 0; i < m_children.size(); ++i)
     childHost->addChild(m_children[i]->platformLayer());
 
   for (size_t i = 0; i < m_linkHighlights.size(); ++i)
     childHost->addChild(m_linkHighlights[i]->layer());
 }
 
 void GraphicsLayer::updateLayerIsDrawable() {
-  // For the rest of the accelerated compositor code, there is no reason to make a
-  // distinction between drawsContent and contentsVisible. So, for m_layer->layer(), these two
-  // flags are combined here. m_contentsLayer shouldn't receive the drawsContent flag
-  // so it is only given contentsVisible.
+  // For the rest of the accelerated compositor code, there is no reason to make
+  // a distinction between drawsContent and contentsVisible. So, for
+  // m_layer->layer(), these two flags are combined here. |m_contentsLayer|
+  // shouldn't receive the drawsContent flag, so it is only given
+  // contentsVisible.
 
   m_layer->layer()->setDrawsContent(m_drawsContent && m_contentsVisible);
   if (WebLayer* contentsLayer = contentsLayerIfRegistered())
     contentsLayer->setDrawsContent(m_contentsVisible);
 
   if (m_drawsContent) {
     m_layer->layer()->invalidate();
     for (size_t i = 0; i < m_linkHighlights.size(); ++i)
       m_linkHighlights[i]->invalidate();
   }
@@ skipping 65 matching lines @@
 
 void GraphicsLayer::setupContentsLayer(WebLayer* contentsLayer) {
   ASSERT(contentsLayer);
   m_contentsLayer = contentsLayer;
   m_contentsLayerId = m_contentsLayer->id();
 
   m_contentsLayer->setLayerClient(this);
   m_contentsLayer->setTransformOrigin(FloatPoint3D());
   m_contentsLayer->setUseParentBackfaceVisibility(true);
 
-  // It is necessary to call setDrawsContent as soon as we receive the new contentsLayer, for
-  // the correctness of early exit conditions in setDrawsContent() and setContentsVisible().
+  // It is necessary to call setDrawsContent as soon as we receive the new
+  // contentsLayer, for the correctness of early exit conditions in
+  // setDrawsContent() and setContentsVisible().
   m_contentsLayer->setDrawsContent(m_contentsVisible);
 
-  // Insert the content layer first. Video elements require this, because they have
-  // shadow content that must display in front of the video.
+  // Insert the content layer first. Video elements require this, because they
+  // have shadow content that must display in front of the video.
   m_layer->layer()->insertChild(m_contentsLayer, 0);
   WebLayer* borderWebLayer = m_contentsClippingMaskLayer
                                  ? m_contentsClippingMaskLayer->platformLayer()
                                  : 0;
   m_contentsLayer->setMaskLayer(borderWebLayer);
 
   m_contentsLayer->setRenderingContext(m_renderingContext3d);
 }
 
 void GraphicsLayer::clearContentsLayerIfUnregistered() {
@@ skipping 51 matching lines @@
   if (m_isTrackingRasterInvalidations) {
     RasterInvalidationInfo info;
     info.client = &client;
     info.clientDebugName = client.debugName();
     info.rect = rect;
     info.reason = reason;
     tracking.trackedRasterInvalidations.append(info);
   }
 
   if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
-    // TODO(crbug.com/496260): Some antialiasing effects overflows the paint invalidation rect.
+    // TODO(crbug.com/496260): Some antialiasing effects overflow the paint
+    // invalidation rect.
     IntRect r = rect;
     r.inflate(1);
     tracking.rasterInvalidationRegionSinceLastPaint.unite(r);
   }
 }
 
 template <typename T>
 static std::unique_ptr<JSONArray> pointAsJSONArray(const T& point) {
   std::unique_ptr<JSONArray> array = JSONArray::create();
   array->pushDouble(point.x());
@@ skipping 269 matching lines @@
 void GraphicsLayer::setOwnerNodeId(int nodeId) {
   m_debugInfo.setOwnerNodeId(nodeId);
 }
 
 void GraphicsLayer::setPosition(const FloatPoint& point) {
   m_position = point;
   platformLayer()->setPosition(m_position);
 }
 
 void GraphicsLayer::setSize(const FloatSize& size) {
-  // We are receiving negative sizes here that cause assertions to fail in the compositor. Clamp them to 0 to
-  // avoid those assertions.
-  // FIXME: This should be an ASSERT instead, as negative sizes should not exist in WebCore.
+  // We are receiving negative sizes here that cause assertions to fail in the
+  // compositor. Clamp them to 0 to avoid those assertions.
+  // FIXME: This should be an ASSERT instead, as negative sizes should not exist
+  // in WebCore.
   FloatSize clampedSize = size;
   if (clampedSize.width() < 0 || clampedSize.height() < 0)
     clampedSize = FloatSize();
 
   if (clampedSize == m_size)
     return;
 
   m_size = clampedSize;
 
   m_layer->layer()->setBounds(flooredIntSize(m_size));
@@ skipping 34 matching lines @@
 
 bool GraphicsLayer::masksToBounds() const {
   return m_layer->layer()->masksToBounds();
 }
 
 void GraphicsLayer::setMasksToBounds(bool masksToBounds) {
   m_layer->layer()->setMasksToBounds(masksToBounds);
 }
 
 void GraphicsLayer::setDrawsContent(bool drawsContent) {
-  // Note carefully this early-exit is only correct because we also properly call
-  // WebLayer::setDrawsContent whenever m_contentsLayer is set to a new layer in setupContentsLayer().
+  // NOTE: This early-exit is only correct because we also properly call
+  // WebLayer::setDrawsContent() whenever |m_contentsLayer| is set to a new
+  // layer in setupContentsLayer().
   if (drawsContent == m_drawsContent)
     return;
 
   m_drawsContent = drawsContent;
   updateLayerIsDrawable();
 
   if (!drawsContent && m_paintController)
     m_paintController.reset();
 }
 
 void GraphicsLayer::setContentsVisible(bool contentsVisible) {
-  // Note carefully this early-exit is only correct because we also properly call
-  // WebLayer::setDrawsContent whenever m_contentsLayer is set to a new layer in setupContentsLayer().
+  // NOTE: This early-exit is only correct because we also properly call
+  // WebLayer::setDrawsContent() whenever |m_contentsLayer| is set to a new
+  // layer in setupContentsLayer().
   if (contentsVisible == m_contentsVisible)
     return;
 
   m_contentsVisible = contentsVisible;
   updateLayerIsDrawable();
 }
 
 void GraphicsLayer::setClipParent(WebLayer* parent) {
   m_hasClipParent = !!parent;
   m_layer->layer()->setClipParent(parent);
@@ skipping 74 matching lines @@
   if (WebLayer* contentsLayer = contentsLayerIfRegistered()) {
     contentsLayer->invalidate();
     trackRasterInvalidation(*this, m_contentsRect, PaintInvalidationFull);
   }
 }
 
 void GraphicsLayer::setNeedsDisplay() {
   if (!drawsContent())
     return;
 
-  // TODO(chrishtr): stop invalidating the rects once FrameView::paintRecursively does so.
+  // TODO(chrishtr): Stop invalidating the rects once
+  // FrameView::paintRecursively() does so.
   m_layer->layer()->invalidate();
   for (size_t i = 0; i < m_linkHighlights.size(); ++i)
     m_linkHighlights[i]->invalidate();
   getPaintController().invalidateAll();
 
   trackRasterInvalidation(*this, IntRect(IntPoint(), expandedIntSize(m_size)),
                           PaintInvalidationFull);
 }
 
 void GraphicsLayer::setNeedsDisplayInRect(
@@ skipping 109 matching lines @@
   else
     m_layer->layer()->setScrollClient(this);
 }
 
 void GraphicsLayer::didScroll() {
   if (m_scrollableArea) {
     DoublePoint newPosition =
         -m_scrollableArea->scrollOrigin() +
         toDoubleSize(m_layer->layer()->scrollPositionDouble());
 
-    // FrameView::setScrollPosition doesn't work for compositor commits (interacts poorly with programmatic scroll animations)
-    // so we need to use the ScrollableArea version. The FrameView method should go away soon anyway.
+    // FrameView::setScrollPosition() doesn't work for compositor commits
+    // (interacts poorly with programmatic scroll animations) so we need to use
+    // the ScrollableArea version. The FrameView method should go away soon
+    // anyway.
     m_scrollableArea->ScrollableArea::setScrollPosition(newPosition,
                                                         CompositorScroll);
   }
 }
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 GraphicsLayer::TakeDebugInfo(cc::Layer* layer) {
   std::unique_ptr<base::trace_event::TracedValue> tracedValue(
       m_debugInfo.asTracedValue());
   tracedValue->SetString(
@@ skipping 113 matching lines @@
         *newBitmap.getAddr32(bitmapX, bitmapY) =
             SkColorSetARGB(0xFF, 0xA0, 0, 0);  // Dark red.
       } else {
         *newBitmap.getAddr32(bitmapX, bitmapY) = SK_ColorTRANSPARENT;
       }
     }
   }
   oldBitmap.unlockPixels();
   newBitmap.unlockPixels();
 
-  // Visualize under-invalidations by overlaying the new bitmap (containing red pixels indicating under-invalidations,
-  // and transparent pixels otherwise) onto the painting.
+  // Visualize under-invalidations by overlaying the new bitmap (containing red
+  // pixels indicating under-invalidations, and transparent pixels otherwise)
+  // onto the painting.
   SkPictureRecorder recorder;
   recorder.beginRecording(rect);
   recorder.getRecordingCanvas()->drawBitmap(newBitmap, rect.x(), rect.y());
   sk_sp<SkPicture> picture = recorder.finishRecordingAsPicture();
   getPaintController().appendDebugDrawingAfterCommit(
       *this, picture, offsetFromLayoutObjectWithSubpixelAccumulation());
 }
 
 }  // namespace blink
 
 #ifndef NDEBUG
 void showGraphicsLayerTree(const blink::GraphicsLayer* layer) {
   if (!layer) {
     fprintf(stderr, "Cannot showGraphicsLayerTree for (nil).\n");
     return;
   }
 
   String output = layer->layerTreeAsText(blink::LayerTreeIncludesDebugInfo);
   fprintf(stderr, "%s\n", output.utf8().data());
 }
 #endif