Add a new QuicChromiumClientSession::Handle class

net/quic/chromium/quic_chromium_client_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.
 //
 // A client specific QuicSession subclass.  This class owns the underlying
 // QuicConnection and QuicConnectionHelper objects.  The connection stores
 // a non-owning pointer to the helper so this session needs to ensure that
 // the helper outlives the connection.
 
 #ifndef NET_QUIC_CHROMIUM_QUIC_CHROMIUM_CLIENT_SESSION_H_
@@ skipping 48 matching lines @@
 namespace test {
 class QuicChromiumClientSessionPeer;
 }  // namespace test
 
 class NET_EXPORT_PRIVATE QuicChromiumClientSession
     : public QuicClientSessionBase,
       public MultiplexedSession,
       public QuicChromiumPacketReader::Visitor,
       public QuicChromiumPacketWriter::Delegate {
  public:
-  // An interface for observing events on a session.
-  class NET_EXPORT_PRIVATE Observer {
+  class StreamRequest;
+
+  // Wrapper for interacting with the session in a restricted fashion which
+  // hides the details of the underlying session's lifetime. All methods of
+  // the Handle are safe to use even after the underlying session is destroyed.
+  class NET_EXPORT_PRIVATE Handle : public MultiplexedSessionHandle {

[xunjieli, 2017/05/04 16:54:42]

Can we disallow copy and assign for this class so know where instances of Handle
are created?

[Ryan Hamilton, 2017/05/05 03:50:24]

Done.

    public:
-    virtual ~Observer() {}
-    virtual void OnCryptoHandshakeConfirmed() = 0;
-    virtual void OnSuccessfulVersionNegotiation(const QuicVersion& version) = 0;
-    virtual void OnSessionClosed(int error, bool port_migration_detected) = 0;
+    explicit Handle(const base::WeakPtr<QuicChromiumClientSession>& session);
+    Handle(const Handle& other);
+    ~Handle();
+
+    // Returns true if the session is still connected.
+    bool IsConnected() const;
+
+    // Returns true if the handshake has been confirmed.
+    // the handle is not valid.

[xunjieli, 2017/05/04 16:54:42]

nit: delete the second line.

[Ryan Hamilton, 2017/05/05 03:50:25]

Done.

+    bool IsCryptoHandshakeConfirmed() const;
+
+    // Returns a new stream request which can be used to create a new
+    // QUIC stream. If |requires_confirmation| is true, then the requested
+    // stream will not be created until the handshake as been confirmed.

[xunjieli, 2017/05/04 16:54:42]

nit: s/as/has

[Ryan Hamilton, 2017/05/05 03:50:24]

Removed this method completely. Yay! :)

+    std::unique_ptr<StreamRequest> CreateStreamRequest(
+        bool requires_confirmation) const;
+
+    // Sends Rst for the stream, and makes sure that future calls to
+    // IsClosedStream(id) return true, which ensures that any subsequent
+    // frames related to this stream will be ignored (modulo flow
+    // control accounting).
+    void ResetPromised(QuicStreamId id, QuicRstStreamErrorCode error_code);
+
+    // Returns a new packet bundler while will cause writes to be batched up
+    // until a packet is full, or the last bundler is destroyed.
+    std::unique_ptr<QuicConnection::ScopedPacketBundler> CreatePacketBundler(
+        QuicConnection::AckBundling bundling_mode);
+
+    // Populates network error details for this session.
+    void PopulateNetErrorDetails(NetErrorDetails* details) const;
+
+    // Returns the connection timing for the handshake of this session.
+    const LoadTimingInfo::ConnectTiming& GetConnectTiming();
+
+    // Signs the exported keying material used for Token Binding using key
+    // |*key| and puts the signature in |*out|. Returns a net error code.
+    Error GetTokenBindingSignature(crypto::ECPrivateKey* key,
+                                   TokenBindingType tb_type,
+                                   std::vector<uint8_t>* out);
+
+    // Returns true if |other| is a handle to the same session as this handle.
+    bool SharesSameSession(const Handle& other) const;
+
+    // Returns the QUIC version used by the session.
+    QuicVersion GetQuicVersion() const;
+
+    // Copies the remote udp address into |address| and returns a net error
+    // code.
+    int GetPeerAddress(IPEndPoint* address) const;
+
+    // Returns the push promise index associated with the session.
+    QuicClientPushPromiseIndex* GetPushPromiseIndex();
+
+    // Returns the session's server ID.
+    QuicServerId server_id() const { return server_id_; }
+
+    // Returns the session's net log.
+    const NetLogWithSource& net_log() const { return net_log_; }
+
+   private:
+    friend class QuicChromiumClientSession;
+    friend class QuicChromiumClientSession::StreamRequest;
+
+    // Waits for the handshake to be confirmed and invokes |callback| when
+    // that happens. If the handshake has already been confirmed, returns OK.
+    // If the connection has already been closed, returns a net error. If the
+    // connection closes before the handshake is confirmed, |callback| will
+    // be invoked with an error.
+    int WaitForHandshakeConfirmation(const CompletionCallback& callback);
+
+    // Called when the handshake is confirmed.
+    void OnCryptoHandshakeConfirmed();
+
+    // Called when the session is closed with a net error.
+    void OnSessionClosed(int error, bool port_migration_detected);
+
+    // Called by |request| to create a stream.
+    int TryCreateStream(StreamRequest* request);
+
+    // Called by |request| to cancel stream request.
+    void CancelRequest(StreamRequest* request);
+
+    base::WeakPtr<QuicChromiumClientSession> session_;
+    NetLogWithSource net_log_;
+
+    // Information latched from the session when it is closed.

[xunjieli, 2017/05/04 16:54:42]

nit: consider rephrasing "latched" to "saved" or something more general.

[Ryan Hamilton, 2017/05/05 03:50:24]

Heh, sure. "latched" is pretty common vocabulary in GFE land, but this isn't GFE
code :)

+    bool was_handshake_confirmed_;
+    int error_;
+    bool port_migration_detected_;
+    QuicServerId server_id_;
+    QuicVersion quic_version_;
+    LoadTimingInfo::ConnectTiming connect_timing_;
+    QuicClientPushPromiseIndex* push_promise_index_;
   };
 
   // A helper class used to manage a request to create a stream.
   class NET_EXPORT_PRIVATE StreamRequest {
    public:
     // Cancels any pending stream creation request and resets |stream_| if
     // it has not yet been released.
     ~StreamRequest();
 
     // Starts a request to create a stream.  If OK is returned, then
     // |stream_| will be updated with the newly created stream.  If
     // ERR_IO_PENDING is returned, then when the request is eventuallly
     // complete |callback| will be called.
     int StartRequest(const CompletionCallback& callback);
 
     // Releases |stream_| to the caller
     QuicChromiumClientStream* ReleaseStream();
 
    private:
     friend class QuicChromiumClientSession;
 
     enum State {
       STATE_NONE,
       STATE_WAIT_FOR_CONFIRMATION,
       STATE_WAIT_FOR_CONFIRMATION_COMPLETE,
       STATE_REQUEST_STREAM,
       STATE_REQUEST_STREAM_COMPLETE,
     };
 
-    StreamRequest(const base::WeakPtr<QuicChromiumClientSession>& session,
+    StreamRequest(QuicChromiumClientSession::Handle session,
                   bool requires_confirmation);
 
     void OnIOComplete(int rv);
     void DoCallback(int rv);
 
     int DoLoop(int rv);
     int DoWaitForConfirmation();
     int DoWaitForConfirmationComplete(int rv);
     int DoRequestStream();
     int DoRequestStreamComplete(int rv);
 
     // Called by |session_| for an asynchronous request when the stream
     // request has finished successfully.
     void OnRequestCompleteSuccess(QuicChromiumClientStream* stream);
 
     // Called by |session_| for an asynchronous request when the stream
     // request has finished with an error. Also called with ERR_ABORTED
     // if |session_| is destroyed while the stream request is still pending.
     void OnRequestCompleteFailure(int rv);
 
-    base::WeakPtr<QuicChromiumClientSession> session_;
+    QuicChromiumClientSession::Handle session_;
     const bool requires_confirmation_;
     CompletionCallback callback_;
     QuicChromiumClientStream* stream_;
     // For tracking how much time pending stream requests wait.
     base::TimeTicks pending_start_time_;
     State next_state_;
 
     base::WeakPtrFactory<StreamRequest> weak_factory_;
 
     DISALLOW_COPY_AND_ASSIGN(StreamRequest);
@@ skipping 22 matching lines @@
       base::TimeTicks dns_resolution_end_time,
       QuicClientPushPromiseIndex* push_promise_index,
       ServerPushDelegate* push_delegate,
       base::TaskRunner* task_runner,
       std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
       NetLog* net_log);
   ~QuicChromiumClientSession() override;
 
   void Initialize() override;
 
-  void AddObserver(Observer* observer);
-  void RemoveObserver(Observer* observer);
+  void AddHandle(Handle* handle);
+  void RemoveHandle(Handle* handle);
 
   // Waits for the handshake to be confirmed and invokes |callback| when
   // that happens. If the handshake has already been confirmed, returns OK.
   // If the connection has already been closed, returns a net error. If the
   // connection closes before the handshake is confirmed, |callback| will
   // be invoked with an error.
   int WaitForHandshakeConfirmation(const CompletionCallback& callback);
 
-  // Returns a new stream request which can be used to create a new
-  // QUIC stream. If |requires_confirmation| is true, then the requested
-  // stream will not be created until the handshake as been confirmed.
-  std::unique_ptr<StreamRequest> CreateStreamRequest(
-      bool requires_confirmation);
-
   // Attempts to create a new stream.  If the stream can be
   // created immediately, returns OK.  If the open stream limit
   // has been reached, returns ERR_IO_PENDING, and |request|
   // will be added to the stream requets queue and will
   // be completed asynchronously.
   // TODO(rch): remove |stream| from this and use setter on |request|
   // and fix in spdy too.
   int TryCreateStream(StreamRequest* request);
 
   // Cancels the pending stream creation request.
@@ skipping 62 matching lines @@
 
   // Close the session because of |net_error| and notifies the factory
   // that this session has been closed, which will delete the session.
   void CloseSessionOnError(int net_error, QuicErrorCode quic_error);
 
   std::unique_ptr<base::Value> GetInfoAsValue(
       const std::set<HostPortPair>& aliases);
 
   const NetLogWithSource& net_log() const { return net_log_; }
 
-  base::WeakPtr<QuicChromiumClientSession> GetWeakPtr();
+  // Return a Handle to this session.
+  QuicChromiumClientSession::Handle GetHandle();
 
   // Returns the number of client hello messages that have been sent on the
   // crypto stream. If the handshake has completed then this is one greater
   // than the number of round-trips needed for the handshake.
   int GetNumSentClientHellos() const;
 
   // Returns the stream id of the push stream if it is not claimed yet, or 0
   // otherwise.
   QuicStreamId GetStreamIdForPush(const GURL& pushed_url);
 
@@ skipping 31 matching lines @@
                           const NetLogWithSource& net_log);
 
   // Schedules a migration alarm to wait for a new network.
   void OnNoNewNetwork();
 
   // Called when migration alarm fires. If migration has not occurred
   // since alarm was set, closes session with error.
   void OnMigrationTimeout(size_t num_sockets);
 
   // Populates network error details for this session.
