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

third_party/WebKit/Source/modules/permissions/Permissions.cpp

 // Copyright 2014 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 "modules/permissions/Permissions.h"
 
 #include <memory>
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/Nullable.h"
 #include "bindings/core/v8/ScriptPromise.h"
@@ skipping 127 matching lines @@
   PermissionDescriptorPtr descriptor =
       parsePermission(scriptState, rawPermission, exceptionState);
   if (exceptionState.hadException())
     return exceptionState.reject(scriptState);
 
   // This must be called after `parsePermission` because the website might
   // be able to run code.
   PermissionService* service = getService(scriptState->getExecutionContext());
   if (!service)
     return ScriptPromise::rejectWithDOMException(
-        scriptState, DOMException::create(InvalidStateError,
-                                          "In its current state, the global "
-                                          "scope can't request permissions."));
+        scriptState,
+        DOMException::create(InvalidStateError,
+                             "In its current state, the global "
+                             "scope can't request permissions."));
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
 
   PermissionDescriptorPtr descriptorCopy = descriptor->Clone();
   service->RequestPermission(
       std::move(descriptor),
       scriptState->getExecutionContext()->getSecurityOrigin(),
       UserGestureIndicator::processingUserGestureThreadSafe(),
       convertToBaseCallback(WTF::bind(
@@ skipping 10 matching lines @@
   PermissionDescriptorPtr descriptor =
       parsePermission(scriptState, rawPermission, exceptionState);
   if (exceptionState.hadException())
     return exceptionState.reject(scriptState);
 
   // This must be called after `parsePermission` because the website might
   // be able to run code.
   PermissionService* service = getService(scriptState->getExecutionContext());
   if (!service)
     return ScriptPromise::rejectWithDOMException(
-        scriptState, DOMException::create(InvalidStateError,
-                                          "In its current state, the global "
-                                          "scope can't revoke permissions."));
+        scriptState,
+        DOMException::create(InvalidStateError,
+                             "In its current state, the global "
+                             "scope can't revoke permissions."));
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
 
   PermissionDescriptorPtr descriptorCopy = descriptor->Clone();
   service->RevokePermission(
       std::move(descriptor),
       scriptState->getExecutionContext()->getSecurityOrigin(),
       convertToBaseCallback(WTF::bind(
           &Permissions::taskComplete, wrapPersistent(this),
@@ skipping 31 matching lines @@
       internalPermissions.push_back(std::move(descriptor));
     }
     callerIndexToInternalIndex[i] = internalIndex;
   }
 
   // This must be called after `parsePermission` because the website might
   // be able to run code.
   PermissionService* service = getService(scriptState->getExecutionContext());
   if (!service)
     return ScriptPromise::rejectWithDOMException(
-        scriptState, DOMException::create(InvalidStateError,
-                                          "In its current state, the global "
-                                          "scope can't request permissions."));
+        scriptState,
+        DOMException::create(InvalidStateError,
+                             "In its current state, the global "
+                             "scope can't request permissions."));
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
 
   Vector<PermissionDescriptorPtr> internalPermissionsCopy;
   internalPermissionsCopy.reserveCapacity(internalPermissions.size());
   for (const auto& descriptor : internalPermissions)
     internalPermissionsCopy.push_back(descriptor->Clone());
 
   service->RequestPermissions(
       std::move(internalPermissions),
       scriptState->getExecutionContext()->getSecurityOrigin(),
       UserGestureIndicator::processingUserGestureThreadSafe(),
       convertToBaseCallback(
           WTF::bind(&Permissions::batchTaskComplete, wrapPersistent(this),
                     wrapPersistent(resolver),
                     WTF::passed(std::move(internalPermissionsCopy)),
                     WTF::passed(std::move(callerIndexToInternalIndex)))));
   return promise;
 }
 
 PermissionService* Permissions::getService(ExecutionContext* executionContext) {
-  if (!m_service && connectToPermissionService(executionContext,
-                                               mojo::MakeRequest(&m_service)))
+  if (!m_service &&
+      connectToPermissionService(executionContext,
+                                 mojo::MakeRequest(&m_service)))
     m_service.set_connection_error_handler(convertToBaseCallback(WTF::bind(
         &Permissions::serviceConnectionError, wrapWeakPersistent(this))));
   return m_service.get();
 }
 
 void Permissions::serviceConnectionError() {
   m_service.reset();
 }
 
 void Permissions::taskComplete(ScriptPromiseResolver* resolver,
@@ skipping 22 matching lines @@
   result.reserveInitialCapacity(callerIndexToInternalIndex.size());
   for (int internalIndex : callerIndexToInternalIndex) {
     result.push_back(PermissionStatus::createAndListen(
         resolver->getExecutionContext(), results[internalIndex],
         descriptors[internalIndex]->Clone()));
   }
   resolver->resolve(result);
 }
 
 }  // namespace blink