[WebSocket] Add Cache-Control to the request header.

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 233 matching lines @@
   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.
   EXPECT_EQ(GURL("ws://localhost/"), request_info_->url);
   EXPECT_EQ(GURL("ws://localhost/"), response_info_->url);
   EXPECT_EQ(101, response_info_->status_code);
   EXPECT_EQ("Switching Protocols", response_info_->status_text);
-  EXPECT_EQ(10u, request_headers.size());
+  ASSERT_EQ(12u, request_headers.size());
   EXPECT_EQ(HeaderKeyValuePair("Host", "localhost"), request_headers[0]);
   EXPECT_EQ(HeaderKeyValuePair("Connection", "Upgrade"), request_headers[1]);
-  EXPECT_EQ(HeaderKeyValuePair("Upgrade", "websocket"), request_headers[2]);
+  EXPECT_EQ(HeaderKeyValuePair("Pragma", "no-cache"), request_headers[2]);
+  EXPECT_EQ(HeaderKeyValuePair("Cache-Control", "no-cache"),
+            request_headers[3]);
+  EXPECT_EQ(HeaderKeyValuePair("Upgrade", "websocket"), request_headers[4]);
   EXPECT_EQ(HeaderKeyValuePair("Origin", "http://localhost/"),
-            request_headers[3]);
+            request_headers[5]);
   EXPECT_EQ(HeaderKeyValuePair("Sec-WebSocket-Version", "13"),
-            request_headers[4]);
-  EXPECT_EQ(HeaderKeyValuePair("User-Agent", ""), request_headers[5]);
+            request_headers[6]);
+  EXPECT_EQ(HeaderKeyValuePair("User-Agent", ""), request_headers[7]);
   EXPECT_EQ(HeaderKeyValuePair("Accept-Encoding", "gzip,deflate"),
-            request_headers[6]);
+            request_headers[8]);
   EXPECT_EQ(HeaderKeyValuePair("Accept-Language", "en-us,fr"),
-            request_headers[7]);
-  EXPECT_EQ("Sec-WebSocket-Key",  request_headers[8].first);
+            request_headers[9]);
+  EXPECT_EQ("Sec-WebSocket-Key",  request_headers[10].first);
   EXPECT_EQ(HeaderKeyValuePair("Sec-WebSocket-Extensions",
                                "permessage-deflate; client_max_window_bits"),
-            request_headers[9]);
+            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());
 
   EXPECT_EQ(HeaderKeyValuePair("Connection", "Upgrade"), response_headers[0]);
   EXPECT_EQ("Sec-WebSocket-Accept", response_headers[1].first);
   EXPECT_EQ(HeaderKeyValuePair("Upgrade", "websocket"), response_headers[2]);
@@ skipping 363 matching lines @@
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "\r\n";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
                                  "http://localhost/",
                                  "",
                                  kInvalidStatusCodeResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
-  EXPECT_EQ("Unexpected status code: 200", failure_message());
+  EXPECT_EQ("Error during WebSocket handshake: Unexpected response code: 200",
+            failure_message());
 }
 
 // Redirects are not followed (according to the WHATWG WebSocket API, which
 // overrides RFC6455 for browser applications).
 TEST_F(WebSocketStreamCreateTest, RedirectsRejected) {
   static const char kRedirectResponse[] =
       "HTTP/1.1 302 Moved Temporarily\r\n"
       "Content-Type: text/html\r\n"
       "Content-Length: 34\r\n"
       "Connection: keep-alive\r\n"
       "Location: ws://localhost/other\r\n"
       "\r\n"
       "<title>Moved</title><h1>Moved</h1>";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
                                  "http://localhost/",
                                  "",
                                  kRedirectResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
-  EXPECT_EQ("Unexpected status code: 302", failure_message());
+  EXPECT_EQ("Error during WebSocket handshake: Unexpected response code: 302",
+            failure_message());
 }
 
 // Malformed responses should be rejected. HttpStreamParser will accept just
 // about any garbage in the middle of the headers. To make it give up, the junk
 // has to be at the start of the response. Even then, it just gets treated as an
 // HTTP/0.9 response.
 TEST_F(WebSocketStreamCreateTest, MalformedResponse) {
   static const char kMalformedResponse[] =
       "220 mx.google.com ESMTP\r\n"
       "HTTP/1.1 101 OK\r\n"
       "Upgrade: websocket\r\n"
       "Connection: Upgrade\r\n"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "\r\n";
   CreateAndConnectCustomResponse("ws://localhost/",
                                  "/",
                                  NoSubProtocols(),
                                  "http://localhost/",
                                  "",
                                  kMalformedResponse);
   RunUntilIdle();
   EXPECT_TRUE(has_failed());
-  EXPECT_EQ("Unexpected status code: 200", failure_message());
+  EXPECT_EQ("Error during WebSocket handshake: Unexpected response code: 200",
+            failure_message());
 }
 
 // Upgrade header must be present.
 TEST_F(WebSocketStreamCreateTest, MissingUpgradeHeader) {
   static const char kMissingUpgradeResponse[] =
       "HTTP/1.1 101 Switching Protocols\r\n"
       "Connection: Upgrade\r\n"
       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
       "\r\n";
   CreateAndConnectCustomResponse("ws://localhost/",
@@ skipping 244 matching lines @@
   stream_request_.reset();
   RunUntilIdle();
   EXPECT_FALSE(has_failed());
   EXPECT_FALSE(stream_);
   EXPECT_TRUE(request_info_);
   EXPECT_FALSE(response_info_);
 }
 
 }  // namespace
 }  // namespace net