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

third_party/WebKit/Source/modules/cachestorage/CacheTest.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/cachestorage/Cache.h"
 
 #include <algorithm>
 #include <memory>
 #include <string>
 #include "bindings/core/v8/ExceptionState.h"
@@ skipping 48 matching lines @@
 
     if (m_response) {
       ScriptPromiseResolver* resolver =
           ScriptPromiseResolver::create(scriptState);
       const ScriptPromise promise = resolver->promise();
       resolver->resolve(m_response);
       m_response = nullptr;
       return promise;
     }
     return ScriptPromise::reject(
-        scriptState, V8ThrowException::createTypeError(
-                         scriptState->isolate(),
-                         "Unexpected call to fetch, no response available."));
+        scriptState,
+        V8ThrowException::createTypeError(
+            scriptState->isolate(),
+            "Unexpected call to fetch, no response available."));
   }
 
   // This does not take ownership of its parameter. The provided sample object
   // is used to check the parameter when called.
   void setExpectedFetchUrl(const String* expectedUrl) {
     m_expectedUrl = expectedUrl;
   }
   void setResponse(Response* response) { m_response = response; }
 
   int fetchCount() const { return m_fetchCount; }
@@ skipping 97 matching lines @@
     CompareQueryParamsForTest(*m_expectedQueryParams, queryParams);
   }
 
   void checkBatchOperationsIfProvided(
       const WebVector<BatchOperation>& batchOperations) {
     if (!m_expectedBatchOperations)
       return;
     const WebVector<BatchOperation> expectedBatchOperations =
         *m_expectedBatchOperations;
     EXPECT_EQ(expectedBatchOperations.size(), batchOperations.size());
-    for (int i = 0, minsize = std::min(expectedBatchOperations.size(),
-                                       batchOperations.size());
+    for (int i = 0,
+             minsize = std::min(expectedBatchOperations.size(),
+                                batchOperations.size());
          i < minsize; ++i) {
       EXPECT_EQ(expectedBatchOperations[i].operationType,
                 batchOperations[i].operationType);
       const String expectedRequestUrl =
           KURL(expectedBatchOperations[i].request.url());
       EXPECT_EQ(expectedRequestUrl, KURL(batchOperations[i].request.url()));
       ASSERT_EQ(expectedBatchOperations[i].response.urlList().size(),
                 batchOperations[i].response.urlList().size());
       for (size_t j = 0;
            j < expectedBatchOperations[i].response.urlList().size(); ++j) {
@@ skipping 154 matching lines @@
       createCache(fetcher, testCache = new NotImplementedErrorCache());
   ASSERT(cache);
 
   const String url = "http://www.cachetest.org/";
 
   CacheQueryOptions options;
   ScriptPromise matchPromise = cache->match(
       getScriptState(), stringToRequestInfo(url), options, exceptionState);
   EXPECT_EQ(kNotImplementedString, getRejectString(matchPromise));
 
-  cache = createCache(fetcher, testCache = new ErrorWebCacheForTests(
-                                   WebServiceWorkerCacheErrorNotFound));
+  cache = createCache(fetcher,
+                      testCache = new ErrorWebCacheForTests(
+                          WebServiceWorkerCacheErrorNotFound));
   matchPromise = cache->match(getScriptState(), stringToRequestInfo(url),
                               options, exceptionState);
   ScriptValue scriptValue = getResolveValue(matchPromise);
   EXPECT_TRUE(scriptValue.isUndefined());
 
-  cache = createCache(fetcher, testCache = new ErrorWebCacheForTests(
-                                   WebServiceWorkerCacheErrorExists));
+  cache = createCache(
+      fetcher,
+      testCache = new ErrorWebCacheForTests(WebServiceWorkerCacheErrorExists));
   matchPromise = cache->match(getScriptState(), stringToRequestInfo(url),
                               options, exceptionState);
   EXPECT_EQ("InvalidAccessError: Entry already exists.",
             getRejectString(matchPromise));
 }
 
 // Tests that arguments are faithfully passed on calls to Cache methods, except
 // for methods which use batch operations, which are tested later.
 TEST_F(CacheStorageTest, BasicArguments) {
   ScriptState::Scope scope(getScriptState());
@@ skipping 339 matching lines @@
 
   EXPECT_EQ(kNotImplementedString, getRejectString(addResult));
   EXPECT_EQ(1, fetcher->fetchCount());
   EXPECT_EQ("dispatchBatch",
             testCache->getAndClearLastErrorWebCacheMethodCalled());
 }
 
 }  // namespace
 
 }  // namespace blink