reflow comments in modules/[app_banner,encoding]

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 "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
@@ skipping 53 matching lines @@
       resolver->resolve(m_response);
       m_response = nullptr;
       return promise;
     }
     return ScriptPromise::reject(
         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.
+  // 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; }
 
   DEFINE_INLINE_TRACE() {
     visitor->trace(m_response);
     GlobalFetch::ScopedFetcher::trace(visitor);
   }
 
  private:
   ScopedFetcherForTests() : m_fetchCount(0), m_expectedUrl(nullptr) {}
 
   int m_fetchCount;
   const String* m_expectedUrl;
   Member<Response> m_response;
 };
 
-// A test implementation of the WebServiceWorkerCache interface which returns a (provided) error for every operation, and optionally checks arguments
-// to methods against provided arguments. Also used as a base class for test specific caches.
+// A test implementation of the WebServiceWorkerCache interface which returns a
+// (provided) error for every operation, and optionally checks arguments to
+// methods against provided arguments. Also used as a base class for test
+// specific caches.
 class ErrorWebCacheForTests : public WebServiceWorkerCache {
  public:
   ErrorWebCacheForTests(const WebServiceWorkerCacheError error)
       : m_error(error),
         m_expectedUrl(0),
         m_expectedQueryParams(0),
         m_expectedBatchOperations(0) {}
 
   std::string getAndClearLastErrorWebCacheMethodCalled() {
     std::string old = m_lastErrorWebCacheMethodCalled;
     m_lastErrorWebCacheMethodCalled.clear();
     return old;
   }
 
-  // These methods do not take ownership of their parameter. They provide an optional sample object to check parameters against.
+  // These methods do not take ownership of their parameter. They provide an
+  // optional sample object to check parameters against.
   void setExpectedUrl(const String* expectedUrl) {
     m_expectedUrl = expectedUrl;
   }
   void setExpectedQueryParams(const QueryParams* expectedQueryParams) {
     m_expectedQueryParams = expectedQueryParams;
   }
   void setExpectedBatchOperations(
       const WebVector<BatchOperation>* expectedBatchOperations) {
     m_expectedBatchOperations = expectedBatchOperations;
   }
@@ skipping 176 matching lines @@
     ScriptValue call(ScriptValue value) override {
       ADD_FAILURE() << "Unexpected call to a null ScriptFunction.";
       return value;
     }
 
    private:
     UnreachableFunction(ScriptState* scriptState)
         : ScriptFunction(scriptState) {}
   };
 
-  // A ScriptFunction that saves its parameter; used by tests to assert on correct
-  // values being passed.
+  // A ScriptFunction that saves its parameter; used by tests to assert on
+  // correct values being passed.
   class TestFunction : public ScriptFunction {
    public:
     static v8::Local<v8::Function> create(ScriptState* scriptState,
                                           ScriptValue* outValue) {
       TestFunction* self = new TestFunction(scriptState, outValue);
       return self->bindToV8Function();
     }
 
     ScriptValue call(ScriptValue value) override {
       ASSERT(!value.isEmpty());
@@ skipping 48 matching lines @@
   EXPECT_TRUE(scriptValue.isUndefined());
 
   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.
+// 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());
   NonThrowableExceptionState exceptionState;
   ScopedFetcherForTests* fetcher = ScopedFetcherForTests::create();
   ErrorWebCacheForTests* testCache;
   Cache* cache =
       createCache(fetcher, testCache = new NotImplementedErrorCache());
   ASSERT(cache);
 
   const String url = "http://www.cache.arguments.test/";
@@ skipping 49 matching lines @@
             testCache->getAndClearLastErrorWebCacheMethodCalled());
   EXPECT_EQ(kNotImplementedString, getRejectString(keysResult2));
 
   ScriptPromise stringKeysResult2 = cache->keys(
       getScriptState(), stringToRequestInfo(url), options, exceptionState);
   EXPECT_EQ("dispatchKeys",
             testCache->getAndClearLastErrorWebCacheMethodCalled());
   EXPECT_EQ(kNotImplementedString, getRejectString(stringKeysResult2));
 }
 
-// Tests that arguments are faithfully passed to API calls that degrade to batch operations.
+// Tests that arguments are faithfully passed to API calls that degrade to batch
+// operations.
 TEST_F(CacheStorageTest, BatchOperationArguments) {
   ScriptState::Scope scope(getScriptState());
   NonThrowableExceptionState exceptionState;
   ScopedFetcherForTests* fetcher = ScopedFetcherForTests::create();
   ErrorWebCacheForTests* testCache;
   Cache* cache =
       createCache(fetcher, testCache = new NotImplementedErrorCache());
   ASSERT(cache);
 
   WebServiceWorkerCache::QueryParams expectedQueryParams;
@@ skipping 262 matching lines @@
 
   EXPECT_EQ(kNotImplementedString, getRejectString(addResult));
   EXPECT_EQ(1, fetcher->fetchCount());
   EXPECT_EQ("dispatchBatch",
             testCache->getAndClearLastErrorWebCacheMethodCalled());
 }
 
 }  // namespace
 
 }  // namespace blink