Clang format slam.

net/http/http_response_body_drainer_unittest.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/http/http_response_body_drainer.h"
 
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/http_stream.h"
 #include "net/proxy/proxy_service.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 const int kMagicChunkSize = 1024;
-COMPILE_ASSERT(
-    (HttpResponseBodyDrainer::kDrainBodyBufferSize % kMagicChunkSize) == 0,
-    chunk_size_needs_to_divide_evenly_into_buffer_size);
+COMPILE_ASSERT((HttpResponseBodyDrainer::kDrainBodyBufferSize %
+                kMagicChunkSize) == 0,
+               chunk_size_needs_to_divide_evenly_into_buffer_size);
 
 class CloseResultWaiter {
  public:
   CloseResultWaiter()
-      : result_(false),
-        have_result_(false),
-        waiting_for_result_(false) {}
+      : result_(false), have_result_(false), waiting_for_result_(false) {}
 
   int WaitForResult() {
     CHECK(!waiting_for_result_);
     while (!have_result_) {
       waiting_for_result_ = true;
       base::MessageLoop::current()->Run();
       waiting_for_result_ = false;
     }
     return result_;
   }
@@ skipping 52 matching lines @@
   virtual bool CanFindEndOfResponse() const OVERRIDE { return true; }
   virtual bool IsConnectionReused() const OVERRIDE { return false; }
   virtual void SetConnectionReused() OVERRIDE {}
   virtual bool IsConnectionReusable() const OVERRIDE { return false; }
   virtual int64 GetTotalReceivedBytes() const OVERRIDE { return 0; }
   virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {}
   virtual void GetSSLCertRequestInfo(
       SSLCertRequestInfo* cert_request_info) OVERRIDE {}
 
   // Mocked API
-  virtual int ReadResponseBody(IOBuffer* buf, int buf_len,
+  virtual int ReadResponseBody(IOBuffer* buf,
+                               int buf_len,
                                const CompletionCallback& callback) OVERRIDE;
   virtual void Close(bool not_reusable) OVERRIDE {
     CHECK(!closed_);
     closed_ = true;
     result_waiter_->set_result(not_reusable);
   }
 
-  virtual HttpStream* RenewStreamForAuth() OVERRIDE {
-    return NULL;
-  }
+  virtual HttpStream* RenewStreamForAuth() OVERRIDE { return NULL; }
 
   virtual bool IsResponseBodyComplete() const OVERRIDE { return is_complete_; }
 
   virtual bool IsSpdyHttpStream() const OVERRIDE { return false; }
 
   virtual bool GetLoadTimingInfo(
-      LoadTimingInfo* load_timing_info) const OVERRIDE { return false; }
+      LoadTimingInfo* load_timing_info) const OVERRIDE {
+    return false;
+  }
 
   virtual void Drain(HttpNetworkSession*) OVERRIDE {}
 
   virtual void SetPriority(RequestPriority priority) OVERRIDE {}
 
   // Methods to tweak/observer mock behavior:
   void set_stall_reads_forever() { stall_reads_forever_ = true; }
 
   void set_num_chunks(int num_chunks) { num_chunks_ = num_chunks; }
 
@@ skipping 87 matching lines @@
     params.ssl_config_service = ssl_config_service_.get();
     params.http_server_properties = http_server_properties_->GetWeakPtr();
     return new HttpNetworkSession(params);
   }
 
   scoped_ptr<ProxyService> proxy_service_;
   scoped_refptr<SSLConfigService> ssl_config_service_;
   scoped_ptr<HttpServerPropertiesImpl> http_server_properties_;
   const scoped_refptr<HttpNetworkSession> session_;
   CloseResultWaiter result_waiter_;
-  MockHttpStream* const mock_stream_;  // Owned by |drainer_|.
+  MockHttpStream* const mock_stream_;       // Owned by |drainer_|.
   HttpResponseBodyDrainer* const drainer_;  // Deletes itself.
 };
 
 TEST_F(HttpResponseBodyDrainerTest, DrainBodySyncSingleOK) {
   mock_stream_->set_num_chunks(1);
   mock_stream_->set_sync();
   drainer_->Start(session_.get());
   EXPECT_FALSE(result_waiter_.WaitForResult());
 }
 
@@ skipping 22 matching lines @@
 
 TEST_F(HttpResponseBodyDrainerTest, DrainBodySyncEmptyChunk) {
   mock_stream_->set_num_chunks(4);
   mock_stream_->set_sync();
   mock_stream_->set_is_last_chunk_zero_size();
   drainer_->Start(session_.get());
   EXPECT_FALSE(result_waiter_.WaitForResult());
 }
 
 TEST_F(HttpResponseBodyDrainerTest, DrainBodySizeEqualsDrainBuffer) {
-  mock_stream_->set_num_chunks(
-      HttpResponseBodyDrainer::kDrainBodyBufferSize / kMagicChunkSize);
+  mock_stream_->set_num_chunks(HttpResponseBodyDrainer::kDrainBodyBufferSize /
+                               kMagicChunkSize);
   drainer_->Start(session_.get());
   EXPECT_FALSE(result_waiter_.WaitForResult());
 }
 
 TEST_F(HttpResponseBodyDrainerTest, DrainBodyTimeOut) {
   mock_stream_->set_num_chunks(2);
   mock_stream_->set_stall_reads_forever();
   drainer_->Start(session_.get());
   EXPECT_TRUE(result_waiter_.WaitForResult());
 }
@@ skipping 27 matching lines @@
 
 TEST_F(HttpResponseBodyDrainerTest, StartWithNothingToDo) {
   mock_stream_->set_num_chunks(0);
   drainer_->StartWithSize(session_.get(), 0);
   EXPECT_FALSE(result_waiter_.WaitForResult());
 }
 
 }  // namespace
 
 }  // namespace net