Clang format slam.

net/http/failing_http_transaction_factory.cc

Index: net/http/failing_http_transaction_factory.cc
diff --git a/net/http/failing_http_transaction_factory.cc b/net/http/failing_http_transaction_factory.cc
index d1d1612966d7eb67372bab24d28a176d43603534..2ea37c46a74f58e2c41b506aa0131ca2f4da4af8 100644
--- a/net/http/failing_http_transaction_factory.cc
+++ b/net/http/failing_http_transaction_factory.cc
@@ -40,11 +40,11 @@ class FailingHttpTransaction : public HttpTransaction {
   virtual int RestartWithCertificate(
       X509Certificate* client_cert,
       const CompletionCallback& callback) OVERRIDE;
-  virtual int RestartWithAuth(
-      const AuthCredentials& credentials,
-      const CompletionCallback& callback) OVERRIDE;
+  virtual int RestartWithAuth(const AuthCredentials& credentials,
+                              const CompletionCallback& callback) OVERRIDE;
   virtual bool IsReadyToRestartForAuth() OVERRIDE;
-  virtual int Read(IOBuffer* buf, int buf_len,
+  virtual int Read(IOBuffer* buf,
+                   int buf_len,
                    const CompletionCallback& callback) OVERRIDE;
   virtual void StopCaching() OVERRIDE;
   virtual bool GetFullRequestHeaders(
@@ -73,90 +73,95 @@ FailingHttpTransaction::FailingHttpTransaction(Error error) : error_(error) {
   DCHECK_LT(error, OK);
 }
 
-FailingHttpTransaction::~FailingHttpTransaction() {}
+FailingHttpTransaction::~FailingHttpTransaction() {
+}
 
 int FailingHttpTransaction::Start(const HttpRequestInfo* request_info,
                                   const CompletionCallback& callback,
-                                  const BoundNetLog& net_log)  {
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(callback, error_));
+                                  const BoundNetLog& net_log) {
+  base::MessageLoop::current()->PostTask(FROM_HERE,
+                                         base::Bind(callback, error_));
   return ERR_IO_PENDING;
 }
 
 int FailingHttpTransaction::RestartIgnoringLastError(
-    const CompletionCallback& callback)  {
+    const CompletionCallback& callback) {
   return ERR_FAILED;
 }
 
 int FailingHttpTransaction::RestartWithCertificate(
     X509Certificate* client_cert,
-    const CompletionCallback& callback)  {
+    const CompletionCallback& callback) {
   return ERR_FAILED;
 }
 
 int FailingHttpTransaction::RestartWithAuth(
     const AuthCredentials& credentials,
-    const CompletionCallback& callback)  {
+    const CompletionCallback& callback) {
   return ERR_FAILED;
 }
 
-bool FailingHttpTransaction::IsReadyToRestartForAuth()  {
+bool FailingHttpTransaction::IsReadyToRestartForAuth() {
   return false;
 }
 
-int FailingHttpTransaction::Read(IOBuffer* buf, int buf_len,
-                                 const CompletionCallback& callback)  {
+int FailingHttpTransaction::Read(IOBuffer* buf,
+                                 int buf_len,
+                                 const CompletionCallback& callback) {
   NOTREACHED();
   return ERR_FAILED;
 }
 
-void FailingHttpTransaction::StopCaching()  {}
+void FailingHttpTransaction::StopCaching() {
+}
 
 bool FailingHttpTransaction::GetFullRequestHeaders(
-    HttpRequestHeaders* headers) const  {
+    HttpRequestHeaders* headers) const {
   return false;
 }
 
-int64 FailingHttpTransaction::GetTotalReceivedBytes() const  {
+int64 FailingHttpTransaction::GetTotalReceivedBytes() const {
   return 0;
 }
 
-void FailingHttpTransaction::DoneReading()  {
+void FailingHttpTransaction::DoneReading() {
   NOTREACHED();
 }
 
-const HttpResponseInfo* FailingHttpTransaction::GetResponseInfo() const  {
+const HttpResponseInfo* FailingHttpTransaction::GetResponseInfo() const {
   return NULL;
 }
 
-LoadState FailingHttpTransaction::GetLoadState() const  {
+LoadState FailingHttpTransaction::GetLoadState() const {
   return LOAD_STATE_IDLE;
 }
 
-UploadProgress FailingHttpTransaction::GetUploadProgress() const  {
+UploadProgress FailingHttpTransaction::GetUploadProgress() const {
   return UploadProgress();
 }
 
 void FailingHttpTransaction::SetQuicServerInfo(
-    net::QuicServerInfo* quic_server_info) {}
+    net::QuicServerInfo* quic_server_info) {
+}
 
 bool FailingHttpTransaction::GetLoadTimingInfo(
-    LoadTimingInfo* load_timing_info) const  {
+    LoadTimingInfo* load_timing_info) const {
   return false;
 }
 
-void FailingHttpTransaction::SetPriority(RequestPriority priority)  {}
+void FailingHttpTransaction::SetPriority(RequestPriority priority) {
+}
 
 void FailingHttpTransaction::SetWebSocketHandshakeStreamCreateHelper(
-    WebSocketHandshakeStreamBase::CreateHelper* create_helper)  {
+    WebSocketHandshakeStreamBase::CreateHelper* create_helper) {
   NOTREACHED();
 }
 
 void FailingHttpTransaction::SetBeforeNetworkStartCallback(
-    const BeforeNetworkStartCallback& callback)  {
+    const BeforeNetworkStartCallback& callback) {
 }
 
-int FailingHttpTransaction::ResumeNetworkStart()  {
+int FailingHttpTransaction::ResumeNetworkStart() {
   NOTREACHED();
   return ERR_FAILED;
 }
@@ -165,11 +170,13 @@ int FailingHttpTransaction::ResumeNetworkStart()  {
 
 FailingHttpTransactionFactory::FailingHttpTransactionFactory(
     HttpNetworkSession* session,
-    Error error) : session_(session), error_(error) {
+    Error error)
+    : session_(session), error_(error) {
   DCHECK_LT(error, OK);
 }
 
-FailingHttpTransactionFactory::~FailingHttpTransactionFactory() {}
+FailingHttpTransactionFactory::~FailingHttpTransactionFactory() {
+}
 
 // HttpTransactionFactory:
 int FailingHttpTransactionFactory::CreateTransaction(
@@ -188,4 +195,3 @@ HttpNetworkSession* FailingHttpTransactionFactory::GetSession() {
 }
 
 }  // namespace net
-