Clang format slam.

net/http/http_pipelined_host_forced_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_pipelined_host_forced.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "net/http/http_pipelined_host_test_util.h"
 #include "net/proxy/proxy_info.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/ssl/ssl_config_service.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::NiceMock;
 using testing::Ref;
 using testing::Return;
 
 namespace net {
 
 namespace {
 
-HttpPipelinedStream* kDummyStream =
-    reinterpret_cast<HttpPipelinedStream*>(24);
+HttpPipelinedStream* kDummyStream = reinterpret_cast<HttpPipelinedStream*>(24);
 
 class HttpPipelinedHostForcedTest : public testing::Test {
  public:
   HttpPipelinedHostForcedTest()
       : key_(HostPortPair("host", 123)),
         factory_(new MockPipelineFactory),  // Owned by |host_|.
-        host_(new HttpPipelinedHostForced(&delegate_, key_, factory_)) {
-  }
+        host_(new HttpPipelinedHostForced(&delegate_, key_, factory_)) {}
 
   MockPipeline* AddTestPipeline() {
     MockPipeline* pipeline = new MockPipeline(0, true, true);
-    EXPECT_CALL(*factory_, CreateNewPipeline(&connection_, host_.get(),
-                                             MatchesOrigin(key_.origin()),
-                                             Ref(ssl_config_), Ref(proxy_info_),
-                                             Ref(net_log_), true,
-                                             kProtoSPDY3))
+    EXPECT_CALL(*factory_,
+                CreateNewPipeline(&connection_,
+                                  host_.get(),
+                                  MatchesOrigin(key_.origin()),
+                                  Ref(ssl_config_),
+                                  Ref(proxy_info_),
+                                  Ref(net_log_),
+                                  true,
+                                  kProtoSPDY3))
         .Times(1)
         .WillOnce(Return(pipeline));
-    EXPECT_CALL(*pipeline, CreateNewStream())
-        .Times(1)
-        .WillOnce(Return(kDummyStream));
-    EXPECT_EQ(kDummyStream, host_->CreateStreamOnNewPipeline(
-        &connection_, ssl_config_, proxy_info_, net_log_, true,
-        kProtoSPDY3));
+    EXPECT_CALL(*pipeline, CreateNewStream()).Times(1).WillOnce(
+        Return(kDummyStream));
+    EXPECT_EQ(kDummyStream,
+              host_->CreateStreamOnNewPipeline(&connection_,
+                                               ssl_config_,
+                                               proxy_info_,
+                                               net_log_,
+                                               true,
+                                               kProtoSPDY3));
     return pipeline;
   }
 
   ClientSocketHandle connection_;
   NiceMock<MockHostDelegate> delegate_;
   HttpPipelinedHost::Key key_;
   MockPipelineFactory* factory_;
   scoped_ptr<HttpPipelinedHostForced> host_;
 
   SSLConfig ssl_config_;
   ProxyInfo proxy_info_;
   BoundNetLog net_log_;
 };
 
 TEST_F(HttpPipelinedHostForcedTest, Delegate) {
   EXPECT_TRUE(key_.origin().Equals(host_->GetKey().origin()));
 }
 
 TEST_F(HttpPipelinedHostForcedTest, SingleUser) {
   EXPECT_FALSE(host_->IsExistingPipelineAvailable());
 
   MockPipeline* pipeline = AddTestPipeline();
   EXPECT_TRUE(host_->IsExistingPipelineAvailable());
 
-  EXPECT_CALL(delegate_, OnHostHasAdditionalCapacity(host_.get()))
-      .Times(1);
-  EXPECT_CALL(delegate_, OnHostIdle(host_.get()))
-      .Times(1);
+  EXPECT_CALL(delegate_, OnHostHasAdditionalCapacity(host_.get())).Times(1);
+  EXPECT_CALL(delegate_, OnHostIdle(host_.get())).Times(1);
   host_->OnPipelineHasCapacity(pipeline);
 }
 
 TEST_F(HttpPipelinedHostForcedTest, ReuseExisting) {
   EXPECT_EQ(NULL, host_->CreateStreamOnExistingPipeline());
 
   MockPipeline* pipeline = AddTestPipeline();
-  EXPECT_CALL(*pipeline, CreateNewStream())
-      .Times(1)
-      .WillOnce(Return(kDummyStream));
+  EXPECT_CALL(*pipeline, CreateNewStream()).Times(1).WillOnce(
+      Return(kDummyStream));
   EXPECT_EQ(kDummyStream, host_->CreateStreamOnExistingPipeline());
 
   pipeline->SetState(1, true, true);
-  EXPECT_CALL(delegate_, OnHostHasAdditionalCapacity(host_.get()))
-      .Times(1);
-  EXPECT_CALL(delegate_, OnHostIdle(host_.get()))
-      .Times(0);
+  EXPECT_CALL(delegate_, OnHostHasAdditionalCapacity(host_.get())).Times(1);
+  EXPECT_CALL(delegate_, OnHostIdle(host_.get())).Times(0);
   host_->OnPipelineHasCapacity(pipeline);
 
   pipeline->SetState(0, true, true);
-  EXPECT_CALL(delegate_, OnHostHasAdditionalCapacity(host_.get()))
-      .Times(1);
-  EXPECT_CALL(delegate_, OnHostIdle(host_.get()))
-      .Times(1);
+  EXPECT_CALL(delegate_, OnHostHasAdditionalCapacity(host_.get())).Times(1);
+  EXPECT_CALL(delegate_, OnHostIdle(host_.get())).Times(1);
   host_->OnPipelineHasCapacity(pipeline);
 }
 
 }  // anonymous namespace
 
 }  // namespace net