DO NOT COMMIT: Results of running new (proposed) clang-format on Blink

third_party/WebKit/Source/core/paint/PaintLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
  * reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
@@ skipping 739 matching lines @@
 
   // Transformed or preserve-3d descendants can only be in the z-order lists,
   // not in the normal flow list, so we only need to check those.
   PaintLayerStackingNodeIterator iterator(
       *m_stackingNode.get(), PositiveZOrderChildren | NegativeZOrderChildren);
   while (PaintLayerStackingNode* node = iterator.next()) {
     const PaintLayer& childLayer = *node->layer();
     bool childHas3D = false;
     // If the child lives in a 3d hierarchy, then the layer at the root of
     // that hierarchy needs the m_has3DTransformedDescendant set.
-    if (childLayer.preserves3D() && (childLayer.has3DTransform() ||
-                                     childLayer.has3DTransformedDescendant()))
+    if (childLayer.preserves3D() &&
+        (childLayer.has3DTransform() ||
+         childLayer.has3DTransformedDescendant()))
       childHas3D = true;
     else if (childLayer.has3DTransform())
       childHas3D = true;
 
     if (childHas3D) {
       m_has3DTransformedDescendant = true;
       break;
     }
   }
 }
@@ skipping 733 matching lines @@
     m_stackingNode = nullptr;
 }
 
 void PaintLayer::updateScrollableArea() {
   DCHECK(!m_scrollableArea);
   if (requiresScrollableArea())
     m_scrollableArea = PaintLayerScrollableArea::create(*this);
 }
 
 bool PaintLayer::hasOverflowControls() const {
-  return m_scrollableArea && (m_scrollableArea->hasScrollbar() ||
-                              m_scrollableArea->scrollCorner() ||
-                              layoutObject()->style()->resize() != RESIZE_NONE);
+  return m_scrollableArea &&
+         (m_scrollableArea->hasScrollbar() ||
+          m_scrollableArea->scrollCorner() ||
+          layoutObject()->style()->resize() != RESIZE_NONE);
 }
 
 void PaintLayer::appendSingleFragmentIgnoringPagination(
     PaintLayerFragments& fragments,
     const PaintLayer* rootLayer,
     const LayoutRect& dirtyRect,
     ClipRectsCacheSlot clipRectsCacheSlot,
     PaintLayer::GeometryMapperOption geometryMapperOption,
     OverlayScrollbarClipBehavior overlayScrollbarClipBehavior,
     ShouldRespectOverflowClipType respectOverflowClip,
@@ skipping 197 matching lines @@
       // crbug.com/522109.
       // TODO(majidvp): This should apply more consistently across different
       // event types and we should not use RequestType for it. Perhaps best for
       // it to be done at a higher level. See http://crbug.com/505825
     } else if ((request.active() || request.release()) &&
                !request.isChildFrameHitTest()) {
       fallback = true;
     }
     if (fallback) {
       layoutObject()->updateHitTestResult(
-          result, toLayoutView(layoutObject())
-                      ->flipForWritingMode(hitTestLocation.point()));
+          result,
+          toLayoutView(layoutObject())
+              ->flipForWritingMode(hitTestLocation.point()));
       insideLayer = this;
 
       // Don't cache this result since it really wasn't a true hit.
       result.setCacheable(false);
     }
   }
 
   // Now determine if the result is inside an anchor - if the urlElement isn't
   // already set.
   Node* node = result.innerNode();
