Clang format slam.

net/quic/quic_network_transaction_unittest.cc

Index: net/quic/quic_network_transaction_unittest.cc
diff --git a/net/quic/quic_network_transaction_unittest.cc b/net/quic/quic_network_transaction_unittest.cc
index 5aa036809873f61301b4a78424f462f9d4d0cdce..9a984265dd1486d1cda7990eb61701831b8a1e7d 100644
--- a/net/quic/quic_network_transaction_unittest.cc
+++ b/net/quic/quic_network_transaction_unittest.cc
@@ -66,30 +66,26 @@ namespace test {
 // Simplify ownership issues and the interaction with the MockSocketFactory.
 class MockQuicData {
  public:
-  ~MockQuicData() {
-    STLDeleteElements(&packets_);
-  }
+  ~MockQuicData() { STLDeleteElements(&packets_); }
 
   void AddRead(scoped_ptr<QuicEncryptedPacket> packet) {
-    reads_.push_back(MockRead(SYNCHRONOUS, packet->data(), packet->length(),
-                              sequence_number_++));
+    reads_.push_back(MockRead(
+        SYNCHRONOUS, packet->data(), packet->length(), sequence_number_++));
     packets_.push_back(packet.release());
   }
 
-  void AddRead(IoMode mode, int rv) {
-    reads_.push_back(MockRead(mode, rv));
-  }
+  void AddRead(IoMode mode, int rv) { reads_.push_back(MockRead(mode, rv)); }
 
   void AddWrite(scoped_ptr<QuicEncryptedPacket> packet) {
-    writes_.push_back(MockWrite(SYNCHRONOUS, packet->data(), packet->length(),
-                                sequence_number_++));
+    writes_.push_back(MockWrite(
+        SYNCHRONOUS, packet->data(), packet->length(), sequence_number_++));
     packets_.push_back(packet.release());
   }
 
   void AddDelayedSocketDataToFactory(MockClientSocketFactory* factory,
                                      size_t delay) {
-    MockRead* reads = reads_.empty() ? NULL  : &reads_[0];
-    MockWrite* writes = writes_.empty() ? NULL  : &writes_[0];
+    MockRead* reads = reads_.empty() ? NULL : &reads_[0];
+    MockWrite* writes = writes_.empty() ? NULL : &writes_[0];
     socket_data_.reset(new DelayedSocketData(
         delay, reads, reads_.size(), writes, writes_.size()));
     factory->AddSocketDataProvider(socket_data_.get());
@@ -190,9 +186,7 @@ class QuicNetworkTransactionTest
         sequence_number, stream_id, should_include_version, fin, headers);
   }
 
-  void CreateSession() {
-    CreateSessionWithFactory(&socket_factory_);
-  }
+  void CreateSession() { CreateSessionWithFactory(&socket_factory_); }
 
   void CreateSessionWithFactory(ClientSocketFactory* socket_factory) {
     params_.enable_quic = true;
@@ -315,7 +309,8 @@ class QuicNetworkTransactionTest
   StaticSocketDataProvider hanging_data_;
 };
 
-INSTANTIATE_TEST_CASE_P(Version, QuicNetworkTransactionTest,
+INSTANTIATE_TEST_CASE_P(Version,
+                        QuicNetworkTransactionTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
 TEST_P(QuicNetworkTransactionTest, ForceQuic) {
@@ -323,12 +318,10 @@ TEST_P(QuicNetworkTransactionTest, ForceQuic) {
       HostPortPair::FromString("www.google.com:80");
 
   MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(
-      ConstructRequestHeadersPacket(1, kStreamId5, true, true,
-                                    GetRequestHeaders("GET", "http", "/")));
-  mock_quic_data.AddRead(
-      ConstructResponseHeadersPacket(1, kStreamId5, false, false,
-                                     GetResponseHeaders("200 OK")));
+  mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
+      1, kStreamId5, true, true, GetRequestHeaders("GET", "http", "/")));
+  mock_quic_data.AddRead(ConstructResponseHeadersPacket(
+      1, kStreamId5, false, false, GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kStreamId5, false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
@@ -351,26 +344,29 @@ TEST_P(QuicNetworkTransactionTest, ForceQuic) {
 
   // Check that we logged a QUIC_SESSION_PACKET_RECEIVED.
   int pos = net::ExpectLogContainsSomewhere(
-      entries, 0,
+      entries,
+      0,
       net::NetLog::TYPE_QUIC_SESSION_PACKET_RECEIVED,
       net::NetLog::PHASE_NONE);
   EXPECT_LT(0, pos);
 
   // ... and also a TYPE_QUIC_SESSION_PACKET_HEADER_RECEIVED.
   pos = net::ExpectLogContainsSomewhere(
-      entries, 0,
+      entries,
+      0,
       net::NetLog::TYPE_QUIC_SESSION_PACKET_HEADER_RECEIVED,
       net::NetLog::PHASE_NONE);
   EXPECT_LT(0, pos);
 
   std::string packet_sequence_number;
-  ASSERT_TRUE(entries[pos].GetStringValue(
-      "packet_sequence_number", &packet_sequence_number));
+  ASSERT_TRUE(entries[pos].GetStringValue("packet_sequence_number",
+                                          &packet_sequence_number));
   EXPECT_EQ("1", packet_sequence_number);
 
   // ... and also a QUIC_SESSION_STREAM_FRAME_RECEIVED.
   pos = net::ExpectLogContainsSomewhere(
-      entries, 0,
+      entries,
+      0,
       net::NetLog::TYPE_QUIC_SESSION_STREAM_FRAME_RECEIVED,
       net::NetLog::PHASE_NONE);
   EXPECT_LT(0, pos);
@@ -385,12 +381,10 @@ TEST_P(QuicNetworkTransactionTest, QuicProxy) {
       ProxyService::CreateFixedFromPacResult("QUIC myproxy:70"));
 
   MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(
-      ConstructRequestHeadersPacket(1, kStreamId5, true, true,
-                                    GetRequestHeaders("GET", "http", "/")));
-  mock_quic_data.AddRead(
-      ConstructResponseHeadersPacket(1, kStreamId5, false, false,
-                                     GetResponseHeaders("200 OK")));
+  mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
+      1, kStreamId5, true, true, GetRequestHeaders("GET", "http", "/")));
+  mock_quic_data.AddRead(ConstructResponseHeadersPacket(
+      1, kStreamId5, false, false, GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kStreamId5, false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
@@ -431,11 +425,9 @@ TEST_P(QuicNetworkTransactionTest, DoNotForceQuicForHttps) {
       HostPortPair::FromString("www.google.com:443");
 
   MockRead http_reads[] = {
-    MockRead("HTTP/1.1 200 OK\r\n\r\n"),
-    MockRead("hello world"),
-    MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
-    MockRead(ASYNC, OK)
-  };
+      MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello world"),
+      MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
+      MockRead(ASYNC, OK)};
 
   StaticSocketDataProvider data(http_reads, arraysize(http_reads), NULL, 0);
   socket_factory_.AddSocketDataProvider(&data);
@@ -451,24 +443,20 @@ TEST_P(QuicNetworkTransactionTest, UseAlternateProtocolForQuic) {
   HttpStreamFactory::EnableNpnSpdy3();  // Enables QUIC too.
 
   MockRead http_reads[] = {
-    MockRead("HTTP/1.1 200 OK\r\n"),
-    MockRead(kQuicAlternateProtocolHttpHeader),
-    MockRead("hello world"),
-    MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
-    MockRead(ASYNC, OK)
-  };
+      MockRead("HTTP/1.1 200 OK\r\n"),
+      MockRead(kQuicAlternateProtocolHttpHeader), MockRead("hello world"),
+      MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
+      MockRead(ASYNC, OK)};
 
-  StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
-                                     NULL, 0);
+  StaticSocketDataProvider http_data(
+      http_reads, arraysize(http_reads), NULL, 0);
   socket_factory_.AddSocketDataProvider(&http_data);
 
   MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(
-      ConstructRequestHeadersPacket(1, kStreamId5, true, true,
-                                    GetRequestHeaders("GET", "http", "/")));
-  mock_quic_data.AddRead(
-      ConstructResponseHeadersPacket(1, kStreamId5, false, false,
-                                     GetResponseHeaders("200 OK")));
+  mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
+      1, kStreamId5, true, true, GetRequestHeaders("GET", "http", "/")));
+  mock_quic_data.AddRead(ConstructResponseHeadersPacket(
+      1, kStreamId5, false, false, GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kStreamId5, false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
@@ -493,24 +481,20 @@ TEST_P(QuicNetworkTransactionTest, UseAlternateProtocolForQuicForHttps) {
   HttpStreamFactory::EnableNpnSpdy3();  // Enables QUIC too.
 
   MockRead http_reads[] = {
-    MockRead("HTTP/1.1 200 OK\r\n"),
-    MockRead(kQuicAlternateProtocolHttpsHeader),
-    MockRead("hello world"),
-    MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
-    MockRead(ASYNC, OK)
-  };
+      MockRead("HTTP/1.1 200 OK\r\n"),
+      MockRead(kQuicAlternateProtocolHttpsHeader), MockRead("hello world"),
+      MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
+      MockRead(ASYNC, OK)};
 
-  StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
-                                     NULL, 0);
+  StaticSocketDataProvider http_data(
+      http_reads, arraysize(http_reads), NULL, 0);
   socket_factory_.AddSocketDataProvider(&http_data);
 
   MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(
-      ConstructRequestHeadersPacket(1, kStreamId5, true, true,
-                                    GetRequestHeaders("GET", "http", "/")));
-  mock_quic_data.AddRead(
-      ConstructResponseHeadersPacket(1, kStreamId5, false, false,
-                                     GetResponseHeaders("200 OK")));
+  mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
+      1, kStreamId5, true, true, GetRequestHeaders("GET", "http", "/")));
+  mock_quic_data.AddRead(ConstructResponseHeadersPacket(
+      1, kStreamId5, false, false, GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kStreamId5, false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
@@ -534,38 +518,33 @@ TEST_P(QuicNetworkTransactionTest, HungAlternateProtocol) {
       MockCryptoClientStream::COLD_START);
 
   MockWrite http_writes[] = {
-    MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"),
-    MockWrite(SYNCHRONOUS, 1, "Host: www.google.com\r\n"),
-    MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")
-  };
+      MockWrite(SYNCHRONOUS, 0, "GET / HTTP/1.1\r\n"),
+      MockWrite(SYNCHRONOUS, 1, "Host: www.google.com\r\n"),
+      MockWrite(SYNCHRONOUS, 2, "Connection: keep-alive\r\n\r\n")};
 
   MockRead http_reads[] = {
-    MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
-    MockRead(SYNCHRONOUS, 4, kQuicAlternateProtocolHttpHeader),
-    MockRead(SYNCHRONOUS, 5, "hello world"),
-    MockRead(SYNCHRONOUS, OK, 6)
-  };
+      MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
+      MockRead(SYNCHRONOUS, 4, kQuicAlternateProtocolHttpHeader),
+      MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)};
 
   DeterministicMockClientSocketFactory socket_factory;
 
-  DeterministicSocketData http_data(http_reads, arraysize(http_reads),
-                                    http_writes, arraysize(http_writes));
+  DeterministicSocketData http_data(
+      http_reads, arraysize(http_reads), http_writes, arraysize(http_writes));
   socket_factory.AddSocketDataProvider(&http_data);
 
   // The QUIC transaction will not be allowed to complete.
-  MockWrite quic_writes[] = {
-    MockWrite(ASYNC, ERR_IO_PENDING, 0)
-  };
+  MockWrite quic_writes[] = {MockWrite(ASYNC, ERR_IO_PENDING, 0)};
   MockRead quic_reads[] = {
-    MockRead(ASYNC, ERR_IO_PENDING, 1),
+      MockRead(ASYNC, ERR_IO_PENDING, 1),
   };
-  DeterministicSocketData quic_data(quic_reads, arraysize(quic_reads),
-                                    quic_writes, arraysize(quic_writes));
+  DeterministicSocketData quic_data(
+      quic_reads, arraysize(quic_reads), quic_writes, arraysize(quic_writes));
   socket_factory.AddSocketDataProvider(&quic_data);
 
   // The HTTP transaction will complete.
-  DeterministicSocketData http_data2(http_reads, arraysize(http_reads),
-                                     http_writes, arraysize(http_writes));
+  DeterministicSocketData http_data2(
+      http_reads, arraysize(http_reads), http_writes, arraysize(http_writes));
   socket_factory.AddSocketDataProvider(&http_data2);
 
   CreateSessionWithFactory(&socket_factory);
@@ -591,12 +570,10 @@ TEST_P(QuicNetworkTransactionTest, ZeroRTTWithHttpRace) {
   HttpStreamFactory::EnableNpnSpdy3();  // Enables QUIC too.
 
   MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(
-      ConstructRequestHeadersPacket(1, kStreamId5, true, true,
-                                    GetRequestHeaders("GET", "http", "/")));
-  mock_quic_data.AddRead(
-      ConstructResponseHeadersPacket(1, kStreamId5, false, false,
-                                     GetResponseHeaders("200 OK")));
+  mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
+      1, kStreamId5, true, true, GetRequestHeaders("GET", "http", "/")));
+  mock_quic_data.AddRead(ConstructResponseHeadersPacket(
+      1, kStreamId5, false, false, GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kStreamId5, false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
@@ -617,12 +594,10 @@ TEST_P(QuicNetworkTransactionTest, ZeroRTTWithNoHttpRace) {
   HttpStreamFactory::EnableNpnSpdy3();  // Enables QUIC too.
 
   MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(
-      ConstructRequestHeadersPacket(1, kStreamId5, true, true,
-                                    GetRequestHeaders("GET", "http", "/")));
-  mock_quic_data.AddRead(
-      ConstructResponseHeadersPacket(1, kStreamId5, false, false,
-                                     GetResponseHeaders("200 OK")));
+  mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
+      1, kStreamId5, true, true, GetRequestHeaders("GET", "http", "/")));
+  mock_quic_data.AddRead(ConstructResponseHeadersPacket(
+      1, kStreamId5, false, false, GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kStreamId5, false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
@@ -655,20 +630,17 @@ TEST_P(QuicNetworkTransactionTest, ZeroRTTWithProxy) {
 
   // Since we are using a proxy, the QUIC job will not succeed.
   MockWrite http_writes[] = {
-    MockWrite(SYNCHRONOUS, 0, "GET http://www.google.com/ HTTP/1.1\r\n"),
-    MockWrite(SYNCHRONOUS, 1, "Host: www.google.com\r\n"),
-    MockWrite(SYNCHRONOUS, 2, "Proxy-Connection: keep-alive\r\n\r\n")
-  };
+      MockWrite(SYNCHRONOUS, 0, "GET http://www.google.com/ HTTP/1.1\r\n"),
+      MockWrite(SYNCHRONOUS, 1, "Host: www.google.com\r\n"),
+      MockWrite(SYNCHRONOUS, 2, "Proxy-Connection: keep-alive\r\n\r\n")};
 
   MockRead http_reads[] = {
-    MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
-    MockRead(SYNCHRONOUS, 4, kQuicAlternateProtocolHttpHeader),
-    MockRead(SYNCHRONOUS, 5, "hello world"),
-    MockRead(SYNCHRONOUS, OK, 6)
-  };
+      MockRead(SYNCHRONOUS, 3, "HTTP/1.1 200 OK\r\n"),
+      MockRead(SYNCHRONOUS, 4, kQuicAlternateProtocolHttpHeader),
+      MockRead(SYNCHRONOUS, 5, "hello world"), MockRead(SYNCHRONOUS, OK, 6)};
 
-  StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
-                                     http_writes, arraysize(http_writes));
+  StaticSocketDataProvider http_data(
+      http_reads, arraysize(http_reads), http_writes, arraysize(http_writes));
   socket_factory_.AddSocketDataProvider(&http_data);
 
   // In order for a new QUIC session to be established via alternate-protocol
@@ -694,12 +666,10 @@ TEST_P(QuicNetworkTransactionTest, ZeroRTTWithConfirmationRequired) {
   HttpStreamFactory::EnableNpnSpdy3();  // Enables QUIC too.
 
   MockQuicData mock_quic_data;
-  mock_quic_data.AddWrite(
-      ConstructRequestHeadersPacket(1, kStreamId5, true, true,
-                                    GetRequestHeaders("GET", "http", "/")));
-  mock_quic_data.AddRead(
-      ConstructResponseHeadersPacket(1, kStreamId5, false, false,
-                                     GetResponseHeaders("200 OK")));
+  mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
+      1, kStreamId5, true, true, GetRequestHeaders("GET", "http", "/")));
+  mock_quic_data.AddRead(ConstructResponseHeadersPacket(
+      1, kStreamId5, false, false, GetResponseHeaders("200 OK")));
   mock_quic_data.AddRead(
       ConstructDataPacket(2, kStreamId5, false, true, 0, "hello!"));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
