Clang format slam.

net/spdy/spdy_test_util_common.cc

Index: net/spdy/spdy_test_util_common.cc
diff --git a/net/spdy/spdy_test_util_common.cc b/net/spdy/spdy_test_util_common.cc
index 3926ebd5bf83041a3358239bda271d6381c49c69..6f19c211eab88d1286c90048fadd6cfed0c0aa1e 100644
--- a/net/spdy/spdy_test_util_common.cc
+++ b/net/spdy/spdy_test_util_common.cc
@@ -31,12 +31,14 @@ namespace {
 
 bool next_proto_is_spdy(NextProto next_proto) {
   return next_proto >= kProtoSPDYMinimumVersion &&
-      next_proto <= kProtoSPDYMaximumVersion;
+         next_proto <= kProtoSPDYMaximumVersion;
 }
 
 // Parses a URL into the scheme, host, and path components required for a
 // SPDY request.
-void ParseUrl(base::StringPiece url, std::string* scheme, std::string* host,
+void ParseUrl(base::StringPiece url,
+              std::string* scheme,
+              std::string* host,
               std::string* path) {
   GURL gurl(url.as_string());
   path->assign(gurl.PathForRequest());
@@ -183,8 +185,10 @@ MockRead CreateMockRead(const SpdyFrame& resp, int seq, IoMode mode) {
 
 // Combines the given SpdyFrames into the given char array and returns
 // the total length.
-int CombineFrames(const SpdyFrame** frames, int num_frames,
-                  char* buff, int buff_len) {
+int CombineFrames(const SpdyFrame** frames,
+                  int num_frames,
+                  char* buff,
+                  int buff_len) {
   int total_len = 0;
   for (int i = 0; i < num_frames; ++i) {
     total_len += frames[i]->size();
@@ -206,9 +210,7 @@ class PriorityGetter : public BufferedSpdyFramerVisitorInterface {
   PriorityGetter() : priority_(0) {}
   virtual ~PriorityGetter() {}
 
-  SpdyPriority priority() const {
-    return priority_;
-  }
+  SpdyPriority priority() const { return priority_; }
 
   virtual void OnError(SpdyFramer::SpdyError error_code) OVERRIDE {}
   virtual void OnStreamError(SpdyStreamId stream_id,
@@ -235,8 +237,9 @@ class PriorityGetter : public BufferedSpdyFramerVisitorInterface {
                                  size_t len,
                                  bool fin) OVERRIDE {}
   virtual void OnSettings(bool clear_persisted) OVERRIDE {}
-  virtual void OnSetting(
-      SpdySettingsIds id, uint8 flags, uint32 value) OVERRIDE {}
+  virtual void OnSetting(SpdySettingsIds id,
+                         uint8 flags,
+                         uint32 value) OVERRIDE {}
   virtual void OnPing(SpdyPingId unique_id, bool is_ack) OVERRIDE {}
   virtual void OnRstStream(SpdyStreamId stream_id,
                            SpdyRstStreamStatus status) OVERRIDE {}
@@ -274,25 +277,26 @@ base::WeakPtr<SpdyStream> CreateStreamSynchronously(
     RequestPriority priority,
     const BoundNetLog& net_log) {
   SpdyStreamRequest stream_request;
-  int rv = stream_request.StartRequest(type, session, url, priority, net_log,
-                                       CompletionCallback());
-  return
-      (rv == OK) ? stream_request.ReleaseStream() : base::WeakPtr<SpdyStream>();
+  int rv = stream_request.StartRequest(
+      type, session, url, priority, net_log, CompletionCallback());
+  return (rv == OK) ? stream_request.ReleaseStream()
+                    : base::WeakPtr<SpdyStream>();
 }
 
-StreamReleaserCallback::StreamReleaserCallback() {}
+StreamReleaserCallback::StreamReleaserCallback() {
+}
 
-StreamReleaserCallback::~StreamReleaserCallback() {}
+StreamReleaserCallback::~StreamReleaserCallback() {
+}
 
 CompletionCallback StreamReleaserCallback::MakeCallback(
     SpdyStreamRequest* request) {
-  return base::Bind(&StreamReleaserCallback::OnComplete,
-                    base::Unretained(this),
-                    request);
+  return base::Bind(
+      &StreamReleaserCallback::OnComplete, base::Unretained(this), request);
 }
 
-void StreamReleaserCallback::OnComplete(
-    SpdyStreamRequest* request, int result) {
+void StreamReleaserCallback::OnComplete(SpdyStreamRequest* request,
+                                        int result) {
   if (result == OK)
     request->ReleaseStream()->Cancel();
   SetResult(result);
@@ -312,8 +316,8 @@ bool MockECSignatureCreator::Sign(const uint8* data,
 
   signature->clear();
   signature->insert(signature->end(), head.begin(), head.end());
-  signature->insert(signature->end(), private_key_value.begin(),
-                    private_key_value.end());
+  signature->insert(
+      signature->end(), private_key_value.begin(), private_key_value.end());
   signature->insert(signature->end(), '-');
   signature->insert(signature->end(), data, data + data_len);
   signature->insert(signature->end(), tail.begin(), tail.end());
@@ -369,8 +373,8 @@ SpdySessionDependencies::SpdySessionDependencies(NextProto protocol)
   host_resolver->set_synchronous_mode(true);
 }
 
-SpdySessionDependencies::SpdySessionDependencies(
-    NextProto protocol, ProxyService* proxy_service)
+SpdySessionDependencies::SpdySessionDependencies(NextProto protocol,
+                                                 ProxyService* proxy_service)
     : host_resolver(new MockHostResolver),
       cert_verifier(new MockCertVerifier),
       transport_security_state(new TransportSecurityState),
@@ -391,7 +395,8 @@ SpdySessionDependencies::SpdySessionDependencies(
   DCHECK(next_proto_is_spdy(protocol)) << "Invalid protocol: " << protocol;
 }
 
-SpdySessionDependencies::~SpdySessionDependencies() {}
+SpdySessionDependencies::~SpdySessionDependencies() {
+}
 
 // static
 HttpNetworkSession* SpdySessionDependencies::SpdyCreateSession(
@@ -419,8 +424,8 @@ HttpNetworkSession* SpdySessionDependencies::SpdyCreateSessionDeterministic(
 // static
 net::HttpNetworkSession::Params SpdySessionDependencies::CreateSessionParams(
     SpdySessionDependencies* session_deps) {
-  DCHECK(next_proto_is_spdy(session_deps->protocol)) <<
-      "Invalid protocol: " << session_deps->protocol;
+  DCHECK(next_proto_is_spdy(session_deps->protocol))
+      << "Invalid protocol: " << session_deps->protocol;
 
   net::HttpNetworkSession::Params params;
   params.host_resolver = session_deps->host_resolver.get();
@@ -455,8 +460,8 @@ SpdyURLRequestContext::SpdyURLRequestContext(NextProto protocol)
   storage_.set_transport_security_state(new TransportSecurityState);
   storage_.set_proxy_service(ProxyService::CreateDirect());
   storage_.set_ssl_config_service(new SSLConfigServiceDefaults);
-  storage_.set_http_auth_handler_factory(HttpAuthHandlerFactory::CreateDefault(
-      host_resolver()));
+  storage_.set_http_auth_handler_factory(
+      HttpAuthHandlerFactory::CreateDefault(host_resolver()));
   storage_.set_http_server_properties(
       scoped_ptr<HttpServerProperties>(new HttpServerPropertiesImpl()));
   net::HttpNetworkSession::Params params;
@@ -499,8 +504,7 @@ base::WeakPtr<SpdySession> CreateSpdySessionHelper(
 
   scoped_refptr<TransportSocketParams> transport_params(
       new TransportSocketParams(
-          key.host_port_pair(), false, false,
-          OnHostResolutionCallback()));
+          key.host_port_pair(), false, false, OnHostResolutionCallback()));
 
   scoped_ptr<ClientSocketHandle> connection(new ClientSocketHandle);
   TestCompletionCallback callback;
@@ -518,13 +522,13 @@ base::WeakPtr<SpdySession> CreateSpdySessionHelper(
                             0,
                             false,
                             false));
-    rv = connection->Init(key.host_port_pair().ToString(),
-                          ssl_params,
-                          MEDIUM,
-                          callback.callback(),
-                          http_session->GetSSLSocketPool(
-                              HttpNetworkSession::NORMAL_SOCKET_POOL),
-                          net_log);
+    rv = connection->Init(
+        key.host_port_pair().ToString(),
+        ssl_params,
+        MEDIUM,
+        callback.callback(),
+        http_session->GetSSLSocketPool(HttpNetworkSession::NORMAL_SOCKET_POOL),
+        net_log);
   } else {
     rv = connection->Init(key.host_port_pair().ToString(),
                           transport_params,
@@ -555,8 +559,8 @@ base::WeakPtr<SpdySession> CreateInsecureSpdySession(
     const scoped_refptr<HttpNetworkSession>& http_session,
     const SpdySessionKey& key,
     const BoundNetLog& net_log) {
-  return CreateSpdySessionHelper(http_session, key, net_log,
-                                 OK, false /* is_secure */);
+  return CreateSpdySessionHelper(
+      http_session, key, net_log, OK, false /* is_secure */);
 }
 
 base::WeakPtr<SpdySession> TryCreateInsecureSpdySessionExpectingFailure(
@@ -565,16 +569,16 @@ base::WeakPtr<SpdySession> TryCreateInsecureSpdySessionExpectingFailure(
     Error expected_error,
     const BoundNetLog& net_log) {
   DCHECK_LT(expected_error, ERR_IO_PENDING);
-  return CreateSpdySessionHelper(http_session, key, net_log,
-                                 expected_error, false /* is_secure */);
+  return CreateSpdySessionHelper(
+      http_session, key, net_log, expected_error, false /* is_secure */);
 }
 
 base::WeakPtr<SpdySession> CreateSecureSpdySession(
     const scoped_refptr<HttpNetworkSession>& http_session,
     const SpdySessionKey& key,
     const BoundNetLog& net_log) {
-  return CreateSpdySessionHelper(http_session, key, net_log,
-                                 OK, true /* is_secure */);
+  return CreateSpdySessionHelper(
+      http_session, key, net_log, OK, true /* is_secure */);
 }
 
 namespace {
@@ -583,17 +587,18 @@ namespace {
 class FakeSpdySessionClientSocket : public MockClientSocket {
  public:
   FakeSpdySessionClientSocket(int read_result)
-      : MockClientSocket(BoundNetLog()),
-        read_result_(read_result) {}
+      : MockClientSocket(BoundNetLog()), read_result_(read_result) {}
 
   virtual ~FakeSpdySessionClientSocket() {}
 
-  virtual int Read(IOBuffer* buf, int buf_len,
+  virtual int Read(IOBuffer* buf,
+                   int buf_len,
                    const CompletionCallback& callback) OVERRIDE {
     return read_result_;
   }
 
-  virtual int Write(IOBuffer* buf, int buf_len,
+  virtual int Write(IOBuffer* buf,
+                    int buf_len,
                     const CompletionCallback& callback) OVERRIDE {
     return ERR_IO_PENDING;
   }
@@ -739,28 +744,28 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyFrame(
   SpdyFrame* frame = NULL;
   switch (header_info.kind) {
     case DATA:
-      frame = framer.CreateDataFrame(header_info.id, header_info.data,
+      frame = framer.CreateDataFrame(header_info.id,
+                                     header_info.data,
                                      header_info.data_length,
                                      header_info.data_flags);
       break;
-    case SYN_STREAM:
-      {
-        frame = framer.CreateSynStream(header_info.id, header_info.assoc_id,
-                                       header_info.priority,
-                                       header_info.control_flags,
-                                       headers.get());
-      }
-      break;
+    case SYN_STREAM: {
+      frame = framer.CreateSynStream(header_info.id,
+                                     header_info.assoc_id,
+                                     header_info.priority,
+                                     header_info.control_flags,
+                                     headers.get());
+    } break;
     case SYN_REPLY:
-      frame = framer.CreateSynReply(header_info.id, header_info.control_flags,
-                                    headers.get());
+      frame = framer.CreateSynReply(
+          header_info.id, header_info.control_flags, headers.get());
       break;
     case RST_STREAM:
       frame = framer.CreateRstStream(header_info.id, header_info.status);
       break;
     case HEADERS:
-      frame = framer.CreateHeaders(header_info.id, header_info.control_flags,
-                                   headers.get());
+      frame = framer.CreateHeaders(
+          header_info.id, header_info.control_flags, headers.get());
       break;
     default:
       ADD_FAILURE();
@@ -792,18 +797,17 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyControlFrame(
   EXPECT_GE(type, FIRST_CONTROL_TYPE);
   EXPECT_LE(type, LAST_CONTROL_TYPE);
   const SpdyHeaderInfo header_info = {
-    type,
-    stream_id,
-    associated_stream_id,
-    ConvertRequestPriorityToSpdyPriority(request_priority, spdy_version_),
-    0,  // credential slot
-    flags,
-    compressed,
-    RST_STREAM_INVALID,  // status
-    NULL,  // data
-    0,  // length
-    DATA_FLAG_NONE
-  };
+      type,
+      stream_id,
+      associated_stream_id,
+      ConvertRequestPriorityToSpdyPriority(request_priority, spdy_version_),
+      0,  // credential slot
+      flags,
+      compressed,
+      RST_STREAM_INVALID,  // status
+      NULL,                // data
+      0,                   // length
+      DATA_FLAG_NONE};
   return ConstructSpdyFrame(header_info, headers.Pass());
 }
 
@@ -822,16 +826,21 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyControlFrame(
   AppendToHeaderBlock(extra_headers, extra_header_count, headers.get());
   if (tail_headers && tail_header_size)
     AppendToHeaderBlock(tail_headers, tail_header_size / 2, headers.get());
-  return ConstructSpdyControlFrame(
-      headers.Pass(), compressed, stream_id,
-      request_priority, type, flags, associated_stream_id);
+  return ConstructSpdyControlFrame(headers.Pass(),
+                                   compressed,
+                                   stream_id,
+                                   request_priority,
+                                   type,
+                                   flags,
+                                   associated_stream_id);
 }
 
 std::string SpdyTestUtil::ConstructSpdyReplyString(
     const SpdyHeaderBlock& headers) const {
   std::string reply_string;
   for (SpdyHeaderBlock::const_iterator it = headers.begin();
-       it != headers.end(); ++it) {
+       it != headers.end();
+       ++it) {
     std::string key = it->first;
     // Remove leading colon from "special" headers (for SPDY3 and
     // above).
@@ -840,7 +849,8 @@ std::string SpdyTestUtil::ConstructSpdyReplyString(
     std::vector<std::string> values;
     base::SplitString(it->second, '\0', &values);
     for (std::vector<std::string>::const_iterator it2 = values.begin();
-         it2 != values.end(); ++it2) {
+         it2 != values.end();
+         ++it2) {
       reply_string += key + ": " + *it2 + "\n";
     }
   }
@@ -852,8 +862,7 @@ std::string SpdyTestUtil::ConstructSpdyReplyString(
 SpdyFrame* SpdyTestUtil::ConstructSpdySettings(
     const SettingsMap& settings) const {
   SpdySettingsIR settings_ir;
-  for (SettingsMap::const_iterator it = settings.begin();
-       it != settings.end();
+  for (SettingsMap::const_iterator it = settings.begin(); it != settings.end();
        ++it) {
     settings_ir.AddSetting(
         it->first,
@@ -881,7 +890,8 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyGoAway(
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyWindowUpdate(
-    const SpdyStreamId stream_id, uint32 delta_window_size) const {
+    const SpdyStreamId stream_id,
+    uint32 delta_window_size) const {
   SpdyWindowUpdateIR update_ir(stream_id, delta_window_size);
   return CreateFramer(false)->SerializeFrame(update_ir);
 }
@@ -901,18 +911,17 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyGet(
     SpdyStreamId stream_id,
     RequestPriority request_priority) const {
   const SpdyHeaderInfo header_info = {
-    SYN_STREAM,
-    stream_id,
-    0,                   // associated stream ID
-    ConvertRequestPriorityToSpdyPriority(request_priority, spdy_version_),
-    0,                   // credential slot
-    CONTROL_FLAG_FIN,
-    compressed,
-    RST_STREAM_INVALID,  // status
-    NULL,                // data
-    0,                   // length
-    DATA_FLAG_NONE
-  };
+      SYN_STREAM,
+      stream_id,
+      0,  // associated stream ID
+      ConvertRequestPriorityToSpdyPriority(request_priority, spdy_version_),
+      0,  // credential slot
+      CONTROL_FLAG_FIN,
+      compressed,
+      RST_STREAM_INVALID,  // status
+      NULL,                // data
+      0,                   // length
+      DATA_FLAG_NONE};
   return ConstructSpdyFrame(header_info, ConstructGetHeaderBlock(url));
 }
 
@@ -929,19 +938,18 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyGet(const char* const extra_headers[],
   syn_stream.SetHeader(GetMethodKey(), "GET");
   syn_stream.SetHeader(GetHostKey(), "www.google.com");
   syn_stream.SetHeader(GetSchemeKey(), "http");
-  syn_stream.SetHeader(GetPathKey(), (is_spdy2() && !direct) ?
-                       "http://www.google.com/" : "/");
+  syn_stream.SetHeader(
+      GetPathKey(), (is_spdy2() && !direct) ? "http://www.google.com/" : "/");
   MaybeAddVersionHeader(&syn_stream);
-  AppendToHeaderBlock(extra_headers, extra_header_count,
-                      syn_stream.mutable_name_value_block());
+  AppendToHeaderBlock(
+      extra_headers, extra_header_count, syn_stream.mutable_name_value_block());
   return CreateFramer(compressed)->SerializeFrame(syn_stream);
 }
 
-SpdyFrame* SpdyTestUtil::ConstructSpdyConnect(
-    const char* const extra_headers[],
-    int extra_header_count,
-    int stream_id,
-    RequestPriority priority) const {
+SpdyFrame* SpdyTestUtil::ConstructSpdyConnect(const char* const extra_headers[],
+                                              int extra_header_count,
+                                              int stream_id,
+                                              RequestPriority priority) const {
   SpdySynStreamIR syn_stream(stream_id);
   syn_stream.set_priority(
       ConvertRequestPriorityToSpdyPriority(priority, spdy_version_));
@@ -949,8 +957,8 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyConnect(
   syn_stream.SetHeader(GetPathKey(), "www.google.com:443");
   syn_stream.SetHeader(GetHostKey(), "www.google.com");
   MaybeAddVersionHeader(&syn_stream);
-  AppendToHeaderBlock(extra_headers, extra_header_count,
-                      syn_stream.mutable_name_value_block());
+  AppendToHeaderBlock(
+      extra_headers, extra_header_count, syn_stream.mutable_name_value_block());
   return CreateFramer(false)->SerializeFrame(syn_stream);
 }
 
@@ -1008,8 +1016,8 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyPushHeaders(
   SpdyHeadersIR headers(stream_id);
   headers.SetHeader(GetStatusKey(), "200 OK");
   MaybeAddVersionHeader(&headers);
-  AppendToHeaderBlock(extra_headers, extra_header_count,
-                      headers.mutable_name_value_block());
+  AppendToHeaderBlock(
+      extra_headers, extra_header_count, headers.mutable_name_value_block());
   return CreateFramer(false)->SerializeFrame(headers);
 }
 
@@ -1022,17 +1030,19 @@ SpdyFrame* SpdyTestUtil::ConstructSpdySynReplyError(
   syn_reply.SetHeader("hello", "bye");
   syn_reply.SetHeader(GetStatusKey(), status);
   MaybeAddVersionHeader(&syn_reply);
-  AppendToHeaderBlock(extra_headers, extra_header_count,
-                      syn_reply.mutable_name_value_block());
+  AppendToHeaderBlock(
+      extra_headers, extra_header_count, syn_reply.mutable_name_value_block());
   return CreateFramer(false)->SerializeFrame(syn_reply);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdyGetSynReplyRedirect(int stream_id) {
   static const char* const kExtraHeaders[] = {
-    "location", "http://www.foo.com/index.php",
+      "location", "http://www.foo.com/index.php",
   };
-  return ConstructSpdySynReplyError("301 Moved Permanently", kExtraHeaders,
-                                    arraysize(kExtraHeaders)/2, stream_id);
+  return ConstructSpdySynReplyError("301 Moved Permanently",
+                                    kExtraHeaders,
+                                    arraysize(kExtraHeaders) / 2,
+                                    stream_id);
 }
 
 SpdyFrame* SpdyTestUtil::ConstructSpdySynReplyError(int stream_id) {
@@ -1047,8 +1057,8 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyGetSynReply(
   syn_reply.SetHeader("hello", "bye");
   syn_reply.SetHeader(GetStatusKey(), "200");
   MaybeAddVersionHeader(&syn_reply);
-  AppendToHeaderBlock(extra_headers, extra_header_count,
-                      syn_reply.mutable_name_value_block());
+  AppendToHeaderBlock(
+      extra_headers, extra_header_count, syn_reply.mutable_name_value_block());
   return CreateFramer(false)->SerializeFrame(syn_reply);
 }
 
@@ -1059,20 +1069,19 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyPost(const char* url,
                                            const char* const extra_headers[],
                                            int extra_header_count) {
   const SpdyHeaderInfo kSynStartHeader = {
-    SYN_STREAM,
-    stream_id,
-    0,                      // Associated stream ID
-    ConvertRequestPriorityToSpdyPriority(priority, spdy_version_),
-    kSpdyCredentialSlotUnused,
-    CONTROL_FLAG_NONE,
-    false,                  // Compressed
-    RST_STREAM_INVALID,
-    NULL,                   // Data
-    0,                      // Length
-    DATA_FLAG_NONE
-  };
-  return ConstructSpdyFrame(
-      kSynStartHeader, ConstructPostHeaderBlock(url, content_length));
+      SYN_STREAM,
+      stream_id,
+      0,  // Associated stream ID
+      ConvertRequestPriorityToSpdyPriority(priority, spdy_version_),
+      kSpdyCredentialSlotUnused,
+      CONTROL_FLAG_NONE,
+      false,  // Compressed
+      RST_STREAM_INVALID,
+      NULL,  // Data
+      0,     // Length
+      DATA_FLAG_NONE};
+  return ConstructSpdyFrame(kSynStartHeader,
+                            ConstructPostHeaderBlock(url, content_length));
 }
 
 SpdyFrame* SpdyTestUtil::ConstructChunkedSpdyPost(
@@ -1085,8 +1094,8 @@ SpdyFrame* SpdyTestUtil::ConstructChunkedSpdyPost(
   syn_stream.SetHeader(GetSchemeKey(), "http");
   MaybeAddVersionHeader(&syn_stream);
   SetPriority(LOWEST, &syn_stream);
-  AppendToHeaderBlock(extra_headers, extra_header_count,
-                      syn_stream.mutable_name_value_block());
+  AppendToHeaderBlock(
+      extra_headers, extra_header_count, syn_stream.mutable_name_value_block());
   return CreateFramer(false)->SerializeFrame(syn_stream);
 }
 
@@ -1098,8 +1107,8 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyPostSynReply(
   syn_reply.SetHeader(GetStatusKey(), "200");
   syn_reply.SetHeader(GetPathKey(), "/index.php");
   MaybeAddVersionHeader(&syn_reply);
-  AppendToHeaderBlock(extra_headers, extra_header_count,
-                      syn_reply.mutable_name_value_block());
+  AppendToHeaderBlock(
+      extra_headers, extra_header_count, syn_reply.mutable_name_value_block());
   return CreateFramer(false)->SerializeFrame(syn_reply);
 }
 
@@ -1124,24 +1133,22 @@ SpdyFrame* SpdyTestUtil::ConstructSpdyBodyFrame(int stream_id,
 SpdyFrame* SpdyTestUtil::ConstructWrappedSpdyFrame(
     const scoped_ptr<SpdyFrame>& frame,
     int stream_id) {
-  return ConstructSpdyBodyFrame(stream_id, frame->data(),
-                                frame->size(), false);
+  return ConstructSpdyBodyFrame(stream_id, frame->data(), frame->size(), false);
 }
 
 const SpdyHeaderInfo SpdyTestUtil::MakeSpdyHeader(SpdyFrameType type) {
   const SpdyHeaderInfo kHeader = {
-    type,
-    1,                            // Stream ID
-    0,                            // Associated stream ID
-    ConvertRequestPriorityToSpdyPriority(LOWEST, spdy_version_),
-    kSpdyCredentialSlotUnused,
-    CONTROL_FLAG_FIN,             // Control Flags
-    false,                        // Compressed
-    RST_STREAM_INVALID,
-    NULL,                         // Data
-    0,                            // Length
-    DATA_FLAG_NONE
-  };
+      type,
+      1,  // Stream ID
+      0,  // Associated stream ID
+      ConvertRequestPriorityToSpdyPriority(LOWEST, spdy_version_),
+      kSpdyCredentialSlotUnused,
+      CONTROL_FLAG_FIN,  // Control Flags
+      false,             // Compressed
+      RST_STREAM_INVALID,
+      NULL,  // Data
+      0,     // Length
+      DATA_FLAG_NONE};
   return kHeader;
 }
 
@@ -1210,8 +1217,8 @@ void SpdyTestUtil::MaybeAddVersionHeader(
 
 void SpdyTestUtil::SetPriority(RequestPriority priority,
                                SpdySynStreamIR* ir) const {
-  ir->set_priority(ConvertRequestPriorityToSpdyPriority(
-      priority, spdy_version()));
+  ir->set_priority(
+      ConvertRequestPriorityToSpdyPriority(priority, spdy_version()));
 }
 
 }  // namespace net