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

net/websockets/websocket_basic_handshake_stream.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_basic_handshake_stream.h"
 
 #include <algorithm>
 #include <iterator>
 #include <set>
 #include <string>
@@ skipping 216 matching lines @@
                                         WebSocketExtensionParams* params) {
   static const char kClientPrefix[] = "client_";
   static const char kServerPrefix[] = "server_";
   static const char kNoContextTakeover[] = "no_context_takeover";
   static const char kMaxWindowBits[] = "max_window_bits";
   const size_t kPrefixLen = arraysize(kClientPrefix) - 1;
   COMPILE_ASSERT(kPrefixLen == arraysize(kServerPrefix) - 1,
                  the_strings_server_and_client_must_be_the_same_length);
   typedef std::vector<WebSocketExtension::Parameter> ParameterVector;
 
-  DCHECK(extension.name() == "permessage-deflate");
+  DCHECK_EQ("permessage-deflate", extension.name());
   const ParameterVector& parameters = extension.parameters();
   std::set<std::string> seen_names;
   for (ParameterVector::const_iterator it = parameters.begin();
        it != parameters.end(); ++it) {
     const std::string& name = it->name();
     if (seen_names.count(name) != 0) {
       *failure_message =
           "Received duplicate permessage-deflate extension parameter " + name;
       return false;
     }
@@ skipping 42 matching lines @@
                         std::string* extensions,
                         std::string* failure_message,
                         WebSocketExtensionParams* params) {
   void* state = NULL;
   std::string value;
   std::vector<std::string> accepted_extensions;
   // TODO(ricea): If adding support for additional extensions, generalise this
   // code.
   bool seen_permessage_deflate = false;
   while (headers->EnumerateHeader(
-      &state, websockets::kSecWebSocketExtensions, &value)) {
+             &state, websockets::kSecWebSocketExtensions, &value)) {
     WebSocketExtensionParser parser;
     parser.Parse(value);
     if (parser.has_error()) {
       // TODO(yhirano) Set appropriate failure message.
       *failure_message =
           "'Sec-WebSocket-Extensions' header value is "
           "rejected by the parser: " +
           value;
       return false;
     }
     if (parser.extension().name() == "permessage-deflate") {
       if (seen_permessage_deflate) {
         *failure_message = "Received duplicate permessage-deflate response";
         return false;
       }
       seen_permessage_deflate = true;
       if (!ValidatePerMessageDeflateExtension(
-               parser.extension(), failure_message, params))
+              parser.extension(), failure_message, params))
         return false;
     } else {
       *failure_message =
           "Found an unsupported extension '" +
           parser.extension().name() +
           "' in 'Sec-WebSocket-Extensions' header";
       return false;
     }
     accepted_extensions.push_back(value);
   }
@@ skipping 80 matching lines @@
   // HttpStreamParser uses a weak pointer when reading from the
   // socket, so it won't be called back after being destroyed. The
   // HttpStreamParser is owned by HttpBasicState which is owned by this object,
   // so this use of base::Unretained() is safe.
   int rv = parser()->ReadResponseHeaders(
       base::Bind(&WebSocketBasicHandshakeStream::ReadResponseHeadersCallback,
                  base::Unretained(this),
                  callback));
   if (rv == ERR_IO_PENDING)
     return rv;
-  if (rv == OK)
-    return ValidateResponse();
-  OnFinishOpeningHandshake();
-  return rv;
+  return ValidateResponse(rv);
 }
 
 const HttpResponseInfo* WebSocketBasicHandshakeStream::GetResponseInfo() const {
   return parser()->GetResponseInfo();
 }
 
 int WebSocketBasicHandshakeStream::ReadResponseBody(
     IOBuffer* buf,
     int buf_len,
     const CompletionCallback& callback) {
@@ skipping 86 matching lines @@
   handshake_challenge_for_testing_.reset(new std::string(key));
 }
 
 std::string WebSocketBasicHandshakeStream::GetFailureMessage() const {
   return failure_message_;
 }
 
 void WebSocketBasicHandshakeStream::ReadResponseHeadersCallback(
     const CompletionCallback& callback,
     int result) {
-  if (result == OK)
-    result = ValidateResponse();
-  else
-    OnFinishOpeningHandshake();
-  callback.Run(result);
+  callback.Run(ValidateResponse(result));
 }
 
 void WebSocketBasicHandshakeStream::OnFinishOpeningHandshake() {
   DCHECK(connect_delegate_);
   DCHECK(http_response_info_);
   scoped_refptr<HttpResponseHeaders> headers = http_response_info_->headers;
   scoped_ptr<WebSocketHandshakeResponseInfo> response(
       new WebSocketHandshakeResponseInfo(url_,
                                          headers->response_code(),
                                          headers->GetStatusText(),
                                          headers,
                                          http_response_info_->response_time));
   connect_delegate_->OnFinishOpeningHandshake(response.Pass());
 }
 
