Clang format slam.

net/url_request/url_request_http_job_unittest.cc

 // Copyright (c) 2013 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/url_request/url_request_http_job.h"
 
 #include <cstddef>
 
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
@@ skipping 14 matching lines @@
 
 namespace {
 
 using ::testing::Return;
 
 // Inherit from URLRequestHttpJob to expose the priority and some
 // other hidden functions.
 class TestURLRequestHttpJob : public URLRequestHttpJob {
  public:
   explicit TestURLRequestHttpJob(URLRequest* request)
-      : URLRequestHttpJob(request, request->context()->network_delegate(),
+      : URLRequestHttpJob(request,
+                          request->context()->network_delegate(),
                           request->context()->http_user_agent_settings()) {}
 
   using URLRequestHttpJob::SetPriority;
   using URLRequestHttpJob::Start;
   using URLRequestHttpJob::Kill;
   using URLRequestHttpJob::priority;
 
  protected:
   virtual ~TestURLRequestHttpJob() {}
 };
@@ skipping 76 matching lines @@
   // Creates a second transaction.
   job->Start();
   ASSERT_TRUE(network_layer_.last_transaction());
   EXPECT_EQ(LOW, network_layer_.last_transaction()->priority());
 }
 
 // This base class just serves to set up some things before the TestURLRequest
 // constructor is called.
 class URLRequestHttpJobWebSocketTestBase : public ::testing::Test {
  protected:
-  URLRequestHttpJobWebSocketTestBase() : socket_data_(NULL, 0, NULL, 0),
-                                         context_(true) {
+  URLRequestHttpJobWebSocketTestBase()
+      : socket_data_(NULL, 0, NULL, 0), context_(true) {
     // A Network Delegate is required for the WebSocketHandshakeStreamBase
     // object to be passed on to the HttpNetworkTransaction.
     context_.set_network_delegate(&network_delegate_);
 
     // Attempting to create real ClientSocketHandles is not going to work out so
     // well. Set up a fake socket factory.
     socket_factory_.AddSocketDataProvider(&socket_data_);
     context_.set_client_socket_factory(&socket_factory_);
     context_.Init();
   }
@@ skipping 27 matching lines @@
  public:
   // GoogleMock does not appear to play nicely with move-only types like
   // scoped_ptr, so this forwarding method acts as a workaround.
   virtual WebSocketHandshakeStreamBase* CreateBasicStream(
       scoped_ptr<ClientSocketHandle> connection,
       bool using_proxy) OVERRIDE {
     // Discard the arguments since we don't need them anyway.
     return CreateBasicStreamMock();
   }
 
-  MOCK_METHOD0(CreateBasicStreamMock,
-               WebSocketHandshakeStreamBase*());
+  MOCK_METHOD0(CreateBasicStreamMock, WebSocketHandshakeStreamBase*());
 
   MOCK_METHOD2(CreateSpdyStream,
                WebSocketHandshakeStreamBase*(const base::WeakPtr<SpdySession>&,
                                              bool));
 };
 
 class FakeWebSocketHandshakeStream : public WebSocketHandshakeStreamBase {
  public:
   FakeWebSocketHandshakeStream() : initialize_stream_was_called_(false) {}
 
@@ skipping 36 matching lines @@
 
   virtual bool CanFindEndOfResponse() const OVERRIDE { return false; }
 
   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 bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const
-      OVERRIDE {
+  virtual bool GetLoadTimingInfo(
+      LoadTimingInfo* load_timing_info) const OVERRIDE {
     return false;
   }
 
   virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {}
 
-  virtual void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info)
-      OVERRIDE {}
+  virtual void GetSSLCertRequestInfo(
+      SSLCertRequestInfo* cert_request_info) OVERRIDE {}
 
   virtual bool IsSpdyHttpStream() const OVERRIDE { return false; }
 
   virtual void Drain(HttpNetworkSession* session) OVERRIDE {}
 
   virtual void SetPriority(RequestPriority priority) OVERRIDE {}
 
   // Fake implementation of WebSocketHandshakeStreamBase method(s)
   virtual scoped_ptr<WebSocketStream> Upgrade() OVERRIDE {
     return scoped_ptr<WebSocketStream>();
@@ skipping 30 matching lines @@
   req_.SetLoadFlags(LOAD_DISABLE_CACHE);
   job->Start();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(URLRequestStatus::IO_PENDING, req_.status().status());
   EXPECT_TRUE(fake_handshake_stream->initialize_stream_was_called());
 }
 
 }  // namespace
 
 }  // namespace net