@@ -719,8 +689,12 @@ TEST_P(QuicNetworkTransactionTest, ZeroRTTWithConfirmationRequired) {
   host_resolver_.rules()->AddIPLiteralRule("www.google.com", "192.168.0.1", "");
   HostResolver::RequestInfo info(HostPortPair("www.google.com", 80));
   AddressList address;
-  host_resolver_.Resolve(info, DEFAULT_PRIORITY, &address,
-                         CompletionCallback(), NULL, net_log_.bound());
+  host_resolver_.Resolve(info,
+                         DEFAULT_PRIORITY,
+                         &address,
+                         CompletionCallback(),
+                         NULL,
+                         net_log_.bound());
 
   CreateSession();
   session_->quic_stream_factory()->set_require_confirmation(true);
@@ -743,23 +717,21 @@ TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocol) {
   // Alternate-protocol job
   scoped_ptr<QuicEncryptedPacket> close(ConstructConnectionClosePacket(1));
   MockRead quic_reads[] = {
-    MockRead(ASYNC, close->data(), close->length()),
-    MockRead(ASYNC, OK),  // EOF
+      MockRead(ASYNC, close->data(), close->length()),
+      MockRead(ASYNC, OK),  // EOF
   };
-  StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads),
-                                     NULL, 0);
+  StaticSocketDataProvider quic_data(
+      quic_reads, arraysize(quic_reads), NULL, 0);
   socket_factory_.AddSocketDataProvider(&quic_data);
 
   // Main job which will succeed even though the alternate job fails.
   MockRead http_reads[] = {
-    MockRead("HTTP/1.1 200 OK\r\n\r\n"),
-    MockRead("hello from http"),
-    MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
-    MockRead(ASYNC, OK)
-  };
+      MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"),
+      MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
+      MockRead(ASYNC, OK)};
 
