SPDY: Make sure we don't try to send https/wss over an unauthenticated, but encrypted SSL socket.

net/spdy/spdy_session.h

 // 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.
 
 #ifndef NET_SPDY_SPDY_SESSION_H_
 #define NET_SPDY_SPDY_SESSION_H_
 
 #include <deque>
 #include <list>
 #include <map>
@@ skipping 41 matching lines @@
   // Returns net::Error::OK on success.
   // Note that this call does not wait for the connect to complete. Callers can
   // immediately start using the SpdySession while it connects.
   net::Error Connect(const std::string& group_name,
                      const TCPSocketParams& destination,
                      RequestPriority priority);
 
   // Get a pushed stream for a given |url|.
   // If the server initiates a stream, it might already exist for a given path.
   // The server might also not have initiated the stream yet, but indicated it
-  // will via X-Associated-Content.
-  // Returns existing stream or NULL.
-  scoped_refptr<SpdyStream> GetPushStream(
+  // will via X-Associated-Content.  Writes the stream out to |spdy_stream|.
+  // Returns a net error code.
+  int GetPushStream(
       const GURL& url,
+      scoped_refptr<SpdyStream>* spdy_stream,
       const BoundNetLog& stream_net_log);
 
-  // Create a new stream for a given |url|.
-  // Returns the new stream.  Never returns NULL.
-  const scoped_refptr<SpdyStream>& CreateStream(
+  // Create a new stream for a given |url|.  Writes it out to |spdy_stream|.
+  // Returns a net error code.
+  int CreateStream(
       const GURL& url,
       RequestPriority priority,
+      scoped_refptr<SpdyStream>* spdy_stream,
       const BoundNetLog& stream_net_log);
 
   // Used by SpdySessionPool to initialize with a pre-existing SSL socket.
   // Returns OK on success, or an error on failure.
-  net::Error InitializeWithSSLSocket(ClientSocketHandle* connection);
+  net::Error InitializeWithSSLSocket(ClientSocketHandle* connection,
+                                     int certificate_error_code);
 
   // Send the SYN frame for |stream_id|.
   int WriteSynStream(
       spdy::SpdyStreamId stream_id,
       RequestPriority priority,
       spdy::SpdyControlFlags flags,
       const linked_ptr<spdy::SpdyHeaderBlock>& headers);
 
   // Write a data frame to the stream.
   // Used to create and queue a data frame for the given stream.
@@ skipping 156 matching lines @@
   // The packet we are currently sending.
   bool write_pending_;            // Will be true when a write is in progress.
   SpdyIOBuffer in_flight_write_;  // This is the write buffer in progress.
 
   // Flag if we have a pending message scheduled for WriteSocket.
   bool delayed_write_pending_;
 
   // Flag if we're using an SSL connection for this SpdySession.
   bool is_secure_;
 
+  // Certificate error code when using a secure connection.
+  int certificate_error_code_;
+
   // Spdy Frame state.
   spdy::SpdyFramer spdy_framer_;
 
   // If an error has occurred on the session, the session is effectively
   // dead.  Record this error here.  When no error has occurred, |error_| will
   // be OK.
   net::Error error_;
   State state_;
 
   // Some statistics counters for the session.
   int streams_initiated_count_;
   int streams_pushed_count_;
   int streams_pushed_and_claimed_count_;
   int streams_abandoned_count_;
   bool sent_settings_;      // Did this session send settings when it started.
   bool received_settings_;  // Did this session receive at least one settings
                             // frame.
 
   bool in_session_pool_;  // True if the session is currently in the pool.
 
   BoundNetLog net_log_;
 
   static bool use_ssl_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_