reflow comments in Source/bindings/core/v8

third_party/WebKit/Source/bindings/core/v8/CallbackPromiseAdapter.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 32 matching lines @@
 // CallbackPromiseAdapter is a WebCallbacks subclass and resolves / rejects the
 // stored resolver when onSuccess / onError is called, respectively.
 //
 // Basically CallbackPromiseAdapter<S, T> is a subclass of
 // WebCallbacks<S::WebType, T::WebType>. There are some exceptions:
 //  - If S or T don't have WebType (e.g. S = bool), a default WebType holder
 //    called trivial WebType holder is used. For example,
 //    CallbackPromiseAdapter<bool, void> is a subclass of
 //    WebCallbacks<bool, void>.
 //  - If a WebType is std::unique_ptr<T>, its corresponding type parameter on
-//    WebCallbacks is std::unique_ptr<T>, because WebCallbacks must be exposed to
-//    Chromium.
+//    WebCallbacks is std::unique_ptr<T>, because WebCallbacks must be exposed
+//    to Chromium.
 //
 // When onSuccess is called with a S::WebType value, the value is passed to
 // S::take and the resolver is resolved with its return value. Ditto for
 // onError.
 //
 // ScriptPromiseResolver::resolve / reject will not be called when the execution
 // context is stopped.
 //
 // Example:
 // class MyClass {
 // public:
 //     using WebType = std::unique_ptr<WebMyClass>;
 //     static PassRefPtr<MyClass> take(ScriptPromiseResolver* resolver,
 //         std::unique_ptr<WebMyClass> webInstance)
 //     {
 //         return MyClass::create(webInstance);
 //     }
 //     ...
 // };
 // class MyErrorClass {
 // public:
 //     using WebType = const WebMyErrorClass&;
 //     static MyErrorClass take(ScriptPromiseResolver* resolver,
 //         const WebErrorClass& webError)
 //     {
 //         return MyErrorClass(webError);
 //     }
 //     ...
 // };
-// std::unique_ptr<WebCallbacks<std::unique_ptr<WebMyClass>, const WebMyErrorClass&>>
+// std::unique_ptr<WebCallbacks<std::unique_ptr<WebMyClass>,
+//                 const WebMyErrorClass&>>
 //     callbacks = wrapUnique(new CallbackPromiseAdapter<MyClass, MyErrorClass>(
 //     resolver));
 // ...
 //
 // std::unique_ptr<WebCallbacks<bool, const WebMyErrorClass&>> callbacks2 =
 //     wrapUnique(new CallbackPromiseAdapter<bool, MyErrorClass>(resolver));
 // ...
 //
 //
 // In order to implement the above exceptions, we have template classes below.
@@ skipping 106 matching lines @@
 
 }  // namespace internal
 
 template <typename S, typename T>
 using CallbackPromiseAdapter =
     internal::CallbackPromiseAdapterInternal::CallbackPromiseAdapter<S, T>;
 
 }  // namespace blink
 
 #endif