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

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositor.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/graphics/compositing/PaintArtifactCompositor.h"
 
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/playback/display_item_list.h"
@@ skipping 104 matching lines @@
 
     if (!rasterInvalidationInfo || rect.IsEmpty())
       return;
 
     RasterInvalidationTracking& tracking =
         ccLayersRasterInvalidationTrackingMap().add(m_ccPictureLayer.get());
 
     tracking.trackedRasterInvalidations.append(*rasterInvalidationInfo);
 
     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 = rasterInvalidationInfo->rect;
       r.inflate(1);
       tracking.rasterInvalidationRegionSinceLastPaint.unite(r);
     }
   }
 
   std::unique_ptr<JSONObject> layerAsJSON() {
     std::unique_ptr<JSONObject> json = JSONObject::create();
     json->setString("name", m_debugName);
     IntSize bounds(m_ccPictureLayer->bounds().width(),
@@ skipping 134 matching lines @@
 }
 
 // cc's property trees use 0 for the root node (always non-null).
 constexpr int kRealRootNodeId = 0;
 // cc allocates special nodes for root effects such as the device scale.
 constexpr int kSecondaryRootNodeId = 1;
 constexpr int kPropertyTreeSequenceNumber = 1;
 
 // Creates a minimal set of property trees for the compositor.
 void setMinimalPropertyTrees(cc::PropertyTrees* propertyTrees, int ownerId) {
-  // cc is hardcoded to use transform node index 1 for device scale and transform.
+  // cc is hardcoded to use transform node index 1 for device scale and
+  // transform.
   cc::TransformTree& transformTree = propertyTrees->transform_tree;
   transformTree.clear();
   cc::TransformNode& transformNode = *transformTree.Node(
       transformTree.Insert(cc::TransformNode(), kRealRootNodeId));
   DCHECK_EQ(transformNode.id, kSecondaryRootNodeId);
   transformNode.source_node_id = transformNode.parent_id;
   transformTree.SetTargetId(transformNode.id, kRealRootNodeId);
   transformTree.SetContentTargetId(transformNode.id, kRealRootNodeId);
 
   // cc is hardcoded to use clip node index 1 for viewport clip.
@@ skipping 22 matching lines @@
   scrollNode.owner_id = ownerId;
   scrollNode.transform_id = kRealRootNodeId;
 }
 
 }  // namespace
 
 std::unique_ptr<PaintArtifactCompositor::ContentLayerClientImpl>
 PaintArtifactCompositor::clientForPaintChunk(
     const PaintChunk& paintChunk,
     const PaintArtifact& paintArtifact) {
-  // TODO(chrishtr): for now, just using a linear walk. In the future we can optimize this by using the same techniques used in
-  // PaintController for display lists.
+  // TODO(chrishtr): for now, just using a linear walk. In the future we can
+  // optimize this by using the same techniques used in PaintController for
+  // display lists.
   for (auto& client : m_contentLayerClients) {
     if (client && client->matches(paintChunk))
       return std::move(client);
   }
 
   return wrapUnique(new ContentLayerClientImpl(
       paintChunk.id
           ? *paintChunk.id
           : paintArtifact.getDisplayItemList()[paintChunk.beginIndex].getId()));
 }
@@ skipping 29 matching lines @@
   if (paintChunk.knownToBeOpaque)
     ccPictureLayer->SetContentsOpaque(true);
   DCHECK(!tracking ||
          tracking->trackedRasterInvalidations.size() ==
              paintChunk.rasterInvalidationRects.size());
   for (unsigned index = 0; index < paintChunk.rasterInvalidationRects.size();
        ++index) {
     IntRect rect(enclosingIntRect(paintChunk.rasterInvalidationRects[index]));
     gfx::Rect ccInvalidationRect(rect.x(), rect.y(), std::max(0, rect.width()),
                                  std::max(0, rect.height()));
+    // Raster paintChunk.rasterInvalidationRects is in the space of the
+    // containing transform node, so need to subtract off the layer offset.
     ccInvalidationRect.Offset(-combinedBounds.OffsetFromOrigin());
-    // Raster paintChunk.rasterInvalidationRects is in the space of the containing transform node, so need to subtract off the layer offset.
     contentLayerClient->setNeedsDisplayRect(
         ccInvalidationRect,
         tracking ? &tracking->trackedRasterInvalidations[index] : nullptr);
   }
 
   newContentLayerClients.append(std::move(contentLayerClient));
   return ccPictureLayer;
 }
 
 namespace {
@@ skipping 264 matching lines @@
   buildEffectNodesRecursively(nextEffect->parent());
   DCHECK_EQ(nextEffect->parent(), currentEffectNode());
 
 #if DCHECK_IS_ON()
   DCHECK(!m_effectNodesConverted.contains(nextEffect))
       << "Malformed paint artifact. Paint chunks under the same effect should "
          "be contiguous.";
   m_effectNodesConverted.add(nextEffect);
 #endif
 
-  // We currently create dummy layers to host effect nodes and corresponding render surface.
-  // This should be removed once cc implements better support for freestanding property trees.
+  // We currently create dummy layers to host effect nodes and corresponding
+  // render surfaces. This should be removed once cc implements better support
+  // for freestanding property trees.
   scoped_refptr<cc::Layer> dummyLayer = cc::Layer::Create();
   m_rootLayer->AddChild(dummyLayer);
 
-  // Also cc assumes a clip node is always created by a layer that creates render surface.
+  // Also cc assumes a clip node is always created by a layer that creates
+  // render surface.
   cc::ClipNode& dummyClip =
       *clipTree().Node(clipTree().Insert(cc::ClipNode(), kSecondaryRootNodeId));
   dummyClip.owner_id = dummyLayer->id();
   dummyClip.transform_id = kRealRootNodeId;
   dummyClip.target_transform_id = kRealRootNodeId;
 
   cc::EffectNode& effectNode = *effectTree().Node(effectTree().Insert(
       cc::EffectNode(), compositorIdForCurrentEffectNode()));
   effectNode.owner_id = dummyLayer->id();
   effectNode.clip_id = dummyClip.id;
@@ skipping 80 matching lines @@
   }
   m_contentLayerClients.clear();
   m_contentLayerClients.swap(newContentLayerClients);
 
   // Mark the property trees as having been rebuilt.
   layerTree->property_trees()->sequence_number = kPropertyTreeSequenceNumber;
   layerTree->property_trees()->needs_rebuild = false;
 }
 
 }  // namespace blink