Map WebSocket URL schemes to HTTP URL schemes for auth purposes.

net/websockets/websocket_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_stream.h"
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_request_headers.h"
+#include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/websockets/websocket_errors.h"
 #include "net/websockets/websocket_event_interface.h"
 #include "net/websockets/websocket_handshake_constants.h"
 #include "net/websockets/websocket_handshake_stream_base.h"
 #include "net/websockets/websocket_handshake_stream_create_helper.h"
 #include "net/websockets/websocket_test_util.h"
 #include "url/gurl.h"
@@ skipping 103 matching lines @@
         case URLRequestStatus::CANCELED:
           failure_message_ = "WebSocket opening handshake was canceled";
           break;
         case URLRequestStatus::FAILED:
           failure_message_ =
               std::string("Error in connection establishment: ") +
               ErrorToString(url_request_.status().error());
           break;
       }
     }
-    connect_delegate_->OnFailure(failure_message_);
+    ReportFailureWithMessage(failure_message_);
+  }
+
+  void ReportFailureWithMessage(const std::string& failure_message) {
+    connect_delegate_->OnFailure(failure_message);
+  }
+
+  void OnFinishOpeningHandshake() {
+    WebSocketDispatchOnFinishOpeningHandshake(connect_delegate(),
+                                              url_request_.url(),
+                                              url_request_.response_headers(),
+                                              url_request_.response_time());
   }
 
   WebSocketStream::ConnectDelegate* connect_delegate() const {
     return connect_delegate_.get();
   }
 
  private:
   // |delegate_| needs to be declared before |url_request_| so that it gets
   // initialised first.
   scoped_ptr<Delegate> delegate_;
@@ skipping 44 matching lines @@
   }
   const int response_code = request->GetResponseCode();
   DVLOG(3) << "OnResponseStarted (response code " << response_code << ")";
   switch (response_code) {
     case HTTP_SWITCHING_PROTOCOLS:
       result_ = CONNECTED;
       owner_->PerformUpgrade();
       return;
 
     case HTTP_UNAUTHORIZED:
+      result_ = FAILED;
+      owner_->OnFinishOpeningHandshake();
+      owner_->ReportFailureWithMessage(
+          "HTTP Authentication failed; no valid credentials available");
+      return;
+
     case HTTP_PROXY_AUTHENTICATION_REQUIRED:
+      result_ = FAILED;
+      owner_->OnFinishOpeningHandshake();
+      owner_->ReportFailureWithMessage("Proxy authentication failed");
       return;
 
     default:
       result_ = FAILED;
       owner_->ReportFailure();
   }
 }
 
 void Delegate::OnAuthRequired(URLRequest* request,
                               AuthChallengeInfo* auth_info) {
@@ skipping 66 matching lines @@
   scoped_ptr<StreamRequestImpl> request(
       new StreamRequestImpl(socket_url,
                             url_request_context,
                             origin,
                             connect_delegate.Pass(),
                             create_helper.Pass()));
   request->Start();
   return request.PassAs<WebSocketStreamRequest>();
 }
 
+void WebSocketDispatchOnFinishOpeningHandshake(
+    WebSocketStream::ConnectDelegate* connect_delegate,
+    const GURL& url,
+    const scoped_refptr<HttpResponseHeaders>& headers,
+    base::Time response_time) {
+  DCHECK(connect_delegate);
+  if (headers) {
+    connect_delegate->OnFinishOpeningHandshake(make_scoped_ptr(
+        new WebSocketHandshakeResponseInfo(url,
+                                           headers->response_code(),
+                                           headers->GetStatusText(),
+                                           headers,
+                                           response_time)));
+  }
+}
+
 }  // namespace net