-  StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
-                                     NULL, 0);
+  StaticSocketDataProvider http_data(
+      http_reads, arraysize(http_reads), NULL, 0);
   socket_factory_.AddSocketDataProvider(&http_data);
 
   CreateSession();
@@ -773,22 +745,20 @@ TEST_P(QuicNetworkTransactionTest, BrokenAlternateProtocolReadError) {
 
   // Alternate-protocol job
   MockRead quic_reads[] = {
-    MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED),
+      MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED),
   };
-  StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads),
-                                     NULL, 0);
+  StaticSocketDataProvider quic_data(
+      quic_reads, arraysize(quic_reads), NULL, 0);
   socket_factory_.AddSocketDataProvider(&quic_data);
 
   // Main job which will succeed even though the alternate job fails.
   MockRead http_reads[] = {
-    MockRead("HTTP/1.1 200 OK\r\n\r\n"),
-    MockRead("hello from http"),
-    MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
-    MockRead(ASYNC, OK)
-  };
+      MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"),
+      MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
+      MockRead(ASYNC, OK)};
 
-  StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
-                                     NULL, 0);
+  StaticSocketDataProvider http_data(
+      http_reads, arraysize(http_reads), NULL, 0);
   socket_factory_.AddSocketDataProvider(&http_data);
 
   CreateSession();
