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

third_party/WebKit/Source/modules/canvas2d/CanvasPathMethods.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc.
  * All rights reserved.
  * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  * Copyright (C) 2012, 2013 Intel Corporation. All rights reserved.
  * Copyright (C) 2012, 2013 Adobe Systems Incorporated. All rights reserved.
@@ skipping 248 matching lines @@
   ASSERT(startAngle >= 0 && startAngle < twoPiFloat);
   ASSERT((anticlockwise && (startAngle - endAngle) >= 0) ||
          (!anticlockwise && (endAngle - startAngle) >= 0));
 
   FloatPoint center(x, y);
   AffineTransform rotationMatrix;
   rotationMatrix.rotateRadians(rotation);
   // First, if the object's path has any subpaths, then the method must add a
   // straight line from the last point in the subpath to the start point of the
   // arc.
-  lineToFloatPoint(path, center +
-                             rotationMatrix.mapPoint(getPointOnEllipse(
-                                 radiusX, radiusY, startAngle)));
+  lineToFloatPoint(path,
+                   center +
+                       rotationMatrix.mapPoint(
+                           getPointOnEllipse(radiusX, radiusY, startAngle)));
   if ((!radiusX && !radiusY) || startAngle == endAngle)
     return;
 
   if (!anticlockwise) {
     // startAngle - fmodf(startAngle, piOverTwoFloat) + piOverTwoFloat is the
     // one of (0, 0.5Pi, Pi, 1.5Pi, 2Pi) that is the closest to startAngle on
     // the clockwise direction.
     for (float angle =
              startAngle - fmodf(startAngle, piOverTwoFloat) + piOverTwoFloat;
          angle < endAngle; angle += piOverTwoFloat)
-      lineToFloatPoint(path, center +
-                                 rotationMatrix.mapPoint(getPointOnEllipse(
-                                     radiusX, radiusY, angle)));
+      lineToFloatPoint(path,
+                       center +
+                           rotationMatrix.mapPoint(
+                               getPointOnEllipse(radiusX, radiusY, angle)));
   } else {
     for (float angle = startAngle - fmodf(startAngle, piOverTwoFloat);
          angle > endAngle; angle -= piOverTwoFloat)
-      lineToFloatPoint(path, center +
-                                 rotationMatrix.mapPoint(getPointOnEllipse(
-                                     radiusX, radiusY, angle)));
+      lineToFloatPoint(path,
+                       center +
+                           rotationMatrix.mapPoint(
+                               getPointOnEllipse(radiusX, radiusY, angle)));
   }
 
-  lineToFloatPoint(path, center +
-                             rotationMatrix.mapPoint(getPointOnEllipse(
-                                 radiusX, radiusY, endAngle)));
+  lineToFloatPoint(path,
+                   center +
+                       rotationMatrix.mapPoint(
+                           getPointOnEllipse(radiusX, radiusY, endAngle)));
 }
 
 }  // namespace
 
 void CanvasPathMethods::arc(float x,
                             float y,
                             float radius,
                             float startAngle,
                             float endAngle,
                             bool anticlockwise,
@@ skipping 32 matching lines @@
                                 float startAngle,
                                 float endAngle,
                                 bool anticlockwise,
                                 ExceptionState& exceptionState) {
   if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(radiusX) ||
       !std::isfinite(radiusY) || !std::isfinite(rotation) ||
       !std::isfinite(startAngle) || !std::isfinite(endAngle))
     return;
 
   if (radiusX < 0) {
-    exceptionState.throwDOMException(
-        IndexSizeError, "The major-axis radius provided (" +
-                            String::number(radiusX) + ") is negative.");
+    exceptionState.throwDOMException(IndexSizeError,
+                                     "The major-axis radius provided (" +
+                                         String::number(radiusX) +
+                                         ") is negative.");
     return;
   }
   if (radiusY < 0) {
-    exceptionState.throwDOMException(
-        IndexSizeError, "The minor-axis radius provided (" +
-                            String::number(radiusY) + ") is negative.");
+    exceptionState.throwDOMException(IndexSizeError,
+                                     "The minor-axis radius provided (" +
+                                         String::number(radiusY) +
+                                         ") is negative.");
     return;
   }
 
   if (!isTransformInvertible())
     return;
 
   canonicalizeAngle(&startAngle, &endAngle);
   float adjustedEndAngle = adjustEndAngle(startAngle, endAngle, anticlockwise);
   if (!radiusX || !radiusY || startAngle == adjustedEndAngle) {
     // The ellipse is empty but we still need to draw the connecting line to
@@ skipping 11 matching lines @@
   if (!isTransformInvertible())
     return;
 
   if (!std::isfinite(x) || !std::isfinite(y) || !std::isfinite(width) ||
       !std::isfinite(height))
     return;
 
   m_path.addRect(FloatRect(x, y, width, height));
 }
 }  // namespace blink