-  void PopulateNetErrorDetails(NetErrorDetails* details);
+  void PopulateNetErrorDetails(NetErrorDetails* details) const;
 
   // Returns current default socket. This is the socket over which all
   // QUIC packets are sent. This default socket can change, so do not store the
   // returned socket.
   const DatagramClientSocket* GetDefaultSocket() const;
 
   bool IsAuthorized(const std::string& hostname) override;
 
   // Returns true if session has one ore more streams marked as non-migratable.
   bool HasNonMigratableStreams() const;
@@ skipping 23 matching lines @@
   // QuicSession methods:
   bool ShouldCreateIncomingDynamicStream(QuicStreamId id) override;
   bool ShouldCreateOutgoingDynamicStream() override;
 
   QuicChromiumClientStream* CreateIncomingDynamicStream(
       QuicStreamId id) override;
 
  private:
   friend class test::QuicChromiumClientSessionPeer;
 
-  typedef std::set<Observer*> ObserverSet;
+  typedef std::set<Handle*> HandleSet;
   typedef std::list<StreamRequest*> StreamRequestQueue;
 
   QuicChromiumClientStream* CreateOutgoingReliableStreamImpl();
   QuicChromiumClientStream* CreateIncomingReliableStreamImpl(QuicStreamId id);
   // A completion callback invoked when a read completes.
   void OnReadComplete(int result);
 
   void OnClosedStream();
 
   void CloseAllStreams(int net_error);
