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

third_party/WebKit/Source/platform/graphics/GraphicsLayer.h

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. 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 81 matching lines @@
   void setSquashingDisallowedReasons(SquashingDisallowedReasons);
   void setOwnerNodeId(int);
 
   GraphicsLayer* parent() const { return m_parent; }
   void setParent(GraphicsLayer*);  // Internal use only.
 
   const Vector<GraphicsLayer*>& children() const { return m_children; }
   // Returns true if the child list changed.
   bool setChildren(const GraphicsLayerVector&);
 
-  // Add child layers. If the child is already parented, it will be removed from its old parent.
+  // Add child layers. If the child is already parented, it will be removed from
+  // its old parent.
   void addChild(GraphicsLayer*);
   void addChildBelow(GraphicsLayer*, GraphicsLayer* sibling);
 
   void removeAllChildren();
   void removeFromParent();
 
   GraphicsLayer* maskLayer() const { return m_maskLayer; }
   void setMaskLayer(GraphicsLayer*);
 
   GraphicsLayer* contentsClippingMaskLayer() const {
     return m_contentsClippingMaskLayer;
   }
   void setContentsClippingMaskLayer(GraphicsLayer*);
 
   enum ShouldSetNeedsDisplay { DontSetNeedsDisplay, SetNeedsDisplay };
 
-  // Offset is origin of the layoutObject minus origin of the graphics layer (so either zero or negative).
+  // The offset is the origin of the layoutObject minus the origin of the
+  // graphics layer (so either zero or negative).
   IntSize offsetFromLayoutObject() const {
     return flooredIntSize(m_offsetFromLayoutObject);
   }
   void setOffsetFromLayoutObject(const IntSize&,
                                  ShouldSetNeedsDisplay = SetNeedsDisplay);
   LayoutSize offsetFromLayoutObjectWithSubpixelAccumulation() const;
 
-  // The double version is only used in |updateScrollingLayerGeometry()| for detecting
-  // scroll offset change at floating point precision.
+  // The double version is only used in updateScrollingLayerGeometry() for
+  // detecting a scroll offset change at floating point precision.
   DoubleSize offsetDoubleFromLayoutObject() const {
     return m_offsetFromLayoutObject;
   }
   void setOffsetDoubleFromLayoutObject(const DoubleSize&,
                                        ShouldSetNeedsDisplay = SetNeedsDisplay);
 
-  // The position of the layer (the location of its top-left corner in its parent)
+  // The position of the layer (the location of its top-left corner in its
+  // parent).
   const FloatPoint& position() const { return m_position; }
   void setPosition(const FloatPoint&);
 
   const FloatPoint3D& transformOrigin() const { return m_transformOrigin; }
   void setTransformOrigin(const FloatPoint3D&);
 
   // The size of the layer.
   const FloatSize& size() const { return m_size; }
   void setSize(const FloatSize&);
 
   const TransformationMatrix& transform() const { return m_transform; }
   void setTransform(const TransformationMatrix&);
   void setShouldFlattenTransform(bool);
   void setRenderingContext(int id);
 
   bool masksToBounds() const;
   void setMasksToBounds(bool);
 
   bool drawsContent() const { return m_drawsContent; }
   void setDrawsContent(bool);
 
   bool contentsAreVisible() const { return m_contentsVisible; }
   void setContentsVisible(bool);
 
   void setScrollParent(WebLayer*);
   void setClipParent(WebLayer*);
 
   // For special cases, e.g. drawing missing tiles on Android.
-  // The compositor should never paint this color in normal cases because the Layer
-  // will paint background by itself.
+  // The compositor should never paint this color in normal cases because the
+  // Layer will paint the background by itself.
   void setBackgroundColor(const Color&);
 
   // opaque means that we know the layer contents have no alpha
   bool contentsOpaque() const { return m_contentsOpaque; }
   void setContentsOpaque(bool);
 
   bool backfaceVisibility() const { return m_backfaceVisibility; }
   void setBackfaceVisibility(bool visible);
 
   float opacity() const { return m_opacity; }
@@ skipping 29 matching lines @@
       Image*,
       RespectImageOrientationEnum = DoNotRespectImageOrientation);
   void setContentsToPlatformLayer(WebLayer* layer) { setContentsTo(layer); }
   bool hasContentsLayer() const { return m_contentsLayer; }
 
   // For hosting this GraphicsLayer in a native layer hierarchy.
   WebLayer* platformLayer() const;
 
   int paintCount() const { return m_paintCount; }
 
-  // Return a string with a human readable form of the layer tree, If debug is true
-  // pointers for the layers and timing data will be included in the returned string.
+  // Return a string with a human readable form of the layer tree. If debug is
+  // true, pointers for the layers and timing data will be included in the
+  // returned string.
   String layerTreeAsText(LayerTreeFlags = LayerTreeNormal) const;
 
   std::unique_ptr<JSONObject> layerTreeAsJSON(LayerTreeFlags) const;
 
   void setTracksRasterInvalidations(bool);
   bool isTrackingOrCheckingRasterInvalidations() const {
     return RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled() ||
            m_isTrackingRasterInvalidations;
   }
 
@@ skipping 129 matching lines @@
   bool m_painted : 1;
 
   bool m_isTrackingRasterInvalidations : 1;
 
   GraphicsLayerPaintingPhase m_paintingPhase;
 
   Vector<GraphicsLayer*> m_children;
   GraphicsLayer* m_parent;
 
   GraphicsLayer* m_maskLayer;  // Reference to mask layer. We don't own this.
-  GraphicsLayer*
-      m_contentsClippingMaskLayer;  // Reference to clipping mask layer. We don't own this.
+  GraphicsLayer* m_contentsClippingMaskLayer;  // Reference to clipping mask
+                                               // layer. We don't own this.
 
   IntRect m_contentsRect;
 
   int m_paintCount;
 
   std::unique_ptr<WebContentLayer> m_layer;
   std::unique_ptr<WebImageLayer> m_imageLayer;
   WebLayer* m_contentsLayer;
-  // We don't have ownership of m_contentsLayer, but we do want to know if a given layer is the
-  // same as our current layer in setContentsTo(). Since m_contentsLayer may be deleted at this point,
-  // we stash an ID away when we know m_contentsLayer is alive and use that for comparisons from that point
-  // on.
+  // We don't have ownership of m_contentsLayer, but we do want to know if a
+  // given layer is the same as our current layer in setContentsTo(). Since
+  // |m_contentsLayer| may be deleted at this point, we stash an ID away when we
+  // know |m_contentsLayer| is alive and use that for comparisons from that
+  // point on.
   int m_contentsLayerId;
 
   Vector<LinkHighlight*> m_linkHighlights;
 
   std::unique_ptr<ContentLayerDelegate> m_contentLayerDelegate;
 
   WeakPersistent<ScrollableArea> m_scrollableArea;
   GraphicsLayerDebugInfo m_debugInfo;
   int m_renderingContext3d;
 
   std::unique_ptr<PaintController> m_paintController;
 
   IntRect m_previousInterestRect;
 };
 
 }  // namespace blink
 
 #ifndef NDEBUG
 // Outside the blink namespace for ease of invocation from gdb.
 void PLATFORM_EXPORT showGraphicsLayerTree(const blink::GraphicsLayer*);
 #endif
 
 #endif  // GraphicsLayer_h