Reformat comments in core/layout up until LayoutTableRow

third_party/WebKit/Source/core/layout/LayoutPart.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Simon Hausmann <hausmann@kde.org>
  *           (C) 2000 Stefan Schimanski (1Stein@gmx.de)
  * Copyright (C) 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 52 matching lines @@
 
   Element* element = toElement(node());
   if (element && element->isFrameOwnerElement())
     toHTMLFrameOwnerElement(element)->setWidget(nullptr);
 
   LayoutReplaced::willBeDestroyed();
 }
 
 void LayoutPart::destroy() {
   willBeDestroyed();
-  // We call clearNode here because LayoutPart is ref counted. This call to destroy
-  // may not actually destroy the layout object. We can keep it around because of
-  // references from the FrameView class. (The actual destruction of the class happens
-  // in postDestroy() which is called from deref()).
+  // We call clearNode here because LayoutPart is ref counted. This call to
+  // destroy may not actually destroy the layout object. We can keep it around
+  // because of references from the FrameView class. (The actual destruction of
+  // the class happens in postDestroy() which is called from deref()).
   //
-  // But, we've told the system we've destroyed the layoutObject, which happens when
-  // the DOM node is destroyed. So there is a good change the DOM node this object
-  // points too is invalid, so we have to clear the node so we make sure we don't
-  // access it in the future.
+  // But, we've told the system we've destroyed the layoutObject, which happens
+  // when the DOM node is destroyed. So there is a good change the DOM node this
+  // object points too is invalid, so we have to clear the node so we make sure
+  // we don't access it in the future.
   clearNode();
   deref();
 }
 
 LayoutPart::~LayoutPart() {
   ASSERT(m_refCount <= 0);
 }
 
 Widget* LayoutPart::widget() const {
   // Plugin widgets are stored in their DOM node.
   Element* element = toElement(node());
 
   if (element && element->isFrameOwnerElement())
     return toHTMLFrameOwnerElement(element)->ownedWidget();
 
   return nullptr;
 }
 
 PaintLayerType LayoutPart::layerTypeRequired() const {
   PaintLayerType type = LayoutReplaced::layerTypeRequired();
   if (type != NoPaintLayer)
     return type;
   return ForcedPaintLayer;
 }
 
 bool LayoutPart::requiresAcceleratedCompositing() const {
-  // There are two general cases in which we can return true. First, if this is a plugin
-  // LayoutObject and the plugin has a layer, then we need a layer. Second, if this is
-  // a LayoutObject with a contentDocument and that document needs a layer, then we need
-  // a layer.
+  // There are two general cases in which we can return true. First, if this is
+  // a plugin LayoutObject and the plugin has a layer, then we need a layer.
+  // Second, if this is a LayoutObject with a contentDocument and that document
+  // needs a layer, then we need a layer.
   if (widget() && widget()->isPluginView() &&
       toPluginView(widget())->platformLayer())
     return true;
 
   if (!node() || !node()->isFrameOwnerElement())
     return false;
 
   HTMLFrameOwnerElement* element = toHTMLFrameOwnerElement(node());
   if (element->contentFrame() && element->contentFrame()->isRemoteFrame())
     return true;
@@ skipping 15 matching lines @@
 
 bool LayoutPart::nodeAtPointOverWidget(
     HitTestResult& result,
     const HitTestLocation& locationInContainer,
     const LayoutPoint& accumulatedOffset,
     HitTestAction action) {
   bool hadResult = result.innerNode();
   bool inside = LayoutReplaced::nodeAtPoint(result, locationInContainer,
                                             accumulatedOffset, action);
 
-  // Check to see if we are really over the widget itself (and not just in the border/padding area).
+  // Check to see if we are really over the widget itself (and not just in the
+  // border/padding area).
   if ((inside || result.isRectBasedTest()) && !hadResult &&
       result.innerNode() == node())
     result.setIsOverWidget(contentBoxRect().contains(result.localPoint()));
   return inside;
 }
 
 bool LayoutPart::nodeAtPoint(HitTestResult& result,
                              const HitTestLocation& locationInContainer,
                              const LayoutPoint& accumulatedOffset,
                              HitTestAction action) {
   if (!widget() || !widget()->isFrameView() ||
       !result.hitTestRequest().allowsChildFrameContent())
     return nodeAtPointOverWidget(result, locationInContainer, accumulatedOffset,
                                  action);
 
-  // A hit test can never hit an off-screen element; only off-screen iframes are throttled;
-  // therefore, hit tests can skip descending into throttled iframes.
+  // A hit test can never hit an off-screen element; only off-screen iframes are
+  // throttled; therefore, hit tests can skip descending into throttled iframes.
   if (toFrameView(widget())->shouldThrottleRendering())
     return nodeAtPointOverWidget(result, locationInContainer, accumulatedOffset,
                                  action);
 
   ASSERT(document().lifecycle().state() >= DocumentLifecycle::CompositingClean);
 
   if (action == HitTestForeground) {
     FrameView* childFrameView = toFrameView(widget());
     LayoutViewItem childRootItem = childFrameView->layoutViewItem();
 
     if (visibleToHitTestRequest(result.hitTestRequest()) &&
         !childRootItem.isNull()) {
       LayoutPoint adjustedLocation = accumulatedOffset + location();
       LayoutPoint contentOffset = LayoutPoint(borderLeft() + paddingLeft(),
                                               borderTop() + paddingTop()) -
                                   LayoutSize(childFrameView->scrollOffsetInt());
       HitTestLocation newHitTestLocation(locationInContainer,
                                          -adjustedLocation - contentOffset);
       HitTestRequest newHitTestRequest(result.hitTestRequest().type() |
                                        HitTestRequest::ChildFrameHitTest);
       HitTestResult childFrameResult(newHitTestRequest, newHitTestLocation);
 
       // The frame's layout and style must be up to date if we reach here.
       bool isInsideChildFrame =
           childRootItem.hitTestNoLifecycleUpdate(childFrameResult);
 
       if (result.hitTestRequest().listBased()) {
         result.append(childFrameResult);
       } else if (isInsideChildFrame) {
-        // Force the result not to be cacheable because the parent
-        // frame should not cache this result; as it won't be notified of
-        // changes in the child.
+        // Force the result not to be cacheable because the parent frame should
+        // not cache this result; as it won't be notified of changes in the
+        // child.
         childFrameResult.setCacheable(false);
         result = childFrameResult;
       }
 
       // Don't trust |isInsideChildFrame|. For rect-based hit-test, returns
       // true only when the hit test rect is totally within the iframe,
       // i.e. nodeAtPointOverWidget() also returns true.
       // Use a temporary HitTestResult because we don't want to collect the
-      // iframe element itself if the hit-test rect is totally within the iframe.
+      // iframe element itself if the hit-test rect is totally within the
+      // iframe.
       if (isInsideChildFrame) {
         if (!locationInContainer.isRectBasedTest())
           return true;
         HitTestResult pointOverWidgetResult = result;
         bool pointOverWidget =
             nodeAtPointOverWidget(pointOverWidgetResult, locationInContainer,
                                   accumulatedOffset, action);
         if (pointOverWidget)
           return true;
         result = pointOverWidgetResult;
@@ skipping 43 matching lines @@
 }
 
 void LayoutPart::paintContents(const PaintInfo& paintInfo,
                                const LayoutPoint& paintOffset) const {
   PartPainter(*this).paintContents(paintInfo, paintOffset);
 }
 
 CursorDirective LayoutPart::getCursor(const LayoutPoint& point,
                                       Cursor& cursor) const {
   if (widget() && widget()->isPluginView()) {
-    // A plugin is responsible for setting the cursor when the pointer is over it.
+    // A plugin is responsible for setting the cursor when the pointer is over
+    // it.
     return DoNotSetCursor;
   }
   return LayoutReplaced::getCursor(point, cursor);
 }
 
 LayoutRect LayoutPart::replacedContentRect() const {
-  // We don't propagate sub-pixel into sub-frame layout, in other words, the rect is snapped
-  // at the document boundary, and sub-pixel movement could cause the sub-frame to layout
-  // due to the 1px snap difference. In order to avoid that, the size of sub-frame is rounded
-  // in advance.
+  // We don't propagate sub-pixel into sub-frame layout, in other words, the
+  // rect is snapped at the document boundary, and sub-pixel movement could
+  // cause the sub-frame to layout due to the 1px snap difference. In order to
+  // avoid that, the size of sub-frame is rounded in advance.
   LayoutRect sizeRoundedRect = contentBoxRect();
   sizeRoundedRect.setSize(LayoutSize(roundedIntSize(sizeRoundedRect.size())));
   return sizeRoundedRect;
 }
 
 void LayoutPart::updateOnWidgetChange() {
   Widget* widget = this->widget();
   if (!widget)
     return;
 
   if (!style())
     return;
 
   if (!needsLayout())
     updateWidgetGeometryInternal();
 
   if (style()->visibility() != EVisibility::Visible) {
     widget->hide();
   } else {
     widget->show();
-    // FIXME: Why do we issue a full paint invalidation in this case, but not the other?
+    // FIXME: Why do we issue a full paint invalidation in this case, but not
+    // the other?
     setShouldDoFullPaintInvalidation();
   }
 }
 
 void LayoutPart::updateWidgetGeometry() {
   Widget* widget = this->widget();
   if (!widget || !node())  // Check the node in case destroy() has been called.
     return;
 
   LayoutRect newFrame = replacedContentRect();
@@ skipping 20 matching lines @@
     frameView->layout();
 
   widget->widgetGeometryMayHaveChanged();
 }
 
 void LayoutPart::updateWidgetGeometryInternal() {
   Widget* widget = this->widget();
   ASSERT(widget);
 
   // Ignore transform here, as we only care about the sub-pixel accumulation.
-  // TODO(trchen): What about multicol? Need a LayoutBox function to query sub-pixel accumulation.
+  // TODO(trchen): What about multicol? Need a LayoutBox function to query
+  // sub-pixel accumulation.
   LayoutPoint absoluteLocation(localToAbsolute(FloatPoint()));
   LayoutRect absoluteReplacedRect = replacedContentRect();
   absoluteReplacedRect.moveBy(absoluteLocation);
 
   IntRect frameRect(IntPoint(),
                     pixelSnappedIntRect(absoluteReplacedRect).size());
-  // Normally the location of the frame rect is ignored by the painter, but currently it is
-  // still used by a family of coordinate conversion function in Widget/FrameView. This is
-  // incorrect because coordinate conversion needs to take transform and into account.
-  // A few callers still use the family of conversion function, including but not exhaustive:
+  // Normally the location of the frame rect is ignored by the painter, but
+  // currently it is still used by a family of coordinate conversion function in
+  // Widget/FrameView. This is incorrect because coordinate conversion needs to
+  // take transform and into account.
+  // A few callers still use the family of conversion function, including but
+  // not exhaustive:
   // FrameView::updateViewportIntersectionIfNeeded()
   // RemoteFrameView::frameRectsChanged().
   // WebPluginContainerImpl::reportGeometry()
   // TODO(trchen): Remove this hack once we fixed all callers.
   FloatRect absoluteBoundingBox =
       localToAbsoluteQuad(FloatRect(replacedContentRect())).boundingBox();
   frameRect.setLocation(roundedIntPoint(absoluteBoundingBox.location()));
 
   // Why is the protector needed?
   RefPtr<LayoutPart> protector(this);
@@ skipping 20 matching lines @@
 }
 
 bool LayoutPart::isThrottledFrameView() const {
   if (!widget() || !widget()->isFrameView())
     return false;
   const FrameView* frameView = toFrameView(widget());
   return frameView->shouldThrottleRendering();
 }
 
 }  // namespace blink