reflow comments in web/

third_party/WebKit/Source/web/LinkHighlightImpl.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 162 matching lines @@
         point = roundedIntPoint(targetSpaceQuad.p2());
         break;
       case 2:
         point = roundedIntPoint(targetSpaceQuad.p3());
         break;
       case 3:
         point = roundedIntPoint(targetSpaceQuad.p4());
         break;
     }
 
-    // FIXME: this does not need to be absolute, just in the paint invalidation container's space.
+    // FIXME: this does not need to be absolute, just in the paint invalidation
+    // container's space.
     point = targetLayoutObject->frame()->view()->contentsToRootFrame(point);
     point =
         paintInvalidationContainer.frame()->view()->rootFrameToContents(point);
     FloatPoint floatPoint =
         paintInvalidationContainer.absoluteToLocal(point, UseTransforms);
     PaintLayer::mapPointInPaintInvalidationContainerToBacking(
         paintInvalidationContainer, floatPoint);
 
     switch (i) {
       case 0:
         compositedSpaceQuad.setP1(floatPoint);
         break;
       case 1:
         compositedSpaceQuad.setP2(floatPoint);
         break;
       case 2:
         compositedSpaceQuad.setP3(floatPoint);
         break;
       case 3:
         compositedSpaceQuad.setP4(floatPoint);
         break;
     }
   }
 }
 
 static void addQuadToPath(const FloatQuad& quad, Path& path) {
-  // FIXME: Make this create rounded quad-paths, just like the axis-aligned case.
+  // FIXME: Make this create rounded quad-paths, just like the axis-aligned
+  // case.
   path.moveTo(quad.p1());
   path.addLineTo(quad.p2());
   path.addLineTo(quad.p3());
   path.addLineTo(quad.p4());
   path.closeSubpath();
 }
 
 void LinkHighlightImpl::computeQuads(const Node& node,
                                      Vector<FloatQuad>& outQuads) const {
   if (!node.layoutObject())
     return;
 
   LayoutObject* layoutObject = node.layoutObject();
 
-  // For inline elements, absoluteQuads will return a line box based on the line-height
-  // and font metrics, which is technically incorrect as replaced elements like images
-  // should use their intristic height and expand the linebox  as needed. To get an
-  // appropriately sized highlight we descend into the children and have them add their
-  // boxes.
+  // For inline elements, absoluteQuads will return a line box based on the
+  // line-height and font metrics, which is technically incorrect as replaced
+  // elements like images should use their intristic height and expand the
+  // linebox  as needed. To get an appropriately sized highlight we descend
+  // into the children and have them add their boxes.
   if (layoutObject->isLayoutInline()) {
     for (Node* child = LayoutTreeBuilderTraversal::firstChild(node); child;
          child = LayoutTreeBuilderTraversal::nextSibling(*child))
       computeQuads(*child, outQuads);
   } else {
-    // FIXME: this does not need to be absolute, just in the paint invalidation container's space.
+    // FIXME: this does not need to be absolute, just in the paint invalidation
+    // container's space.
     layoutObject->absoluteQuads(outQuads);
   }
 }
 
 bool LinkHighlightImpl::computeHighlightLayerPathAndPosition(
     const LayoutBoxModelObject& paintInvalidationContainer) {
   if (!m_node || !m_node->layoutObject() || !m_currentGraphicsLayer)
     return false;
 
   // FIXME: This is defensive code to avoid crashes such as those described in
   // crbug.com/440887. This should be cleaned up once we fix the root cause of
   // of the paint invalidation container not being composited.
   if (!paintInvalidationContainer.layer()->compositedLayerMapping() &&
       !paintInvalidationContainer.layer()->groupedMapping())
     return false;
 
   // Get quads for node in absolute coordinates.
   Vector<FloatQuad> quads;
   computeQuads(*m_node, quads);
   DCHECK(quads.size());
   Path newPath;
 
   for (size_t quadIndex = 0; quadIndex < quads.size(); ++quadIndex) {
     FloatQuad absoluteQuad = quads[quadIndex];
 
-    // Scrolling content layers have the same offset from layout object as the non-scrolling layers. Thus we need
-    // to adjust for their scroll offset.
+    // Scrolling content layers have the same offset from layout object as the
+    // non-scrolling layers. Thus we need to adjust for their scroll offset.
     if (m_isScrollingGraphicsLayer) {
       DoubleSize adjustedScrollOffset = paintInvalidationContainer.layer()
                                             ->getScrollableArea()
                                             ->adjustedScrollOffset();
       absoluteQuad.move(adjustedScrollOffset.width(),
                         adjustedScrollOffset.height());
     }
 
-    // Transform node quads in target absolute coords to local coordinates in the compositor layer.
+    // Transform node quads in target absolute coords to local coordinates in
+    // the compositor layer.
     FloatQuad transformedQuad;
     convertTargetSpaceQuadToCompositedLayer(
         absoluteQuad, m_node->layoutObject(), paintInvalidationContainer,
         transformedQuad);
 
-    // FIXME: for now, we'll only use rounded paths if we have a single node quad. The reason for this is that
-    // we may sometimes get a chain of adjacent boxes (e.g. for text nodes) which end up looking like sausage
-    // links: these should ideally be merged into a single rect before creating the path, but that's
-    // another CL.
+    // FIXME: for now, we'll only use rounded paths if we have a single node
+    // quad. The reason for this is that we may sometimes get a chain of
+    // adjacent boxes (e.g. for text nodes) which end up looking like sausage
+    // links: these should ideally be merged into a single rect before creating
+    // the path, but that's another CL.
     if (quads.size() == 1 && transformedQuad.isRectilinear() &&
         !m_owningWebViewImpl->settingsImpl()
              ->mockGestureTapHighlightsEnabled()) {
       FloatSize rectRoundingRadii(3, 3);
       newPath.addRoundedRect(transformedQuad.boundingBox(), rectRoundingRadii);
     } else {
       addQuadToPath(transformedQuad, newPath);
     }
   }
 
@@ skipping 51 matching lines @@
 
   m_contentLayer->layer()->setOpacity(startOpacity);
 
   std::unique_ptr<CompositorFloatAnimationCurve> curve =
       CompositorFloatAnimationCurve::create();
 
   const auto& timingFunction = *CubicBezierTimingFunction::preset(
       CubicBezierTimingFunction::EaseType::EASE);
 
   curve->addKeyframe(CompositorFloatKeyframe(0, startOpacity, timingFunction));
-  // Make sure we have displayed for at least minPreFadeDuration before starting to fade out.
+  // Make sure we have displayed for at least minPreFadeDuration before starting
+  // to fade out.
   float extraDurationRequired = std::max(
       0.f, minPreFadeDuration -
                static_cast<float>(monotonicallyIncreasingTime() - m_startTime));
   if (extraDurationRequired)
     curve->addKeyframe(CompositorFloatKeyframe(extraDurationRequired,
                                                startOpacity, timingFunction));
   // For layout tests we don't fade out.
   curve->addKeyframe(CompositorFloatKeyframe(
       fadeDuration + extraDurationRequired, layoutTestMode() ? startOpacity : 0,
       timingFunction));
@@ skipping 23 matching lines @@
   clearGraphicsLayerLinkHighlightPointer();
   releaseResources();
 }
 
 class LinkHighlightDisplayItemClientForTracking : public DisplayItemClient {
   String debugName() const final { return "LinkHighlight"; }
   LayoutRect visualRect() const final { return LayoutRect(); }
 };
 
 void LinkHighlightImpl::updateGeometry() {
-  // To avoid unnecessary updates (e.g. other entities have requested animations from our WebViewImpl),
-  // only proceed if we actually requested an update.
+  // To avoid unnecessary updates (e.g. other entities have requested animations
+  // from our WebViewImpl), only proceed if we actually requested an update.
   if (!m_geometryNeedsUpdate)
     return;
 
   m_geometryNeedsUpdate = false;
 
   bool hasLayoutObject = m_node && m_node->layoutObject();
   if (hasLayoutObject) {
     const LayoutBoxModelObject& paintInvalidationContainer =
         m_node->layoutObject()->containerForPaintInvalidation();
     attachLinkHighlightToCompositingLayer(paintInvalidationContainer);
     if (computeHighlightLayerPathAndPosition(paintInvalidationContainer)) {
-      // We only need to invalidate the layer if the highlight size has changed, otherwise
-      // we can just re-position the layer without needing to repaint.
+      // We only need to invalidate the layer if the highlight size has changed,
+      // otherwise we can just re-position the layer without needing to
+      // repaint.
       m_contentLayer->layer()->invalidate();
 
       if (m_currentGraphicsLayer)
         m_currentGraphicsLayer->trackPaintInvalidation(
             LinkHighlightDisplayItemClientForTracking(),
             enclosingIntRect(
                 FloatRect(layer()->position().x, layer()->position().y,
                           layer()->bounds().width, layer()->bounds().height)),
             PaintInvalidationFull);
     }
   } else {
     clearGraphicsLayerLinkHighlightPointer();
     releaseResources();
   }
 }
 
 void LinkHighlightImpl::clearCurrentGraphicsLayer() {
   m_currentGraphicsLayer = 0;
   m_geometryNeedsUpdate = true;
 }
 
 void LinkHighlightImpl::invalidate() {
-  // Make sure we update geometry on the next callback from WebViewImpl::layout().
+  // Make sure we update geometry on the next callback from
+  // WebViewImpl::layout().
   m_geometryNeedsUpdate = true;
 }
 
 WebLayer* LinkHighlightImpl::layer() {
   return clipLayer();
 }
 
 CompositorAnimationPlayer* LinkHighlightImpl::compositorPlayer() const {
   return m_compositorPlayer.get();
 }
 
 }  // namespace blink