@@ -803,24 +773,22 @@ TEST_P(QuicNetworkTransactionTest, FailedZeroRttBrokenAlternateProtocol) {
 
   // Alternate-protocol job
   MockRead quic_reads[] = {
-    MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED),
+      MockRead(ASYNC, ERR_SOCKET_NOT_CONNECTED),
   };
-  StaticSocketDataProvider quic_data(quic_reads, arraysize(quic_reads),
-                                     NULL, 0);
+  StaticSocketDataProvider quic_data(
+      quic_reads, arraysize(quic_reads), NULL, 0);
   socket_factory_.AddSocketDataProvider(&quic_data);
 
   AddHangingNonAlternateProtocolSocketData();
 
   // Final job that will proceed when the QUIC job fails.
   MockRead http_reads[] = {
-    MockRead("HTTP/1.1 200 OK\r\n\r\n"),
-    MockRead("hello from http"),
-    MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
-    MockRead(ASYNC, OK)
-  };
+      MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"),
+      MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
+      MockRead(ASYNC, OK)};
 
-  StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
-                                     NULL, 0);
+  StaticSocketDataProvider http_data(
+      http_reads, arraysize(http_reads), NULL, 0);
   socket_factory_.AddSocketDataProvider(&http_data);
 
   CreateSession();
