Clang format slam.

net/quic/quic_fec_group_test.cc

 // Copyright (c) 2012 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 "net/quic/quic_fec_group.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::_;
 using base::StringPiece;
 
 namespace net {
 
 namespace {
 
 const char* kData[] = {
-  "abc12345678",
-  "987defg",
-  "ghi12345",
-  "987jlkmno",
-  "mno4567890",
-  "789pqrstuvw",
+    "abc12345678", "987defg",    "ghi12345",
+    "987jlkmno",   "mno4567890", "789pqrstuvw",
 };
 
 const bool kEntropyFlag[] = {
-  false,
-  true,
-  true,
-  false,
-  true,
-  true,
+    false, true, true, false, true, true,
 };
 
 }  // namespace
 
 class QuicFecGroupTest : public ::testing::Test {
  protected:
   void RunTest(size_t num_packets, size_t lost_packet, bool out_of_order) {
     size_t max_len = strlen(kData[0]);
     scoped_ptr<char[]> redundancy(new char[max_len]);
     for (size_t packet = 0; packet < num_packets; ++packet) {
@@ skipping 24 matching lines @@
           ASSERT_TRUE(group.UpdateFec(num_packets, fec));
         } else {
           QuicPacketHeader header;
           header.packet_sequence_number = packet;
           header.entropy_flag = kEntropyFlag[packet];
           ASSERT_TRUE(group.Update(header, kData[packet]));
         }
         ASSERT_TRUE(group.CanRevive() == (packet == num_packets - 1));
       }
     } else {
-    // Update the FEC state for each non-lost packet.
+      // Update the FEC state for each non-lost packet.
       for (size_t packet = 0; packet < num_packets; packet++) {
         if (packet == lost_packet) {
           continue;
         }
 
         QuicPacketHeader header;
         header.packet_sequence_number = packet;
         header.entropy_flag = kEntropyFlag[packet];
         ASSERT_TRUE(group.Update(header, kData[packet]));
         ASSERT_FALSE(group.CanRevive());
       }
 
       ASSERT_FALSE(group.IsFinished());
       // Attempt to revive the missing packet.
       QuicFecData fec;
       fec.fec_group = 0;
       fec.redundancy = StringPiece(redundancy.get(), strlen(kData[0]));
 
       ASSERT_TRUE(group.UpdateFec(num_packets, fec));
     }
     QuicPacketHeader header;
     char recovered[kMaxPacketSize];
     ASSERT_TRUE(group.CanRevive());
     size_t len = group.Revive(&header, recovered, arraysize(recovered));
-    ASSERT_NE(0u, len)
-        << "Failed to revive packet " << lost_packet << " out of "
-        << num_packets;
+    ASSERT_NE(0u, len) << "Failed to revive packet " << lost_packet
+                       << " out of " << num_packets;
     EXPECT_EQ(lost_packet, header.packet_sequence_number)
         << "Failed to revive packet " << lost_packet << " out of "
         << num_packets;
     // Revived packets have an unknown entropy.
     EXPECT_FALSE(header.entropy_flag);
     ASSERT_GE(len, strlen(kData[lost_packet])) << "Incorrect length";
     for (size_t i = 0; i < strlen(kData[lost_packet]); i++) {
       EXPECT_EQ(kData[lost_packet][i], recovered[i]);
     }
     ASSERT_TRUE(group.IsFinished());
@@ skipping 89 matching lines @@
 
   EXPECT_FALSE(group.ProtectsPacketsBefore(1));
   EXPECT_FALSE(group.ProtectsPacketsBefore(2));
   EXPECT_TRUE(group.ProtectsPacketsBefore(3));
   EXPECT_TRUE(group.ProtectsPacketsBefore(4));
   EXPECT_TRUE(group.ProtectsPacketsBefore(5));
   EXPECT_TRUE(group.ProtectsPacketsBefore(50));
 }
 
 }  // namespace net