Remove |certificate_error_code| and SpdySession::TryAccessStream().

net/spdy/spdy_session.h

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 
@@ skipping 315 matching lines @@
                     const NetLogWithSource& stream_net_log);
 
   // Initialize the session with the given connection. |is_secure|
   // must indicate whether |connection| uses an SSL socket or not; it
   // is usually true, but it can be false for testing or when SPDY is
   // configured to work with non-secure sockets.
   //
   // |pool| is the SpdySessionPool that owns us.  Its lifetime must
   // strictly be greater than |this|.
   //
-  // |certificate_error_code| must either be OK or less than
-  // ERR_IO_PENDING.

[Ryan Hamilton, 2016/09/27 17:17:50]

OH! I'll bet this is a hold-over from the days when we could do spdy for http
urls even if the cert didn't validate.

-  //
   // The session begins reading from |connection| on a subsequent event loop
   // iteration, so the SpdySession may close immediately afterwards if the first
   // read of |connection| fails.
   void InitializeWithSocket(std::unique_ptr<ClientSocketHandle> connection,
                             SpdySessionPool* pool,
-                            bool is_secure,
-                            int certificate_error_code);
+                            bool is_secure);
 
   // Check to see if this SPDY session can support an additional domain.
   // If the session is un-authenticated, then this call always returns true.
   // For SSL-based sessions, verifies that the server certificate in use by
   // this session provides authentication for the domain and no client
   // certificate or channel ID was sent to the original server during the SSL
   // handshake.  NOTE:  This function can have false negatives on some
   // platforms.
   // TODO(wtc): rename this function and the Net.SpdyIPPoolDomainMatch
   // histogram because this function does more than verifying domain
@@ skipping 282 matching lines @@
     READ_STATE_DO_READ_COMPLETE,
   };
 
   enum WriteState {
     // There is no in-flight write and the write queue is empty.
     WRITE_STATE_IDLE,
     WRITE_STATE_DO_WRITE,
     WRITE_STATE_DO_WRITE_COMPLETE,
   };
 
-  // Checks whether a stream for the given |url| can be created or
-  // retrieved from the set of unclaimed push streams. Returns OK if
-  // so. Otherwise, the session is closed and an error <
-  // ERR_IO_PENDING is returned.
-  Error TryAccessStream(const GURL& url);
-
   // Called by SpdyStreamRequest to start a request to create a
   // stream. If OK is returned, then |stream| will be filled in with a
   // valid stream. If ERR_IO_PENDING is returned, then
   // |request->OnRequestComplete{Success,Failure}()| will be called
   // when the stream is created (unless it is cancelled). Otherwise,
   // no stream is created and the error is returned.
   int TryCreateStream(const base::WeakPtr<SpdyStreamRequest>& request,
                       base::WeakPtr<SpdyStream>* stream);
 
   // Actually create a stream into |stream|. Returns OK if successful;
@@ skipping 407 matching lines @@
   SpdyFrameType in_flight_write_frame_type_;
   // The size of the frame in |in_flight_write_|.
   size_t in_flight_write_frame_size_;
   // The stream to notify when |in_flight_write_| has been written to
   // the socket completely.
   base::WeakPtr<SpdyStream> in_flight_write_stream_;
 
   // 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.
   std::unique_ptr<BufferedSpdyFramer> buffered_spdy_framer_;
 
   // The state variables.
   AvailabilityState availability_state_;
   ReadState read_state_;
   WriteState write_state_;
 
   // If the session is closing (i.e., |availability_state_| is STATE_DRAINING),
   // then |error_on_close_| holds the error with which it was closed, which
@@ skipping 118 matching lines @@
   // Used for posting asynchronous IO tasks.  We use this even though
   // SpdySession is refcounted because we don't need to keep the SpdySession
   // alive if the last reference is within a RunnableMethod.  Just revoke the
   // method.
   base::WeakPtrFactory<SpdySession> weak_factory_;
 };
 
 }  // namespace net
 
 #endif  // NET_SPDY_SPDY_SESSION_H_