@@ skipping 458 matching lines @@
                                  const HitTestLocation& hitTestLocation,
                                  HitTestFilter hitTestFilter) const {
   DCHECK(isSelfPaintingLayer() || hasSelfPaintingLayerDescendant());
 
   if (!layoutObject()->hitTest(
           result, hitTestLocation,
           toLayoutPoint(layerBounds.location() - layoutBoxLocation()),
           hitTestFilter)) {
     // It's wrong to set innerNode, but then claim that you didn't hit anything,
     // unless it is a rect-based test.
-    DCHECK(!result.innerNode() || (result.hitTestRequest().listBased() &&
-                                   result.listBasedTestResult().size()));
+    DCHECK(!result.innerNode() ||
+           (result.hitTestRequest().listBased() &&
+            result.listBasedTestResult().size()));
     return false;
   }
 
   if (!result.innerNode()) {
     // We hit something anonymous, and we didn't find a DOM node ancestor in
     // this layer.
 
     if (layoutObject()->isLayoutFlowThread()) {
       // For a flow thread it's safe to just say that we didn't hit anything.
       // That means that we'll continue as normally, and eventually hit a column
@@ skipping 55 matching lines @@
       if (!depthSortDescendants)
         break;
     }
   }
 
   return resultLayer;
 }
 
 FloatRect PaintLayer::boxForFilterOrMask() const {
   return FloatRect(physicalBoundingBoxIncludingStackingChildren(
-      LayoutPoint(), PaintLayer::CalculateBoundsOptions::
-                         IncludeTransformsAndCompositedChildLayers));
+      LayoutPoint(),
+      PaintLayer::CalculateBoundsOptions::
+          IncludeTransformsAndCompositedChildLayers));
 }
 
 LayoutRect PaintLayer::boxForClipPath() const {
   if (!layoutObject()->isBox()) {
     SECURITY_DCHECK(layoutObject()->isLayoutInline());
     const LayoutInline& layoutInline = toLayoutInline(*layoutObject());
     // This somewhat convoluted computation matches what Gecko does.
     // See crbug.com/641907.
     LayoutRect inlineBBox = layoutInline.linesBoundingBox();
     const InlineFlowBox* flowBox = layoutInline.firstLineBox();
@@ skipping 146 matching lines @@
       const_cast<PaintLayer*>(this)->stackingNode());
 #endif
 
   PaintLayerStackingNodeIterator iterator(*this->stackingNode(), AllChildren);
   while (PaintLayerStackingNode* node = iterator.next()) {
     // Here we exclude both directly composited layers and squashing layers
     // because those Layers don't paint into the graphics layer
     // for this Layer. For example, the bounds of squashed Layers
     // will be included in the computation of the appropriate squashing
     // GraphicsLayer.
-    if (options != PaintLayer::CalculateBoundsOptions::
-                       IncludeTransformsAndCompositedChildLayers &&
+    if (options !=
+            PaintLayer::CalculateBoundsOptions::
+                IncludeTransformsAndCompositedChildLayers &&
         node->layer()->compositingState() != NotComposited)
       continue;
     result.unite(node->layer()->boundingBoxForCompositingInternal(
         compositedLayer, this, options));
   }
 }
 
 LayoutRect PaintLayer::physicalBoundingBoxIncludingStackingChildren(
     const LayoutPoint& offsetFromRoot,
     CalculateBoundsOptions options) const {
@@ skipping 53 matching lines @@
 
   result.intersect(physicalBoundingBox(LayoutPoint()));
 
   expandRectForStackingChildren(compositedLayer, result, options);
 
   // Only enlarge by the filter outsets if we know the filter is going to be
   // rendered in software.  Accelerated filters will handle their own outsets.
   if (paintsWithFilters())
     result = mapLayoutRectForFilter(result);
 
-  if (transform() && (options == IncludeTransformsAndCompositedChildLayers ||
-                      ((paintsWithTransform(GlobalPaintNormalPhase) &&
-                        (this != &compositedLayer ||
-                         options == MaybeIncludeTransformForAncestorLayer)))))
+  if (transform() &&
+      (options == IncludeTransformsAndCompositedChildLayers ||
+       ((paintsWithTransform(GlobalPaintNormalPhase) &&
+         (this != &compositedLayer ||
+          options == MaybeIncludeTransformForAncestorLayer)))))
     result = transform()->mapRect(result);
 
   if (shouldFragmentCompositedBounds(&compositedLayer)) {
     convertFromFlowThreadToVisualBoundingBoxInAncestor(&compositedLayer,
                                                        result);
     return result;
   }
 
   if (stackingParent) {
     LayoutPoint delta;
@@ skipping 672 matching lines @@
 }
 
 void showLayerTree(const blink::LayoutObject* layoutObject) {
   if (!layoutObject) {
     LOG(INFO) << "Cannot showLayerTree. Root is (nil)";
     return;
   }
   showLayerTree(layoutObject->enclosingLayer());
 }
 #endif