-  void CloseAllObservers(int net_error);
+  void CloseAllHandles(int net_error);
   void CancelAllRequests(int net_error);
   void NotifyRequestsOfConfirmation(int net_error);
 
   // Notifies the factory that this session is going away and no more streams
   // should be created from it.  This needs to be called before closing any
   // streams, because closing a stream may cause a new stream to be created.
   void NotifyFactoryOfSessionGoingAway();
 
   // Posts a task to notify the factory that this session has been closed.
   void NotifyFactoryOfSessionClosedLater();
 
   // Notifies the factory that this session has been closed which will
   // delete |this|.
   void NotifyFactoryOfSessionClosed();
 
   QuicServerId server_id_;
   bool require_confirmation_;
   std::unique_ptr<QuicCryptoClientStream> crypto_stream_;
   QuicStreamFactory* stream_factory_;
   std::vector<std::unique_ptr<DatagramClientSocket>> sockets_;
   TransportSecurityState* transport_security_state_;
   std::unique_ptr<QuicServerInfo> server_info_;
   std::unique_ptr<CertVerifyResult> cert_verify_result_;
   std::unique_ptr<ct::CTVerifyResult> ct_verify_result_;
   std::string pinning_failure_log_;
   bool pkp_bypassed_;
-  ObserverSet observers_;
+  HandleSet handles_;
   StreamRequestQueue stream_requests_;
   std::vector<CompletionCallback> waiting_for_confirmation_callbacks_;
   CompletionCallback callback_;
   size_t num_total_streams_;
   base::TaskRunner* task_runner_;
   NetLogWithSource net_log_;
   std::vector<std::unique_ptr<QuicChromiumPacketReader>> packet_readers_;
   LoadTimingInfo::ConnectTiming connect_timing_;
   std::unique_ptr<QuicConnectionLogger> logger_;
   // True when the session is going away, and streams may no longer be created
@@ skipping 11 matching lines @@
   uint64_t bytes_pushed_count_;
   uint64_t bytes_pushed_and_unclaimed_count_;
   // Stores packet that witnesses socket write error. This packet is
   // written to a new socket after migration completes.
   scoped_refptr<StringIOBuffer> packet_;
   // TODO(jri): Replace use of migration_pending_ sockets_.size().
   // When a task is posted for MigrateSessionOnError, pass in
   // sockets_.size(). Then in MigrateSessionOnError, check to see if
   // the current sockets_.size() == the passed in value.
   bool migration_pending_;  // True while migration is underway.
+  std::unique_ptr<Handle> self_handle_;  // Handle to this session
   base::WeakPtrFactory<QuicChromiumClientSession> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicChromiumClientSession);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CHROMIUM_QUIC_CHROMIUM_CLIENT_SESSION_H_