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

third_party/WebKit/Source/platform/scheduler/base/thread_load_tracker_unittest.cc

 #include "platform/scheduler/base/thread_load_tracker.h"
 
 #include "base/bind.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::ElementsAre;
 
 namespace blink {
 namespace scheduler {
@@ skipping 35 matching lines @@
 
   thread_load_tracker.RecordTaskTime(MillisecondsToTime(13700),
                                      MillisecondsToTime(13800));
 
   thread_load_tracker.RecordTaskTime(MillisecondsToTime(14500),
                                      MillisecondsToTime(16500));
 
   thread_load_tracker.RecordIdle(MillisecondsToTime(17500));
 
   // Because of 10-second delay we're getting information starting with 11s.
-  EXPECT_THAT(result, ElementsAre(std::make_pair(SecondsToTime(11), 0),
-                                  std::make_pair(SecondsToTime(12), 0.1),
-                                  std::make_pair(SecondsToTime(13), 0.1),
-                                  std::make_pair(SecondsToTime(14), 0.2),
-                                  std::make_pair(SecondsToTime(15), 0.5),
-                                  std::make_pair(SecondsToTime(16), 1.0),
-                                  std::make_pair(SecondsToTime(17), 0.5)));
+  EXPECT_THAT(result,
+              ElementsAre(std::make_pair(SecondsToTime(11), 0),
+                          std::make_pair(SecondsToTime(12), 0.1),
+                          std::make_pair(SecondsToTime(13), 0.1),
+                          std::make_pair(SecondsToTime(14), 0.2),
+                          std::make_pair(SecondsToTime(15), 0.5),
+                          std::make_pair(SecondsToTime(16), 1.0),
+                          std::make_pair(SecondsToTime(17), 0.5)));
 }
 
 TEST(ThreadLoadTrackerTest, PauseAndResume) {
   std::vector<std::pair<base::TimeTicks, double>> result;
 
   ThreadLoadTracker thread_load_tracker(
       SecondsToTime(1), base::Bind(&AddToVector, base::Unretained(&result)),
       base::TimeDelta::FromSeconds(1), base::TimeDelta::FromSeconds(10));
   thread_load_tracker.Resume(SecondsToTime(1));
 
   thread_load_tracker.RecordTaskTime(SecondsToTime(3), SecondsToTime(4));
   thread_load_tracker.Pause(SecondsToTime(5));
   // This task should be ignored.
   thread_load_tracker.RecordTaskTime(SecondsToTime(10), SecondsToTime(11));
   thread_load_tracker.Resume(SecondsToTime(15));
   thread_load_tracker.RecordTaskTime(MillisecondsToTime(20900),
                                      MillisecondsToTime(21100));
 
   thread_load_tracker.RecordIdle(MillisecondsToTime(23500));
 
   thread_load_tracker.Pause(MillisecondsToTime(23500));
   thread_load_tracker.Resume(SecondsToTime(26));
 
   thread_load_tracker.RecordTaskTime(MillisecondsToTime(26100),
                                      MillisecondsToTime(26200));
   thread_load_tracker.RecordIdle(MillisecondsToTime(27500));
 
-  EXPECT_THAT(result, ElementsAre(std::make_pair(SecondsToTime(21), 0.1),
-                                  std::make_pair(SecondsToTime(22), 0.1),
-                                  std::make_pair(SecondsToTime(23), 0),
-                                  std::make_pair(SecondsToTime(27), 0.1)));
+  EXPECT_THAT(result,
+              ElementsAre(std::make_pair(SecondsToTime(21), 0.1),
+                          std::make_pair(SecondsToTime(22), 0.1),
+                          std::make_pair(SecondsToTime(23), 0),
+                          std::make_pair(SecondsToTime(27), 0.1)));
 }
 
 TEST(ThreadLoadTrackerTest, DisabledByDefault) {
   std::vector<std::pair<base::TimeTicks, double>> result;
   ThreadLoadTracker thread_load_tracker(
       SecondsToTime(1), base::Bind(&AddToVector, base::Unretained(&result)),
       base::TimeDelta::FromSeconds(1), base::TimeDelta::FromSeconds(10));
 
   // ThreadLoadTracker should be disabled and these tasks should be
   // ignored.
   thread_load_tracker.RecordTaskTime(SecondsToTime(13), SecondsToTime(14));
   thread_load_tracker.RecordTaskTime(SecondsToTime(15), SecondsToTime(16));
 
   thread_load_tracker.Resume(SecondsToTime(17));
 
   thread_load_tracker.RecordTaskTime(SecondsToTime(28), SecondsToTime(29));
 
-  EXPECT_THAT(result, ElementsAre(std::make_pair(SecondsToTime(27), 0),
-                                  std::make_pair(SecondsToTime(28), 0),
-                                  std::make_pair(SecondsToTime(29), 1)));
+  EXPECT_THAT(result,
+              ElementsAre(std::make_pair(SecondsToTime(27), 0),
+                          std::make_pair(SecondsToTime(28), 0),
+                          std::make_pair(SecondsToTime(29), 1)));
 }
 
 }  // namespace scheduler
 }  // namespace blink