-int WebSocketBasicHandshakeStream::ValidateResponse() {
+int WebSocketBasicHandshakeStream::ValidateResponse(int rv) {
   DCHECK(http_response_info_);
-  const scoped_refptr<HttpResponseHeaders>& headers =
-      http_response_info_->headers;
+  const HttpResponseHeaders* headers = http_response_info_->headers.get();
+  if (rv == OK) {
+    switch (headers->response_code()) {
+      case HTTP_SWITCHING_PROTOCOLS:
+        OnFinishOpeningHandshake();
+        return ValidateUpgradeResponse(headers);
 
-  switch (headers->response_code()) {
-    case HTTP_SWITCHING_PROTOCOLS:
-      OnFinishOpeningHandshake();
-      return ValidateUpgradeResponse(headers);
+        // We need to pass these through for authentication to work.
+      case HTTP_UNAUTHORIZED:
+      case HTTP_PROXY_AUTHENTICATION_REQUIRED:
+        return OK;
 
-    // We need to pass these through for authentication to work.
-    case HTTP_UNAUTHORIZED:
-    case HTTP_PROXY_AUTHENTICATION_REQUIRED:
-      return OK;
-
-    // Other status codes are potentially risky (see the warnings in the
-    // WHATWG WebSocket API spec) and so are dropped by default.
-    default:
-      failure_message_ = base::StringPrintf("Unexpected status code: %d",
-                                            headers->response_code());
-      OnFinishOpeningHandshake();
-      return ERR_INVALID_RESPONSE;
+        // Other status codes are potentially risky (see the warnings in the
+        // WHATWG WebSocket API spec) and so are dropped by default.
+      default:
+        failure_message_ = base::StringPrintf(
+            "Error during WebSocket handshake: Unexpected response code: %d",
+            headers->response_code());
+        OnFinishOpeningHandshake();
+        return ERR_INVALID_RESPONSE;
+    }
+  } else {
+    std::string message(ErrorToString(MapSystemError(rv)));
+    if (headers) {
+      message = base::StringPrintf("Unexpected response code: %d",
+                                   headers->response_code());
+    }
+    failure_message_ = "Error during WebSocket handshake: " + message;
+    OnFinishOpeningHandshake();
+    return rv;
   }
 }
 
 int WebSocketBasicHandshakeStream::ValidateUpgradeResponse(
-    const scoped_refptr<HttpResponseHeaders>& headers) {
+    const HttpResponseHeaders* headers) {
   extension_params_.reset(new WebSocketExtensionParams);
-  if (ValidateUpgrade(headers.get(), &failure_message_) &&
-      ValidateSecWebSocketAccept(headers.get(),
+  if (ValidateUpgrade(headers, &failure_message_) &&
+      ValidateSecWebSocketAccept(headers,
                                  handshake_challenge_response_,
                                  &failure_message_) &&
-      ValidateConnection(headers.get(), &failure_message_) &&
-      ValidateSubProtocol(headers.get(),
+      ValidateConnection(headers, &failure_message_) &&
+      ValidateSubProtocol(headers,
                           requested_sub_protocols_,
                           &sub_protocol_,
                           &failure_message_) &&
-      ValidateExtensions(headers.get(),
+      ValidateExtensions(headers,
                          requested_extensions_,
                          &extensions_,
                          &failure_message_,
                          extension_params_.get())) {
     return OK;
   }
   failure_message_ = "Error during WebSocket handshake: " + failure_message_;
   return ERR_INVALID_RESPONSE;
 }
 
 }  // namespace net