@@ -840,20 +808,18 @@ TEST_P(QuicNetworkTransactionTest, NoBrokenAlternateProtocolOnConnectFailure) {
 
   // Alternate-protocol job will fail before creating a QUIC session.
   StaticSocketDataProvider quic_data(NULL, 0, NULL, 0);
-  quic_data.set_connect_data(MockConnect(SYNCHRONOUS,
-                                         ERR_INTERNET_DISCONNECTED));
+  quic_data.set_connect_data(
+      MockConnect(SYNCHRONOUS, ERR_INTERNET_DISCONNECTED));
   socket_factory_.AddSocketDataProvider(&quic_data);
 
   // Main job which will succeed even though the alternate job fails.
   MockRead http_reads[] = {
-    MockRead("HTTP/1.1 200 OK\r\n\r\n"),
-    MockRead("hello from http"),
-    MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
-    MockRead(ASYNC, OK)
-  };
+      MockRead("HTTP/1.1 200 OK\r\n\r\n"), MockRead("hello from http"),
+      MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
+      MockRead(ASYNC, OK)};
 
-  StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
-                                     NULL, 0);
+  StaticSocketDataProvider http_data(
+      http_reads, arraysize(http_reads), NULL, 0);
   socket_factory_.AddSocketDataProvider(&http_data);
 
   CreateSession();
