Try https proxy for websocket connection.

net/socket_stream/socket_stream.cc

 // Copyright (c) 2009 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.
 //
 // TODO(ukai): code is similar with http_network_transaction.cc.  We should
 //   think about ways to share code, if possible.
 
 #include "net/socket_stream/socket_stream.h"
 
 #include <string>
@@ skipping 29 matching lines @@
 }
 
 SocketStream::SocketStream(const GURL& url, Delegate* delegate)
     : load_log_(new net::LoadLog(kMaxNumLoadLogEntries)),
       url_(url),
       delegate_(delegate),
       max_pending_send_allowed_(kMaxPendingSendAllowed),
       next_state_(STATE_NONE),
       factory_(ClientSocketFactory::GetDefaultFactory()),
       proxy_mode_(kDirectConnection),
+      proxy_url_(url),
       pac_request_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_(this, &SocketStream::OnIOCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           read_callback_(this, &SocketStream::OnReadCompleted)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           write_callback_(this, &SocketStream::OnWriteCompleted)),
       read_buf_(NULL),
       write_buf_(NULL),
       current_write_buf_(NULL),
@@ skipping 347 matching lines @@
       LoadLog::EndEvent(load_log_, LoadLog::TYPE_SOCKET_STREAM_CONNECT);
     }
   } while (result != ERR_IO_PENDING);
 }
 
 int SocketStream::DoResolveProxy() {
   DCHECK(!pac_request_);
   next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
 
   return proxy_service()->ResolveProxy(
-      url_, &proxy_info_, &io_callback_, &pac_request_, load_log_);
+      proxy_url_, &proxy_info_, &io_callback_, &pac_request_, load_log_);
 }
 
 int SocketStream::DoResolveProxyComplete(int result) {
   next_state_ = STATE_RESOLVE_HOST;
 
   pac_request_ = NULL;
   if (result != OK) {
     LOG(ERROR) << "Failed to resolve proxy: " << result;
     if (delegate_)
       delegate_->OnError(this, result);
     proxy_info_.UseDirect();
   }
+  if (proxy_info_.is_direct()) {
+    // If proxy was not found for original URL (ie. websocket URL),

[tyoshino (SeeGerritForStatus), 2009/11/16 07:33:49]

i.e.

+    // try again with https URL, like Safari implementation.
+    // Note that we don't want to use http proxy, because we'll use tunnel
+    // proxy using CONNECT method, which is used by https proxy.
+    if (!proxy_url_.SchemeIs("https")) {
+      GURL::Replacements repl;
+      repl.SetSchemeStr("https");
+      proxy_url_ = url_.ReplaceComponents(repl);
+      DLOG(INFO) << "Try https proxy: " << proxy_url_;
+      next_state_ = STATE_RESOLVE_PROXY;
+      return OK;
+    }
+  }
 
   return OK;
 }
 
 int SocketStream::DoResolveHost() {
   next_state_ = STATE_RESOLVE_HOST_COMPLETE;
 
   if (proxy_info_.is_direct())
     proxy_mode_ = kDirectConnection;
   else if (proxy_info_.proxy_server().is_socks())
@@ skipping 441 matching lines @@
   return context_->proxy_service();
 }
 
 void SocketStream::GetInfoForTracker(
     RequestTracker<SocketStream>::RecentRequestInfo* info) const {
   info->original_url = url_;
   info->load_log = load_log_;
 }
 
 }  // namespace net