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

third_party/WebKit/Source/core/html/canvas/CanvasAsyncBlobCreator.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/html/canvas/CanvasAsyncBlobCreator.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/fileapi/Blob.h"
 #include "platform/CrossThreadFunctional.h"
@@ skipping 263 matching lines @@
         WTF::bind(&CanvasAsyncBlobCreator::idleTaskStartTimeoutEvent,
                   wrapPersistent(this), quality),
         IdleTaskStartTimeoutDelay);
   }
 }
 
 void CanvasAsyncBlobCreator::scheduleInitiateJpegEncoding(
     const double& quality) {
   m_scheduleInitiateStartTime = WTF::monotonicallyIncreasingTime();
   Platform::current()->currentThread()->scheduler()->postIdleTask(
-      BLINK_FROM_HERE, WTF::bind(&CanvasAsyncBlobCreator::initiateJpegEncoding,
-                                 wrapPersistent(this), quality));
+      BLINK_FROM_HERE,
+      WTF::bind(&CanvasAsyncBlobCreator::initiateJpegEncoding,
+                wrapPersistent(this), quality));
 }
 
 void CanvasAsyncBlobCreator::initiateJpegEncoding(const double& quality,
                                                   double deadlineSeconds) {
   recordElapsedTimeHistogram(
       InitiateEncodingDelay, MimeTypeJpeg,
       WTF::monotonicallyIncreasingTime() - m_scheduleInitiateStartTime);
   if (m_idleTaskStatus == IdleTaskSwitchedToImmediateTask) {
     return;
   }
 
   DCHECK(m_idleTaskStatus == IdleTaskNotStarted);
   m_idleTaskStatus = IdleTaskStarted;
 
   if (!initializeJpegStruct(quality)) {
     m_idleTaskStatus = IdleTaskFailed;
     return;
   }
   this->idleEncodeRowsJpeg(deadlineSeconds);
 }
 
 void CanvasAsyncBlobCreator::scheduleInitiatePngEncoding() {
   m_scheduleInitiateStartTime = WTF::monotonicallyIncreasingTime();
   Platform::current()->currentThread()->scheduler()->postIdleTask(
-      BLINK_FROM_HERE, WTF::bind(&CanvasAsyncBlobCreator::initiatePngEncoding,
-                                 wrapPersistent(this)));
+      BLINK_FROM_HERE,
+      WTF::bind(&CanvasAsyncBlobCreator::initiatePngEncoding,
+                wrapPersistent(this)));
 }
 
 void CanvasAsyncBlobCreator::initiatePngEncoding(double deadlineSeconds) {
   recordElapsedTimeHistogram(
       InitiateEncodingDelay, MimeTypePng,
       WTF::monotonicallyIncreasingTime() - m_scheduleInitiateStartTime);
   if (m_idleTaskStatus == IdleTaskSwitchedToImmediateTask) {
     return;
   }
 
@@ skipping 13 matching lines @@
   }
 
   double startTime = WTF::monotonicallyIncreasingTime();
   unsigned char* inputPixels =
       m_data->data() + m_pixelRowStride * m_numRowsCompleted;
   for (int y = m_numRowsCompleted; y < m_size.height(); ++y) {
     if (isDeadlineNearOrPassed(deadlineSeconds)) {
       m_numRowsCompleted = y;
       m_elapsedTime += (WTF::monotonicallyIncreasingTime() - startTime);
       Platform::current()->currentThread()->scheduler()->postIdleTask(
-          BLINK_FROM_HERE, WTF::bind(&CanvasAsyncBlobCreator::idleEncodeRowsPng,
-                                     wrapPersistent(this)));
+          BLINK_FROM_HERE,
+          WTF::bind(&CanvasAsyncBlobCreator::idleEncodeRowsPng,
+                    wrapPersistent(this)));
       return;
     }
     PNGImageEncoder::writeOneRowToPng(inputPixels, m_pngEncoderState.get());
     inputPixels += m_pixelRowStride;
   }
   m_numRowsCompleted = m_size.height();
   PNGImageEncoder::finalizePng(m_pngEncoderState.get());
 
   m_idleTaskStatus = IdleTaskCompleted;
   m_elapsedTime += (WTF::monotonicallyIncreasingTime() - startTime);
@@ skipping 29 matching lines @@
               WTF::bind(&CanvasAsyncBlobCreator::createBlobAndReturnResult,
                         wrapPersistent(this)));
     } else {
       this->createBlobAndReturnResult();
     }
   } else if (m_numRowsCompleted == JPEGImageEncoder::ProgressiveEncodeFailed) {
     m_idleTaskStatus = IdleTaskFailed;
     this->createNullAndReturnResult();
   } else {
     Platform::current()->currentThread()->scheduler()->postIdleTask(
-        BLINK_FROM_HERE, WTF::bind(&CanvasAsyncBlobCreator::idleEncodeRowsJpeg,
-                                   wrapPersistent(this)));
+        BLINK_FROM_HERE,
+        WTF::bind(&CanvasAsyncBlobCreator::idleEncodeRowsJpeg,
+                  wrapPersistent(this)));
   }
 }
 
 void CanvasAsyncBlobCreator::forceEncodeRowsPngOnCurrentThread() {
   DCHECK(m_idleTaskStatus == IdleTaskSwitchedToImmediateTask);
 
   // Continue encoding from the last completed row
   unsigned char* inputPixels =
       m_data->data() + m_pixelRowStride * m_numRowsCompleted;
   for (int y = m_numRowsCompleted; y < m_size.height(); ++y) {
@@ skipping 42 matching lines @@
 void CanvasAsyncBlobCreator::createBlobAndReturnResult() {
   recordIdleTaskStatusHistogram(m_idleTaskStatus);
   recordElapsedTimeHistogram(ToBlobDuration, m_mimeType,
                              WTF::monotonicallyIncreasingTime() - m_startTime);
 
   Blob* resultBlob =
       Blob::create(m_encodedImage->data(), m_encodedImage->size(),
                    convertMimeTypeEnumToString(m_mimeType));
   if (m_functionType == HTMLCanvasToBlobCallback) {
     TaskRunnerHelper::get(TaskType::CanvasBlobSerialization, m_document)
-        ->postTask(BLINK_FROM_HERE, WTF::bind(&BlobCallback::handleEvent,
-                                              wrapPersistent(m_callback.get()),
-                                              wrapPersistent(resultBlob)));
+        ->postTask(BLINK_FROM_HERE,
+                   WTF::bind(&BlobCallback::handleEvent,
+                             wrapPersistent(m_callback.get()),
+                             wrapPersistent(resultBlob)));
   } else {
     m_scriptPromiseResolver->resolve(resultBlob);
   }
   // Avoid unwanted retention, see dispose().
   dispose();
 }
 
 void CanvasAsyncBlobCreator::createNullAndReturnResult() {
   recordIdleTaskStatusHistogram(m_idleTaskStatus);
   if (m_functionType == HTMLCanvasToBlobCallback) {
@@ skipping 141 matching lines @@
 
 DEFINE_TRACE(CanvasAsyncBlobCreator) {
   visitor->trace(m_document);
   visitor->trace(m_data);
   visitor->trace(m_callback);
   visitor->trace(m_parentFrameTaskRunner);
   visitor->trace(m_scriptPromiseResolver);
 }
 
 }  // namespace blink