@@ -867,23 +833,20 @@ TEST_P(QuicNetworkTransactionTest, ConnectionCloseDuringConnect) {
 
   MockQuicData mock_quic_data;
   mock_quic_data.AddRead(ConstructConnectionClosePacket(1));
-  mock_quic_data.AddWrite(
-      ConstructRequestHeadersPacket(1, kStreamId5, true, true,
-                                    GetRequestHeaders("GET", "http", "/")));
+  mock_quic_data.AddWrite(ConstructRequestHeadersPacket(
+      1, kStreamId5, true, true, GetRequestHeaders("GET", "http", "/")));
   mock_quic_data.AddWrite(ConstructAckPacket(2, 1));
   mock_quic_data.AddDelayedSocketDataToFactory(&socket_factory_, 0);
 
   // When the QUIC connection fails, we will try the request again over HTTP.
   MockRead http_reads[] = {
-    MockRead("HTTP/1.1 200 OK\r\n"),
-    MockRead(kQuicAlternateProtocolHttpHeader),
-    MockRead("hello world"),
-    MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
-    MockRead(ASYNC, OK)
-  };
+      MockRead("HTTP/1.1 200 OK\r\n"),
+      MockRead(kQuicAlternateProtocolHttpHeader), MockRead("hello world"),
+      MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ),
+      MockRead(ASYNC, OK)};
 
-  StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
-                                     NULL, 0);
+  StaticSocketDataProvider http_data(
+      http_reads, arraysize(http_reads), NULL, 0);
   socket_factory_.AddSocketDataProvider(&http_data);
 
   // In order for a new QUIC session to be established via alternate-protocol