Clang format slam.

net/websockets/websocket_stream_test.cc

 // Copyright 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/websockets/websocket_stream.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 61 matching lines @@
     // This will break in an obvious way if the type created by
     // CreateBasicStream() changes.
     static_cast<WebSocketBasicHandshakeStream*>(stream())
         ->SetWebSocketKeyForTesting("dGhlIHNhbXBsZSBub25jZQ==");
     return stream();
   }
 };
 
 class WebSocketStreamCreateTest : public ::testing::Test {
  public:
-  WebSocketStreamCreateTest(): has_failed_(false) {}
+  WebSocketStreamCreateTest() : has_failed_(false) {}
 
   void CreateAndConnectCustomResponse(
       const std::string& socket_url,
       const std::string& socket_path,
       const std::vector<std::string>& sub_protocols,
       const std::string& origin,
       const std::string& extra_request_headers,
       const std::string& response_body) {
     url_request_context_host_.SetExpectations(
         WebSocketStandardRequest(socket_path, origin, extra_request_headers),
@@ skipping 157 matching lines @@
   static const char kResponse[] =
       "HTTP/1.1 101 Switching Protocols\r\n"
       "Upgrade: websocket\r\n"
       "Connection: Upgrade\r\n"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "foo: bar, baz\r\n"
       "hoge: fuga\r\n"
       "hoge: piyo\r\n"
       "\r\n";
 
-  CreateAndConnectCustomResponse(
-      "ws://localhost/",
-      "/",
-      NoSubProtocols(),
-      "http://localhost",
-      "",
-      kResponse);
+  CreateAndConnectCustomResponse("ws://localhost/",
+                                 "/",
+                                 NoSubProtocols(),
+                                 "http://localhost",
+                                 "",
+                                 kResponse);
   EXPECT_FALSE(request_info_);
   EXPECT_FALSE(response_info_);
   RunUntilIdle();
   EXPECT_TRUE(stream_);
   ASSERT_TRUE(request_info_);
   ASSERT_TRUE(response_info_);
   std::vector<HeaderKeyValuePair> request_headers =
       ToVector(request_info_->headers);
   // We examine the contents of request_info_ and response_info_
   // mainly only in this test case.
@@ skipping 10 matching lines @@
   EXPECT_EQ(HeaderKeyValuePair("Upgrade", "websocket"), request_headers[4]);
   EXPECT_EQ(HeaderKeyValuePair("Origin", "http://localhost"),
             request_headers[5]);
   EXPECT_EQ(HeaderKeyValuePair("Sec-WebSocket-Version", "13"),
             request_headers[6]);
   EXPECT_EQ(HeaderKeyValuePair("User-Agent", ""), request_headers[7]);
   EXPECT_EQ(HeaderKeyValuePair("Accept-Encoding", "gzip,deflate"),
             request_headers[8]);
   EXPECT_EQ(HeaderKeyValuePair("Accept-Language", "en-us,fr"),
             request_headers[9]);
-  EXPECT_EQ("Sec-WebSocket-Key",  request_headers[10].first);
+  EXPECT_EQ("Sec-WebSocket-Key", request_headers[10].first);
   EXPECT_EQ(HeaderKeyValuePair("Sec-WebSocket-Extensions",
                                "permessage-deflate; client_max_window_bits"),
             request_headers[11]);
 
   std::vector<HeaderKeyValuePair> response_headers =
       ToVector(*response_info_->headers);
   ASSERT_EQ(6u, response_headers.size());
   // Sort the headers for ease of verification.
   std::sort(response_headers.begin(), response_headers.end());
 
@@ skipping 61 matching lines @@
 TEST_F(WebSocketStreamCreateTest, UnsolicitedSubProtocol) {
   CreateAndConnectStandard("ws://localhost/testing_path",
                            "/testing_path",
                            NoSubProtocols(),
                            "http://google.com",
                            "",
                            "Sec-WebSocket-Protocol: chatv20.chromium.org\r\n");
   RunUntilIdle();
   EXPECT_FALSE(stream_);
   EXPECT_TRUE(has_failed());
-  EXPECT_EQ("Error during WebSocket handshake: "
-            "Response must not include 'Sec-WebSocket-Protocol' header "
-            "if not present in request: chatv20.chromium.org",
-            failure_message());
+  EXPECT_EQ(
+      "Error during WebSocket handshake: "
+      "Response must not include 'Sec-WebSocket-Protocol' header "
+      "if not present in request: chatv20.chromium.org",
+      failure_message());
 }
 
 // Missing sub-protocol response is rejected.
 TEST_F(WebSocketStreamCreateTest, UnacceptedSubProtocol) {
   std::vector<std::string> sub_protocols;
   sub_protocols.push_back("chat.example.com");
   CreateAndConnectStandard("ws://localhost/testing_path",
                            "/testing_path",
                            sub_protocols,
                            "http://localhost",
                            "Sec-WebSocket-Protocol: chat.example.com\r\n",
                            "");
   RunUntilIdle();
   EXPECT_FALSE(stream_);
   EXPECT_TRUE(has_failed());
-  EXPECT_EQ("Error during WebSocket handshake: "
-            "Sent non-empty 'Sec-WebSocket-Protocol' header "
-            "but no response was received",
-            failure_message());
+  EXPECT_EQ(
+      "Error during WebSocket handshake: "
+      "Sent non-empty 'Sec-WebSocket-Protocol' header "
+      "but no response was received",
+      failure_message());
 }
 
 // Only one sub-protocol can be accepted.
 TEST_F(WebSocketStreamCreateTest, MultipleSubProtocolsInResponse) {
   std::vector<std::string> sub_protocols;
   sub_protocols.push_back("chatv11.chromium.org");
   sub_protocols.push_back("chatv20.chromium.org");
   CreateAndConnectStandard("ws://localhost/testing_path",
                            "/testing_path",
                            sub_protocols,
                            "http://google.com",
                            "Sec-WebSocket-Protocol: chatv11.chromium.org, "
                            "chatv20.chromium.org\r\n",
                            "Sec-WebSocket-Protocol: chatv11.chromium.org, "
                            "chatv20.chromium.org\r\n");
   RunUntilIdle();
   EXPECT_FALSE(stream_);
   EXPECT_TRUE(has_failed());
-  EXPECT_EQ("Error during WebSocket handshake: "
-            "'Sec-WebSocket-Protocol' header must not appear "
-            "more than once in a response",
-            failure_message());
+  EXPECT_EQ(
+      "Error during WebSocket handshake: "
+      "'Sec-WebSocket-Protocol' header must not appear "
+      "more than once in a response",
+      failure_message());
 }
 
 // Unmatched sub-protocol should be rejected.
 TEST_F(WebSocketStreamCreateTest, UnmatchedSubProtocolInResponse) {
   std::vector<std::string> sub_protocols;
   sub_protocols.push_back("chatv11.chromium.org");
   sub_protocols.push_back("chatv20.chromium.org");
   CreateAndConnectStandard("ws://localhost/testing_path",
                            "/testing_path",
                            sub_protocols,
                            "http://google.com",
                            "Sec-WebSocket-Protocol: chatv11.chromium.org, "
                            "chatv20.chromium.org\r\n",
                            "Sec-WebSocket-Protocol: chatv21.chromium.org\r\n");
   RunUntilIdle();
   EXPECT_FALSE(stream_);
   EXPECT_TRUE(has_failed());
-  EXPECT_EQ("Error during WebSocket handshake: "
-            "'Sec-WebSocket-Protocol' header value 'chatv21.chromium.org' "
-            "in response does not match any of sent values",
-            failure_message());
+  EXPECT_EQ(
+      "Error during WebSocket handshake: "
+      "'Sec-WebSocket-Protocol' header value 'chatv21.chromium.org' "
+      "in response does not match any of sent values",
+      failure_message());
 }
 
 // permessage-deflate extension basic success case.
 TEST_F(WebSocketStreamCreateExtensionTest, PerMessageDeflateSuccess) {
   CreateAndConnectWithExtensions("permessage-deflate");
   EXPECT_TRUE(stream_);
   EXPECT_FALSE(has_failed());
 }
 
 // permessage-deflate extensions success with all parameters.
@@ skipping 30 matching lines @@
   ASSERT_EQ(1U, frames.size());
   ASSERT_EQ(5U, frames[0]->header.payload_length);
   EXPECT_EQ("Hello", std::string(frames[0]->data->data(), 5));
 }
 
 // Unknown extension in the response is rejected
 TEST_F(WebSocketStreamCreateExtensionTest, UnknownExtension) {
   CreateAndConnectWithExtensions("x-unknown-extension");
   EXPECT_FALSE(stream_);
   EXPECT_TRUE(has_failed());
-  EXPECT_EQ("Error during WebSocket handshake: "
-            "Found an unsupported extension 'x-unknown-extension' "
-            "in 'Sec-WebSocket-Extensions' header",
-            failure_message());
+  EXPECT_EQ(
+      "Error during WebSocket handshake: "
+      "Found an unsupported extension 'x-unknown-extension' "
+      "in 'Sec-WebSocket-Extensions' header",
+      failure_message());
 }
 
 // Malformed extensions are rejected (this file does not cover all possible
 // parse failures, as the parser is covered thoroughly by its own unit tests).
 TEST_F(WebSocketStreamCreateExtensionTest, MalformedExtension) {
   CreateAndConnectWithExtensions(";");
   EXPECT_FALSE(stream_);
   EXPECT_TRUE(has_failed());
   EXPECT_EQ(
       "Error during WebSocket handshake: 'Sec-WebSocket-Extensions' header "
@@ skipping 144 matching lines @@
   CreateAndConnectStandard(
       "ws://localhost/",
       "/",
       NoSubProtocols(),
       "http://localhost",
       "",
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n");
   RunUntilIdle();
   EXPECT_FALSE(stream_);
   EXPECT_TRUE(has_failed());
-  EXPECT_EQ("Error during WebSocket handshake: "
-            "'Sec-WebSocket-Accept' header must not appear "
-            "more than once in a response",
-            failure_message());
+  EXPECT_EQ(
+      "Error during WebSocket handshake: "
+      "'Sec-WebSocket-Accept' header must not appear "
+      "more than once in a response",
+      failure_message());
 }
 
 // Response code 200 must be rejected.
 TEST_F(WebSocketStreamCreateTest, InvalidStatusCode) {
   static const char kInvalidStatusCodeResponse[] =
       "HTTP/1.1 200 OK\r\n"
       "Upgrade: websocket\r\n"
       "Connection: Upgrade\r\n"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "\r\n";
@@ skipping 70 matching lines @@
                                  "",
                                  kMissingUpgradeResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error during WebSocket handshake: 'Upgrade' header is missing",
             failure_message());
 }
 
 // There must only be one upgrade header.
 TEST_F(WebSocketStreamCreateTest, DoubleUpgradeHeader) {
-  CreateAndConnectStandard(
-      "ws://localhost/",
-      "/",
-      NoSubProtocols(),
-      "http://localhost",
-      "", "Upgrade: HTTP/2.0\r\n");
+  CreateAndConnectStandard("ws://localhost/",
+                           "/",
+                           NoSubProtocols(),
+                           "http://localhost",
+                           "",
+                           "Upgrade: HTTP/2.0\r\n");
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
-  EXPECT_EQ("Error during WebSocket handshake: "
-            "'Upgrade' header must not appear more than once in a response",
-            failure_message());
+  EXPECT_EQ(
+      "Error during WebSocket handshake: "
+      "'Upgrade' header must not appear more than once in a response",
+      failure_message());
 }
 
 // There must only be one correct upgrade header.
 TEST_F(WebSocketStreamCreateTest, IncorrectUpgradeHeader) {
   static const char kMissingUpgradeResponse[] =
       "HTTP/1.1 101 Switching Protocols\r\n"
       "Connection: Upgrade\r\n"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "Upgrade: hogefuga\r\n"
       "\r\n";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
                                  "http://localhost",
                                  "",
                                  kMissingUpgradeResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
-  EXPECT_EQ("Error during WebSocket handshake: "
-            "'Upgrade' header value is not 'WebSocket': hogefuga",
-            failure_message());
+  EXPECT_EQ(
+      "Error during WebSocket handshake: "
+      "'Upgrade' header value is not 'WebSocket': hogefuga",
+      failure_message());
 }
 
 // Connection header must be present.
 TEST_F(WebSocketStreamCreateTest, MissingConnectionHeader) {
   static const char kMissingConnectionResponse[] =
       "HTTP/1.1 101 Switching Protocols\r\n"
       "Upgrade: websocket\r\n"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "\r\n";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
                                  "http://localhost",
                                  "",
                                  kMissingConnectionResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
-  EXPECT_EQ("Error during WebSocket handshake: "
-            "'Connection' header is missing",
-            failure_message());
+  EXPECT_EQ(
+      "Error during WebSocket handshake: "
+      "'Connection' header is missing",
+      failure_message());
 }
 
 // Connection header must contain "Upgrade".
 TEST_F(WebSocketStreamCreateTest, IncorrectConnectionHeader) {
   static const char kMissingConnectionResponse[] =
       "HTTP/1.1 101 Switching Protocols\r\n"
       "Upgrade: websocket\r\n"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "Connection: hogefuga\r\n"
       "\r\n";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
                                  "http://localhost",
                                  "",
                                  kMissingConnectionResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
-  EXPECT_EQ("Error during WebSocket handshake: "
-            "'Connection' header value must contain 'Upgrade'",
-            failure_message());
+  EXPECT_EQ(
+      "Error during WebSocket handshake: "
+      "'Connection' header value must contain 'Upgrade'",
+      failure_message());
 }
 
 // Connection header is permitted to contain other tokens.
 TEST_F(WebSocketStreamCreateTest, AdditionalTokenInConnectionHeader) {
   static const char kAdditionalConnectionTokenResponse[] =
       "HTTP/1.1 101 Switching Protocols\r\n"
       "Upgrade: websocket\r\n"
       "Connection: Upgrade, Keep-Alive\r\n"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "\r\n";
@@ skipping 16 matching lines @@
       "Connection: Upgrade\r\n"
       "\r\n";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
                                  "http://localhost",
                                  "",
                                  kMissingAcceptResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
-  EXPECT_EQ("Error during WebSocket handshake: "
-            "'Sec-WebSocket-Accept' header is missing",
-            failure_message());
+  EXPECT_EQ(
+      "Error during WebSocket handshake: "
+      "'Sec-WebSocket-Accept' header is missing",
+      failure_message());
 }
 
 // Sec-WebSocket-Accept header must match the key that was sent.
 TEST_F(WebSocketStreamCreateTest, WrongSecWebSocketAccept) {
   static const char kIncorrectAcceptResponse[] =
       "HTTP/1.1 101 Switching Protocols\r\n"
       "Upgrade: websocket\r\n"
       "Connection: Upgrade\r\n"
       "Sec-WebSocket-Accept: x/byyPZ2tOFvJCGkkugcKvqhhPk=\r\n"
       "\r\n";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
                                  "http://localhost",
                                  "",
                                  kIncorrectAcceptResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
-  EXPECT_EQ("Error during WebSocket handshake: "
-            "Incorrect 'Sec-WebSocket-Accept' header value",
-            failure_message());
+  EXPECT_EQ(
+      "Error during WebSocket handshake: "
+      "Incorrect 'Sec-WebSocket-Accept' header value",
+      failure_message());
 }
 
 // Cancellation works.
 TEST_F(WebSocketStreamCreateTest, Cancellation) {
   CreateAndConnectStandard(
       "ws://localhost/", "/", NoSubProtocols(), "http://localhost", "", "");
   stream_request_.reset();
   RunUntilIdle();
   EXPECT_FALSE(has_failed());
   EXPECT_FALSE(stream_);
   EXPECT_FALSE(request_info_);
   EXPECT_FALSE(response_info_);
 }
 
 // Connect failure must look just like negotiation failure.
 TEST_F(WebSocketStreamCreateTest, ConnectionFailure) {
   scoped_ptr<DeterministicSocketData> socket_data(
       new DeterministicSocketData(NULL, 0, NULL, 0));
   socket_data->set_connect_data(
       MockConnect(SYNCHRONOUS, ERR_CONNECTION_REFUSED));
-  CreateAndConnectRawExpectations("ws://localhost/", NoSubProtocols(),
-                                  "http://localhost", socket_data.Pass());
+  CreateAndConnectRawExpectations("ws://localhost/",
+                                  NoSubProtocols(),
+                                  "http://localhost",
+                                  socket_data.Pass());
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error in connection establishment: net::ERR_CONNECTION_REFUSED",
             failure_message());
   EXPECT_FALSE(request_info_);
   EXPECT_FALSE(response_info_);
 }
 
 // Connect timeout must look just like any other failure.
 TEST_F(WebSocketStreamCreateTest, ConnectionTimeout) {
   scoped_ptr<DeterministicSocketData> socket_data(
       new DeterministicSocketData(NULL, 0, NULL, 0));
-  socket_data->set_connect_data(
-      MockConnect(ASYNC, ERR_CONNECTION_TIMED_OUT));
-  CreateAndConnectRawExpectations("ws://localhost/", NoSubProtocols(),
-                                  "http://localhost", socket_data.Pass());
+  socket_data->set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_TIMED_OUT));
+  CreateAndConnectRawExpectations("ws://localhost/",
+                                  NoSubProtocols(),
+                                  "http://localhost",
+                                  socket_data.Pass());
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
   EXPECT_EQ("Error in connection establishment: net::ERR_CONNECTION_TIMED_OUT",
             failure_message());
 }
 
 // Cancellation during connect works.
 TEST_F(WebSocketStreamCreateTest, CancellationDuringConnect) {
   scoped_ptr<DeterministicSocketData> socket_data(
       new DeterministicSocketData(NULL, 0, NULL, 0));
@@ skipping 29 matching lines @@
   EXPECT_FALSE(stream_);
   EXPECT_TRUE(request_info_);
   EXPECT_FALSE(response_info_);
 }
 
 // Cancellation during read of the response headers works.
 TEST_F(WebSocketStreamCreateTest, CancellationDuringRead) {
   std::string request = WebSocketStandardRequest("/", "http://localhost", "");
   MockWrite writes[] = {MockWrite(ASYNC, 0, request.c_str())};
   MockRead reads[] = {
-    MockRead(ASYNC, 1, "HTTP/1.1 101 Switching Protocols\r\nUpgr"),
+      MockRead(ASYNC, 1, "HTTP/1.1 101 Switching Protocols\r\nUpgr"),
   };
   DeterministicSocketData* socket_data(new DeterministicSocketData(
       reads, arraysize(reads), writes, arraysize(writes)));
   socket_data->set_connect_data(MockConnect(SYNCHRONOUS, OK));
   socket_data->SetStop(1);
   CreateAndConnectRawExpectations("ws://localhost/",
                                   NoSubProtocols(),
                                   "http://localhost",
                                   make_scoped_ptr(socket_data));
   socket_data->Run();
   stream_request_.reset();
   RunUntilIdle();
   EXPECT_FALSE(has_failed());
   EXPECT_FALSE(stream_);
   EXPECT_TRUE(request_info_);
   EXPECT_FALSE(response_info_);
 }
 
 // Over-size response headers (> 256KB) should not cause a crash.  This is a
 // regression test for crbug.com/339456. It is based on the layout test
 // "cookie-flood.html".
 TEST_F(WebSocketStreamCreateTest, VeryLargeResponseHeaders) {
   std::string set_cookie_headers;
   set_cookie_headers.reserve(45 * 10000);
   for (int i = 0; i < 10000; ++i) {
     set_cookie_headers +=
         base::StringPrintf("Set-Cookie: WK-websocket-test-flood-%d=1\r\n", i);
   }
-  CreateAndConnectStandard("ws://localhost/", "/", NoSubProtocols(),
-                           "http://localhost", "", set_cookie_headers);
+  CreateAndConnectStandard("ws://localhost/",
+                           "/",
+                           NoSubProtocols(),
+                           "http://localhost",
+                           "",
+                           set_cookie_headers);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
   EXPECT_FALSE(response_info_);
 }
 
 // If the remote host closes the connection without sending headers, we should
 // log the console message "Connection closed before receiving a handshake
 // response".
 TEST_F(WebSocketStreamCreateTest, NoResponse) {
   std::string request = WebSocketStandardRequest("/", "http://localhost", "");
@@ skipping 89 matching lines @@
   if (original) {
     samples->Subtract(*original);  // Cancel the original values.
   }
   EXPECT_EQ(0, samples->GetCount(INCOMPLETE));
   EXPECT_EQ(0, samples->GetCount(CONNECTED));
   EXPECT_EQ(1, samples->GetCount(FAILED));
 }
 
 }  // namespace
 }  // namespace net