[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 271 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)
+  if (result == OK) {
     result = ValidateResponse();
-  else
+  } else {
+    std::string message = "Unknown failure";
+    const scoped_refptr<HttpResponseHeaders>& headers =
+        http_response_info_->headers;
+    if (headers) {
+      message = base::StringPrintf("Unexpected response code: %d",
+                                   headers->response_code());
+    }
+    failure_message_ = "Error during WebSocket handshake: " + message;
     OnFinishOpeningHandshake();

[Adam Rice, 2014/02/03 08:43:52]

OnFinishOpeningHandshake() is also called at line 421, so similar logic will be
needed there. I think when HttpStreamParser returns a |result| other than OK, it
is probably more useful to log the net error code than to log the HTTP response
code.

[yhirano, 2014/02/03 09:32:52]

Done in ValidateResponse.

HttpStreamParser returns an error when it detects 404.
I think "Unexpected status code: 404" is more useful then "net::ERR_FAILED" in
such case.

[Adam Rice, 2014/02/04 03:52:46]

In my tests, HttpStreamParser returns a positive value on 404. I have filed a
bug http://crbug.com/340533 to try to get more information. In the meantime, I
think we will have to change if (result == OK) to if (result >= 0). Do you want
to do that in this CL?

[yhirano, 2014/02/04 04:15:50]

Done.

+  }
   callback.Run(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(),
@@ skipping 14 matching lines @@
       return ValidateUpgradeResponse(headers);
 
     // 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",
+      failure_message_ = base::StringPrintf("Unexpected response code: %d",
                                             headers->response_code());
       OnFinishOpeningHandshake();
       return ERR_INVALID_RESPONSE;
   }
 }
 
 int WebSocketBasicHandshakeStream::ValidateUpgradeResponse(
     const scoped_refptr<HttpResponseHeaders>& headers) {
   extension_params_.reset(new WebSocketExtensionParams);
   if (ValidateUpgrade(headers.get(), &failure_message_) &&
@@ skipping 10 matching lines @@
                          &extensions_,
                          &failure_message_,
                          extension_params_.get())) {
     return OK;
   }
   failure_message_ = "Error during WebSocket handshake: " + failure_message_;
   return ERR_INVALID_RESPONSE;
 }
 
 }  // namespace net