reflow comments in wtf

third_party/WebKit/Source/wtf/FunctionalTest.cpp

 /*
  * Copyright (C) 2011 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 460 matching lines @@
 int tripleMoveOnlysByValues(MoveOnly first, MoveOnly second, MoveOnly third) {
   return first.value() + second.value() + third.value();
 }
 
 TEST(FunctionalTest, BindMoveOnlyObjects) {
   MoveOnly one(1);
   std::unique_ptr<Function<int()>> bound =
       bind(singleMoveOnlyByRvalueReference, passed(std::move(one)));
   EXPECT_EQ(0, one.value());  // Should be moved away.
   EXPECT_EQ(1, (*bound)());
-  EXPECT_EQ(
-      0,
-      (*bound)());  // The stored value must be cleared in the first function call.
+  // The stored value must be cleared in the first function call.
+  EXPECT_EQ(0, (*bound)());
 
   bound = bind(singleMoveOnlyByValue, passed(MoveOnly(1)));
   EXPECT_EQ(1, (*bound)());
   EXPECT_EQ(0, (*bound)());
 
   bound = bind(tripleMoveOnlysByRvalueReferences, passed(MoveOnly(1)),
                passed(MoveOnly(2)), passed(MoveOnly(3)));
   EXPECT_EQ(6, (*bound)());
   EXPECT_EQ(0, (*bound)());
 
@@ skipping 29 matching lines @@
 TEST(FunctionalTest, CountCopiesOfBoundArguments) {
   CountCopy lvalue;
   std::unique_ptr<Function<int()>> bound =
       bind(takeCountCopyAsConstReference, lvalue);
   EXPECT_EQ(2, (*bound)());  // wrapping and unwrapping.
 
   bound = bind(takeCountCopyAsConstReference, CountCopy());  // Rvalue.
   EXPECT_EQ(2, (*bound)());
 
   bound = bind(takeCountCopyAsValue, lvalue);
-  EXPECT_EQ(
-      3,
-      (*bound)());  // wrapping, unwrapping and copying in the final function argument.
+  // wrapping, unwrapping and copying in the final function argument.
+  EXPECT_EQ(3, (*bound)());
 
   bound = bind(takeCountCopyAsValue, CountCopy());
   EXPECT_EQ(3, (*bound)());
 }
 
 TEST(FunctionalTest, MoveUnboundArgumentsByRvalueReference) {
   std::unique_ptr<Function<int(MoveOnly &&)>> boundSingle =
       bind(singleMoveOnlyByRvalueReference);
   EXPECT_EQ(1, (*boundSingle)(MoveOnly(1)));
   EXPECT_EQ(42, (*boundSingle)(MoveOnly(42)));
@@ skipping 13 matching lines @@
 }
 
 TEST(FunctionalTest, CountCopiesOfUnboundArguments) {
   CountCopy lvalue;
   std::unique_ptr<Function<int(const CountCopy&)>> bound1 =
       bind(takeCountCopyAsConstReference);
   EXPECT_EQ(0, (*bound1)(lvalue));  // No copies!
   EXPECT_EQ(0, (*bound1)(CountCopy()));
 
   std::unique_ptr<Function<int(CountCopy)>> bound2 = bind(takeCountCopyAsValue);
-  EXPECT_EQ(
-      3,
-      (*bound2)(
-          lvalue));  // At Function::operator(), at Callback::Run() and at the destination function.
-  EXPECT_LE(
-      (*bound2)(CountCopy()),
-      2);  // Compiler is allowed to optimize one copy away if the argument is rvalue.
+  // At Function::operator(), at Callback::Run() and at the destination
+  // function.
+  EXPECT_EQ(3, (*bound2)(lvalue));
+  // Compiler is allowed to optimize one copy away if the argument is rvalue.
+  EXPECT_LE((*bound2)(CountCopy()), 2);
 }
 
 TEST(FunctionalTest, WeakPtr) {
   HasWeakPtrSupport obj;
   int counter = 0;
   std::unique_ptr<WTF::Closure> bound =
       WTF::bind(&HasWeakPtrSupport::increment, obj.createWeakPtr(),
                 WTF::unretained(&counter));
 
   (*bound)();
   EXPECT_FALSE(bound->isCancelled());
   EXPECT_EQ(1, counter);
 
   obj.revokeAll();
   EXPECT_TRUE(bound->isCancelled());
   (*bound)();
   EXPECT_EQ(1, counter);
 }
 
 }  // anonymous namespace
 
 }  // namespace WTF