Clang format slam.

net/http/http_transaction_unittest.h

 // 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.
 
 #ifndef NET_HTTP_HTTP_TRANSACTION_UNITTEST_H_
 #define NET_HTTP_HTTP_TRANSACTION_UNITTEST_H_
 
 #include "net/http/http_transaction.h"
 
 #include <string>
@@ skipping 19 matching lines @@
 class IOBuffer;
 }
 
 //-----------------------------------------------------------------------------
 // mock transaction data
 
 // these flags may be combined to form the test_mode field
 enum {
   TEST_MODE_NORMAL = 0,
   TEST_MODE_SYNC_NET_START = 1 << 0,
-  TEST_MODE_SYNC_NET_READ  = 1 << 1,
+  TEST_MODE_SYNC_NET_READ = 1 << 1,
   TEST_MODE_SYNC_CACHE_START = 1 << 2,
-  TEST_MODE_SYNC_CACHE_READ  = 1 << 3,
-  TEST_MODE_SYNC_CACHE_WRITE  = 1 << 4,
+  TEST_MODE_SYNC_CACHE_READ = 1 << 3,
+  TEST_MODE_SYNC_CACHE_WRITE = 1 << 4,
   TEST_MODE_SYNC_ALL = (TEST_MODE_SYNC_NET_START | TEST_MODE_SYNC_NET_READ |
-                        TEST_MODE_SYNC_CACHE_START | TEST_MODE_SYNC_CACHE_READ |
+                        TEST_MODE_SYNC_CACHE_START |
+                        TEST_MODE_SYNC_CACHE_READ |
                         TEST_MODE_SYNC_CACHE_WRITE),
   TEST_MODE_SLOW_READ = 1 << 5
 };
 
 typedef void (*MockTransactionHandler)(const net::HttpRequestInfo* request,
                                        std::string* response_status,
                                        std::string* response_headers,
                                        std::string* response_data);
 
 struct MockTransaction {
@@ skipping 24 matching lines @@
 
 // returns the mock transaction for the given URL
 const MockTransaction* FindMockTransaction(const GURL& url);
 
 // Add/Remove a mock transaction that can be accessed via FindMockTransaction.
 // There can be only one MockTransaction associated with a given URL.
 void AddMockTransaction(const MockTransaction* trans);
 void RemoveMockTransaction(const MockTransaction* trans);
 
 struct ScopedMockTransaction : MockTransaction {
-  ScopedMockTransaction() {
-    AddMockTransaction(this);
-  }
+  ScopedMockTransaction() { AddMockTransaction(this); }
   explicit ScopedMockTransaction(const MockTransaction& t)
       : MockTransaction(t) {
     AddMockTransaction(this);
   }
-  ~ScopedMockTransaction() {
-    RemoveMockTransaction(this);
-  }
+  ~ScopedMockTransaction() { RemoveMockTransaction(this); }
 };
 
 //-----------------------------------------------------------------------------
 // mock http request
 
 class MockHttpRequest : public net::HttpRequestInfo {
  public:
   explicit MockHttpRequest(const MockTransaction& t);
 };
 
@@ skipping 11 matching lines @@
 
   bool is_done() const { return state_ == DONE; }
   int error() const { return error_; }
 
   const net::HttpResponseInfo* response_info() const {
     return trans_->GetResponseInfo();
   }
   const std::string& content() const { return content_; }
 
  private:
-  enum State {
-    IDLE,
-    STARTING,
-    READING,
-    DONE
-  };
+  enum State { IDLE, STARTING, READING, DONE };
 
   void DidStart(int result);
   void DidRead(int result);
   void DidFinish(int result);
   void Read();
 
   void OnIOComplete(int result);
 
   State state_;
   scoped_ptr<net::HttpTransaction> trans_;
@@ skipping 10 matching lines @@
 class MockNetworkLayer;
 
 // This transaction class inspects the available set of mock transactions to
 // find data for the request URL.  It supports IO operations that complete
 // synchronously or asynchronously to help exercise different code paths in the
 // HttpCache implementation.
 class MockNetworkTransaction
     : public net::HttpTransaction,
       public base::SupportsWeakPtr<MockNetworkTransaction> {
   typedef net::WebSocketHandshakeStreamBase::CreateHelper CreateHelper;
+
  public:
   MockNetworkTransaction(net::RequestPriority priority,
                          MockNetworkLayer* factory);
   virtual ~MockNetworkTransaction();
 
   virtual int Start(const net::HttpRequestInfo* request,
                     const net::CompletionCallback& callback,
                     const net::BoundNetLog& net_log) OVERRIDE;
 
   virtual int RestartIgnoringLastError(
       const net::CompletionCallback& callback) OVERRIDE;
 
   virtual int RestartWithCertificate(
       net::X509Certificate* client_cert,
       const net::CompletionCallback& callback) OVERRIDE;
 
-  virtual int RestartWithAuth(
-      const net::AuthCredentials& credentials,
-      const net::CompletionCallback& callback) OVERRIDE;
+  virtual int RestartWithAuth(const net::AuthCredentials& credentials,
+                              const net::CompletionCallback& callback) OVERRIDE;
 
   virtual bool IsReadyToRestartForAuth() OVERRIDE;
 
-  virtual int Read(net::IOBuffer* buf, int buf_len,
+  virtual int Read(net::IOBuffer* buf,
+                   int buf_len,
                    const net::CompletionCallback& callback) OVERRIDE;
 
   virtual void StopCaching() OVERRIDE;
 
   virtual bool GetFullRequestHeaders(
       net::HttpRequestHeaders* headers) const OVERRIDE;
 
   virtual int64 GetTotalReceivedBytes() const OVERRIDE;
 
   virtual void DoneReading() OVERRIDE;
@@ skipping 71 matching lines @@
   // CreateTransaction. Returns a NULL WeakPtr if one has not been
   // created yet, or the last transaction has been destroyed, or
   // ClearLastTransaction() has been called and a new transaction
   // hasn't been created yet.
   base::WeakPtr<MockNetworkTransaction> last_transaction() {
     return last_transaction_;
   }
 
   // Makes last_transaction() return NULL until the next transaction
   // is created.
-  void ClearLastTransaction() {
-    last_transaction_.reset();
-  }
+  void ClearLastTransaction() { last_transaction_.reset(); }
 
   // net::HttpTransactionFactory:
   virtual int CreateTransaction(
       net::RequestPriority priority,
       scoped_ptr<net::HttpTransaction>* trans) OVERRIDE;
   virtual net::HttpCache* GetCache() OVERRIDE;
   virtual net::HttpNetworkSession* GetSession() OVERRIDE;
 
  private:
   int transaction_count_;
   bool done_reading_called_;
   bool stop_caching_called_;
   net::RequestPriority last_create_transaction_priority_;
   base::WeakPtr<MockNetworkTransaction> last_transaction_;
 };
 
 //-----------------------------------------------------------------------------
 // helpers
 
 // read the transaction completely
 int ReadTransaction(net::HttpTransaction* trans, std::string* result);
 
 #endif  // NET_HTTP_HTTP_TRANSACTION_UNITTEST_H_